{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":8616088,"sourceType":"datasetVersion","datasetId":4906925}],"dockerImageVersionId":30732,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"A **neural network model** for **classification** is a computational framework designed to classify data into predefined classes. It consists of **interconnected layers** of **neurons**, where each *neuron applies a mathematical operation to its input and passes the result to the next layer*. The model typically includes an input layer that receives the raw data, **one or more hidden layers** that learn intricate patterns through **weighted connections** and **activation functions**, and an *output layer that produces the final class predictions*. The ability of neural networks to capture **non-linear patterns** in data through the use of non-linear activation functions is a key factor in their effectiveness. During training, the model **adjusts its weights** using a process called **backpropagation**, which *minimizes the discrepancy between the predicted and actual class labels*. Neural network classifiers are widely used due to their ability to handle complex and high-dimensional datasets, making them effective for tasks like image recognition, text classification, and medical diagnosis.","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19"}},{"cell_type":"markdown","source":"### Read the Data","metadata":{}},{"cell_type":"code","source":"import pandas as pd\n\n# Read the training datasets\nX_train_original = pd.read_csv('/kaggle/input/bankloan-ready-to-modeling/X_train_original.csv')\nX_train_original = X_train_original.set_index('Unnamed: 0')\n\nX_train_transformed = pd.read_csv('/kaggle/input/bankloan-ready-to-modeling/X_train_transformed.csv')\nX_train_transformed = X_train_transformed.set_index('Unnamed: 0')\n\nX_train_discretized = pd.read_csv('/kaggle/input/bankloan-ready-to-modeling/X_train_discretized.csv')\nX_train_discretized = X_train_discretized.set_index('Unnamed: 0')\n\n# Read the test datasets\nX_test_original = pd.read_csv('/kaggle/input/bankloan-ready-to-modeling/X_test_original.csv')\nX_test_original = X_test_original.set_index('Unnamed: 0')\n\nX_test_transformed = pd.read_csv('/kaggle/input/bankloan-ready-to-modeling/X_test_transformed.csv')\nX_test_transformed = X_test_transformed.set_index('Unnamed: 0')\n\nX_test_discretized = pd.read_csv('/kaggle/input/bankloan-ready-to-modeling/X_test_discretized.csv')\nX_test_discretized = X_test_discretized.set_index('Unnamed: 0')\n\n# Read the target variable for training and testing\ny_train = pd.read_csv('/kaggle/input/bankloan-ready-to-modeling/y_train.csv')\ny_train = y_train.set_index('Unnamed: 0').squeeze()\n\ny_test = pd.read_csv('/kaggle/input/bankloan-ready-to-modeling/y_test.csv')\ny_test = y_test.set_index('Unnamed: 0').squeeze() \n","metadata":{"execution":{"iopub.status.busy":"2024-06-25T15:42:29.983759Z","iopub.execute_input":"2024-06-25T15:42:29.984184Z","iopub.status.idle":"2024-06-25T15:42:30.099014Z","shell.execute_reply.started":"2024-06-25T15:42:29.984151Z","shell.execute_reply":"2024-06-25T15:42:30.098227Z"},"trusted":true},"execution_count":5,"outputs":[]},{"cell_type":"markdown","source":"### Train and Validate the Neural Network Model","metadata":{}},{"cell_type":"markdown","source":"consider these model parameters:  \n\n#### hidden_layer_sizes\n- **Type**: array-like of shape (n_layers - 2,)\n- **Default**: (100,)\n- **Description**: The ith element represents the number of neurons in the ith hidden layer.\n\n#### activation\n- **Type**: {'identity', 'logistic', 'tanh', 'relu'}\n- **Default**: 'relu'\n- **Description**: Activation function for the hidden layer.\n    - **'identity'**: No-op activation, useful to implement linear bottleneck, returns f(x) = x.\n    - **'logistic'**: The logistic sigmoid function, returns f(x) = 1 / (1 + exp(-x)).\n    - **'tanh'**: The hyperbolic tan function, returns f(x) = tanh(x).\n    - **'relu'**: The rectified linear unit function, returns f(x) = max(0, x).\n\n#### solver\n- **Type**: {'lbfgs', 'sgd', 'adam'}\n- **Default**: 'adam'\n- **Description**: The solver for weight optimization.\n    - **'lbfgs'**: An optimizer in the family of quasi-Newton methods.\n    - **'sgd'**: Refers to stochastic gradient descent.\n    - **'adam'**: Refers to a stochastic gradient-based optimizer proposed by Kingma, Diederik, and Jimmy Ba.\n    - **Note**: The default solver 'adam' works well on relatively large datasets (with thousands of training samples or more) in terms of both training time and validation score. For small datasets, 'lbfgs' can converge faster and perform better.\n\n#### alpha\n- **Type**: float\n- **Default**: 0.0001\n- **Description**: Strength of the L2 regularization term. The L2 regularization term is divided by the sample size when added to the loss.\n    - **Example**: For an example usage and visualization of varying regularization, see [Varying regularization in Multi-layer Perceptron](https://scikit-learn.org/stable/auto_examples/neural_networks/plot_mlp_alpha.html).\n\n#### batch_size\n- **Type**: int\n- **Default**: 'auto'\n- **Description**: Size of minibatches for stochastic optimizers. If the solver is 'lbfgs', the classifier will not use minibatch. When set to \"auto\", batch_size=min(200, n_samples).\n\n#### learning_rate\n- **Type**: {'constant', 'invscaling', 'adaptive'}\n- **Default**: 'constant'\n- **Description**: Learning rate schedule for weight updates.\n    - **'constant'**: A constant learning rate given by 'learning_rate_init'.\n    - **'invscaling'**: Gradually decreases the learning rate at each time step 't' using an inverse scaling exponent of 'power_t'. Effective learning rate = learning_rate_init / pow(t, power_t).\n    - **'adaptive'**: Keeps the learning rate constant to 'learning_rate_init' as long as training loss keeps decreasing. Each time two consecutive epochs fail to decrease training loss by at least tol, or fail to increase validation score by at least tol if 'early_stopping' is on, the current learning rate is divided by 5.\n    - **Note**: Only used when solver='sgd'.\n\n#### learning_rate_init\n- **Type**: float\n- **Default**: 0.001\n- **Description**: The initial learning rate used. It controls the step-size in updating the weights. Only used when solver='sgd' or 'adam'.\n\n#### max_iter\n- **Type**: int\n- **Default**: 200\n- **Description**: Maximum number of iterations. The solver iterates until convergence (determined by 'tol') or this number of iterations. For stochastic solvers ('sgd', 'adam'), this determines the number of epochs (how many times each data point will be used), not the number of gradient steps.\n\n#### random_state\n- **Type**: int, RandomState instance\n- **Default**: None\n- **Description**: Determines random number generation for weights and bias initialization, train-test split if early stopping is used, and batch sampling when solver='sgd' or 'adam'. Pass an int for reproducible results across multiple function calls. See [Glossary](https://scikit-learn.org/stable/glossary.html#term-random-state).\n  \n#### n_iter_no_change\n- **Type**: int\n- **Default**: 10\n- **Description**: Maximum number of epochs to not meet tol improvement. Only effective when solver='sgd' or 'adam'.  \n\n*This markdown presents the model parameters for the KNN algorithm in a format similar to that of the sklearn documentation.*","metadata":{}},{"cell_type":"code","source":"from sklearn.neural_network import MLPClassifier\nfrom sklearn.metrics import confusion_matrix, classification_report\n\nmodel = MLPClassifier(hidden_layer_sizes=(10), activation='relu', solver='adam', alpha=0, batch_size=20,\n                learning_rate='constant', learning_rate_init=0.001, max_iter=1000, random_state=111, n_iter_no_change=10)\n\nmodel.fit(X_train_original, y_train)\n\ny_pred_train = model.predict(X_train_original)\ny_pred_test = model.predict(X_test_original)\n\ncm_train = confusion_matrix(y_train, y_pred_train)\nreport_train = classification_report(y_train, y_pred_train)\n\ncm_test = confusion_matrix(y_test, y_pred_test)\nreport_test = classification_report(y_test, y_pred_test)\n\nprint(\"Evaluation the Model on Training Set\")\nprint(f\"Confusion Matrix:\\n{cm_train}\")\nprint(f\"Classification Report:\\n{report_train}\")\nprint(\"-\"*80)\nprint(\"Evaluation the Model on Testing Set\")\nprint(f\"Confusion Matrix:\\n{cm_test}\")\nprint(f\"Classification Report:\\n{report_test}\")","metadata":{"execution":{"iopub.status.busy":"2024-06-22T18:52:39.639106Z","iopub.execute_input":"2024-06-22T18:52:39.639957Z","iopub.status.idle":"2024-06-22T18:52:45.451175Z","shell.execute_reply.started":"2024-06-22T18:52:39.639922Z","shell.execute_reply":"2024-06-22T18:52:45.450210Z"},"trusted":true},"execution_count":17,"outputs":[{"name":"stdout","text":"Evaluation the Model on Training Set\nConfusion Matrix:\n[[341  23]\n [ 45  76]]\nClassification Report:\n              precision    recall  f1-score   support\n\n           0       0.88      0.94      0.91       364\n           1       0.77      0.63      0.69       121\n\n    accuracy                           0.86       485\n   macro avg       0.83      0.78      0.80       485\nweighted avg       0.85      0.86      0.85       485\n\n--------------------------------------------------------------------------------\nEvaluation the Model on Testing Set\nConfusion Matrix:\n[[142  11]\n [ 29  28]]\nClassification Report:\n              precision    recall  f1-score   support\n\n           0       0.83      0.93      0.88       153\n           1       0.72      0.49      0.58        57\n\n    accuracy                           0.81       210\n   macro avg       0.77      0.71      0.73       210\nweighted avg       0.80      0.81      0.80       210\n\n","output_type":"stream"}]},{"cell_type":"markdown","source":"### Identify the Optimal Model through Hyperparameter Tuning","metadata":{}},{"cell_type":"markdown","source":"Since the ANN model does not inherently address class imbalance, I utilized a **sampling method** to tackle this challenge. You can find the approach used in this notebook: https://www.kaggle.com/code/zahrazolghadr/overcoming-imbalanced-data-challenges","metadata":{}},{"cell_type":"code","source":"from imblearn.over_sampling import SMOTE\nfrom sklearn.neural_network import MLPClassifier\nfrom sklearn.metrics import make_scorer, f1_score\nfrom sklearn.model_selection import GridSearchCV\n\ndef ANN_modeling(X_train, y_train, X_test, y_test):\n    \n    # Perform SMOTE oversampling\n    smote = SMOTE(random_state=1)\n    X_train_smote, y_train_smote = smote.fit_resample(X_train, y_train)\n\n    # Define a custom scorer for class '1' F1-score\n    def custom_f1_scorer(y_true, y_pred):\n        return f1_score(y_true, y_pred, pos_label=1)\n\n    custom_scorer = make_scorer(custom_f1_scorer)\n\n    # Initialize the KNeighborsClassifier\n    ann = MLPClassifier(solver='adam', alpha=0, batch_size=20, learning_rate='constant', max_iter=10000, random_state=111)\n\n    # Set up the parameter grid\n    param_grid = {\n        'hidden_layer_sizes': [(3,), (5,), (10,), (20,), (10, 5), (20, 10)],  \n        'activation': ['relu', 'tanh', 'logistic'],\n        'learning_rate_init': [0.001, 0.01, 0.1],\n        'n_iter_no_change': [10, 20, 30]\n    }\n\n    # Perform Grid Search with custom F1 scorer\n    grid_search = GridSearchCV(ann, param_grid, scoring=custom_scorer, cv=5, n_jobs=-1)\n\n    # Fit the model\n    grid_search.fit(X_train_smote, y_train_smote)\n\n    # Print the best parameters and the best score\n    print(\"Best parameters found: \", grid_search.best_params_)\n    print(\"Best custom F1 score: \", grid_search.best_score_)\n\n    # Evaluate the best model on the test set\n    best_ann = grid_search.best_estimator_\n    y_pred = best_ann.predict(X_test)\n    custom_f1 = custom_f1_scorer(y_test, y_pred)\n\n    print(f\"Custom F1 Score on test set: {custom_f1}\")\n    \n    return\n","metadata":{"execution":{"iopub.status.busy":"2024-06-22T17:44:58.981954Z","iopub.execute_input":"2024-06-22T17:44:58.982562Z","iopub.status.idle":"2024-06-22T17:44:58.992741Z","shell.execute_reply.started":"2024-06-22T17:44:58.982530Z","shell.execute_reply":"2024-06-22T17:44:58.991723Z"},"trusted":true},"execution_count":12,"outputs":[]},{"cell_type":"code","source":"ANN_modeling(X_train_original, y_train, X_test_original, y_test)","metadata":{"execution":{"iopub.status.busy":"2024-06-22T17:45:20.333616Z","iopub.execute_input":"2024-06-22T17:45:20.334024Z","iopub.status.idle":"2024-06-22T17:52:10.958244Z","shell.execute_reply.started":"2024-06-22T17:45:20.333993Z","shell.execute_reply":"2024-06-22T17:52:10.956948Z"},"trusted":true},"execution_count":13,"outputs":[{"name":"stderr","text":"/opt/conda/lib/python3.10/site-packages/joblib/externals/loky/backend/fork_exec.py:38: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n  pid = os.fork()\n/opt/conda/lib/python3.10/site-packages/joblib/externals/loky/backend/fork_exec.py:38: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n  pid = os.fork()\n","output_type":"stream"},{"name":"stdout","text":"Best parameters found:  {'activation': 'tanh', 'hidden_layer_sizes': (20,), 'learning_rate_init': 0.01, 'n_iter_no_change': 30}\nBest custom F1 score:  0.8720188861910716\nCustom F1 Score on test set: 0.5882352941176471\n","output_type":"stream"}]},{"cell_type":"code","source":"ANN_modeling(X_train_transformed, y_train, X_test_transformed, y_test)","metadata":{"execution":{"iopub.status.busy":"2024-06-22T17:53:01.883812Z","iopub.execute_input":"2024-06-22T17:53:01.884186Z","iopub.status.idle":"2024-06-22T17:59:27.142269Z","shell.execute_reply.started":"2024-06-22T17:53:01.884151Z","shell.execute_reply":"2024-06-22T17:59:27.141210Z"},"trusted":true},"execution_count":14,"outputs":[{"name":"stdout","text":"Best parameters found:  {'activation': 'tanh', 'hidden_layer_sizes': (20, 10), 'learning_rate_init': 0.01, 'n_iter_no_change': 20}\nBest custom F1 score:  0.8768813465015997\nCustom F1 Score on test set: 0.6037735849056605\n","output_type":"stream"}]},{"cell_type":"code","source":"ANN_modeling(X_train_discretized, y_train, X_test_discretized, y_test)","metadata":{"execution":{"iopub.status.busy":"2024-06-22T17:59:37.038286Z","iopub.execute_input":"2024-06-22T17:59:37.038805Z","iopub.status.idle":"2024-06-22T18:05:34.317595Z","shell.execute_reply.started":"2024-06-22T17:59:37.038768Z","shell.execute_reply":"2024-06-22T18:05:34.316542Z"},"trusted":true},"execution_count":15,"outputs":[{"name":"stdout","text":"Best parameters found:  {'activation': 'relu', 'hidden_layer_sizes': (20, 10), 'learning_rate_init': 0.1, 'n_iter_no_change': 30}\nBest custom F1 score:  0.8777184335305297\nCustom F1 Score on test set: 0.4770642201834862\n","output_type":"stream"}]},{"cell_type":"markdown","source":"# Neural Networks with Keras\n\n## 1. Deep Neural Networks\n\nTraditional neural networks, such as **shallow Multi-Layer Perceptrons** (MLPs), consist of an input layer, one or two hidden layers, and an output layer. Deep neural networks (DNNs), in contrast, have multiple hidden layers. This depth allows them to model more complex patterns in data, making them suitable for a wide range of tasks, including image and speech recognition, natural language processing, and more. Key advantages include:\n\n- **Automatic Feature Learning**: Deep networks can automatically learn features from raw data, reducing the need for manual feature engineering.\n- **Improved Performance**: Capable of achieving higher accuracy and better generalization on complex tasks.\n- **Scalability**: Better suited for large-scale datasets and high-dimensional data.  \n\n![image.png](attachment:4ae9ebfe-d500-4856-a566-0ee6bbfe010f.png)\n\n## 2. Deep Learning\n\nDeep learning is a subset of machine learning focused on neural networks with many layers, enabling machines to learn from vast amounts of data and achieve high accuracy across various domains.\n\n## 3. Role of GPU and New Frameworks Such as Keras\n\nGPUs accelerate deep learning by handling thousands of parallel operations, significantly speeding up model training. Keras provides a user-friendly, high-level API for building and training deep learning models, leveraging the power of frameworks like TensorFlow.\n\n## 4. Important Structure for Running Models with Keras\n\nKeras is a high-level neural networks API, written in Python, and capable of running on top of TensorFlow, CNTK, or Theano. It simplifies the process of building and training deep learning models, making it accessible for both beginners and experts. Here are the key components and steps for implementing neural networks with Keras:\n\n### Key Components of Keras\n  \n#### Model Building\n\n- **Sequential API**: A simple and intuitive way to build models layer by layer.\n- **Functional API**: More flexible, allowing the creation of complex models such as multi-input/multi-output models.\n\n#### Layers\n\n- **Dense Layer**: Fully connected layer where each neuron connects to every neuron in the next layer.\n- **Convolutional Layer**: Essential for processing image data, capturing spatial hierarchies.\n- **Recurrent Layer**: Suitable for sequence data, such as text and time series, enabling the network to maintain information over time.\n\n#### Compilation\n\n- **Loss Functions**: Measure how well the model is performing. Common loss functions include `categorical_crossentropy` for classification and `mean_squared_error` for regression.\n- **Optimizers**: Algorithms to update the model's weights based on the loss function. Popular optimizers include `Adam`, `SGD`, and `RMSprop`.\n- **Metrics**: Used to evaluate the model’s performance during training and testing, such as `accuracy`.\n\n#### Training\n\n- **Fit Method**: Trains the model on the training data. Key parameters include:\n  - **Batch Size**: Number of samples processed before the model is updated.\n  - **Epochs**: Number of complete passes through the training dataset.\n","metadata":{},"attachments":{"4ae9ebfe-d500-4856-a566-0ee6bbfe010f.png":{"image/png":"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"}}},{"cell_type":"code","source":"from keras.models import Sequential\nfrom keras.layers import Dense\nfrom keras.optimizers import Adam\nfrom sklearn.metrics import confusion_matrix, classification_report\nimport random\n\n\nseed_value = 117\nrandom.seed(seed_value)\n\n\n# Build the model\nmodel = Sequential()\n\nmodel.add(Dense(units=64, activation='relu', input_shape=(8,)))\n\nmodel.add(Dense(units=64, activation='relu'))\n\nmodel.add(Dense(units=1, activation='sigmoid'))\n\n\n# Compile the model\nmodel.compile(optimizer=Adam(learning_rate=0.01), loss='binary_crossentropy', metrics=['f1_score'])\n\n\n# Train the model\nhistory = model.fit(X_train_transformed, y_train, epochs=100, batch_size=32, validation_split=0, verbose=1)\nmodel.summary()\n\n# Evaluate the model\ny_pred_train = (model.predict(X_train_transformed) > 0.5).astype(int)\ny_pred_test = (model.predict(X_test_transformed) > 0.5).astype(int)\n\ncm_train = confusion_matrix(y_train, y_pred_train)\nreport_train = classification_report(y_train, y_pred_train)\n\ncm_test = confusion_matrix(y_test, y_pred_test)\nreport_test = classification_report(y_test, y_pred_test)\n\nprint(\"Evaluation the Model on Training Set\")\nprint(f\"Confusion Matrix:\\n{cm_train}\")\nprint(f\"Classification Report:\\n{report_train}\")\nprint(\"-\"*80)\nprint(\"Evaluation the Model on Testing Set\")\nprint(f\"Confusion Matrix:\\n{cm_test}\")\nprint(f\"Classification Report:\\n{report_test}\")","metadata":{"trusted":true},"execution_count":9,"outputs":[{"name":"stdout","text":"\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 8ms/step\n\u001b[1m7/7\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 13ms/step\nEvaluation the Model on Training Set\nConfusion Matrix:\n[[364   0]\n [  0 121]]\nClassification Report:\n              precision    recall  f1-score   support\n\n           0       1.00      1.00      1.00       364\n           1       1.00      1.00      1.00       121\n\n    accuracy                           1.00       485\n   macro avg       1.00      1.00      1.00       485\nweighted avg       1.00      1.00      1.00       485\n\n--------------------------------------------------------------------------------\nEvaluation the Model on Testing Set\nConfusion Matrix:\n[[139  14]\n [ 34  23]]\nClassification Report:\n              precision    recall  f1-score   support\n\n           0       0.80      0.91      0.85       153\n           1       0.62      0.40      0.49        57\n\n    accuracy                           0.77       210\n   macro avg       0.71      0.66      0.67       210\nweighted avg       0.75      0.77      0.75       210\n\n","output_type":"stream"}]},{"cell_type":"code","source":"from imblearn.over_sampling import SMOTE\nfrom keras.models import Sequential\nfrom keras.layers import Dense\nfrom keras.optimizers import Adam\nimport keras_tuner as kt\n\n# Perform SMOTE oversampling\nsmote = SMOTE(random_state=1)\nX_train_smote, y_train_smote = smote.fit_resample(X_train_transformed, y_train)\n\n# Define a model-building function\ndef build_model(hp):\n    model = Sequential()\n    \n    # Tune the number of units in the first Dense layer\n    hp_units = hp.Int('units', min_value=8, max_value=128, step=8)\n    # Tune the activation function for the first Dense layer\n    hp_activation = hp.Choice('activation', values=['relu', 'tanh', 'sigmoid'])\n    model.add(Dense(units=hp_units, activation=hp_activation, input_shape=(8,)))\n  \n    # Tune the number of units in the second Dense layer\n    hp_units_2 = hp.Int('units_2', min_value=0, max_value=64, step=8)\n    model.add(Dense(units=hp_units_2, activation=hp_activation))\n    \n    model.add(Dense(1, activation='sigmoid'))\n    \n    # Tune the learning rate for the optimizer\n    hp_learning_rate = hp.Choice('learning_rate', values=[1e-2, 1e-3, 1e-4])\n    \n    model.compile(optimizer=Adam(learning_rate=hp_learning_rate),loss='binary_crossentropy', metrics=['f1_score'])\n    \n    return model\n\n# Instantiate the tuner using GridSearch\ntuner = kt.RandomSearch(\n    build_model,\n    objective='val_f1_score',\n    max_trials=200,  # Number of different hyperparameter combinations to try\n    executions_per_trial=1,  # Number of models to build and fit for each trial\n    seed=117,\n    directory='my_dir',\n    project_name='random_search_kt',\n    overwrite=True\n)\n\n# Perform the hyperparameter search\ntuner.search(X_train_smote, y_train_smote, epochs=50, validation_split=0.2, verbose=1)\n\n# Get the best model\nbest_model = tuner.get_best_models(num_models=1)[0]\n\n\nbest_model.summary()\nbest_model.save(\"best_nn_class.keras\")","metadata":{"execution":{"iopub.status.busy":"2024-06-24T19:07:28.576164Z","iopub.execute_input":"2024-06-24T19:07:28.576781Z","iopub.status.idle":"2024-06-24T19:38:17.705194Z","shell.execute_reply.started":"2024-06-24T19:07:28.576748Z","shell.execute_reply":"2024-06-24T19:38:17.704424Z"},"trusted":true},"execution_count":38,"outputs":[{"name":"stdout","text":"Trial 200 Complete [00h 00m 10s]\nval_f1_score: 1.0\n\nBest val_f1_score So Far: 1.0\nTotal elapsed time: 00h 30m 45s\n","output_type":"stream"},{"name":"stderr","text":"/opt/conda/lib/python3.10/site-packages/keras/src/layers/core/dense.py:87: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n/opt/conda/lib/python3.10/site-packages/keras/src/saving/saving_lib.py:415: UserWarning: Skipping variable loading for optimizer 'adam', because it has 2 variables whereas the saved optimizer has 14 variables. \n  saveable.load_own_variables(weights_store.get(inner_path))\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"\u001b[1mModel: \"sequential\"\u001b[0m\n","text/html":"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential\"</span>\n</pre>\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n┃\u001b[1m \u001b[0m\u001b[1mLayer (type)                   \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape          \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      Param #\u001b[0m\u001b[1m \u001b[0m┃\n┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n│ dense (\u001b[38;5;33mDense\u001b[0m)                   │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m)             │           \u001b[38;5;34m288\u001b[0m │\n├─────────────────────────────────┼────────────────────────┼───────────────┤\n│ dense_1 (\u001b[38;5;33mDense\u001b[0m)                 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m)             │         \u001b[38;5;34m2,112\u001b[0m │\n├─────────────────────────────────┼────────────────────────┼───────────────┤\n│ dense_2 (\u001b[38;5;33mDense\u001b[0m)                 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m)              │            \u001b[38;5;34m65\u001b[0m │\n└─────────────────────────────────┴────────────────────────┴───────────────┘\n","text/html":"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n┃<span style=\"font-weight: bold\"> Layer (type)                    </span>┃<span style=\"font-weight: bold\"> Output Shape           </span>┃<span style=\"font-weight: bold\">       Param # </span>┃\n┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n│ dense (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                   │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)             │           <span style=\"color: #00af00; text-decoration-color: #00af00\">288</span> │\n├─────────────────────────────────┼────────────────────────┼───────────────┤\n│ dense_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)             │         <span style=\"color: #00af00; text-decoration-color: #00af00\">2,112</span> │\n├─────────────────────────────────┼────────────────────────┼───────────────┤\n│ dense_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>)              │            <span style=\"color: #00af00; text-decoration-color: #00af00\">65</span> │\n└─────────────────────────────────┴────────────────────────┴───────────────┘\n</pre>\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"\u001b[1m Total params: \u001b[0m\u001b[38;5;34m2,465\u001b[0m (9.63 KB)\n","text/html":"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">2,465</span> (9.63 KB)\n</pre>\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m2,465\u001b[0m (9.63 KB)\n","text/html":"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">2,465</span> (9.63 KB)\n</pre>\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n","text/html":"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n</pre>\n"},"metadata":{}}]},{"cell_type":"code","source":"best_hps = tuner.get_best_hyperparameters(num_trials=1)[0]\n\nprint(\"The best hyperparameters are:\")\nprint(f\"Units (first layer): {best_hps.get('units')}\")\nprint(f\"Activation (first layer): {best_hps.get('activation')}\")\nprint(f\"Units (second layer): {best_hps.get('units_2')}\")\nprint(f\"Activation (second layer): {best_hps.get('activation')}\")\nprint(f\"Learning rate: {best_hps.get('learning_rate')}\")","metadata":{"execution":{"iopub.status.busy":"2024-06-24T19:42:42.344443Z","iopub.execute_input":"2024-06-24T19:42:42.345087Z","iopub.status.idle":"2024-06-24T19:42:42.351939Z","shell.execute_reply.started":"2024-06-24T19:42:42.345054Z","shell.execute_reply":"2024-06-24T19:42:42.351007Z"},"trusted":true},"execution_count":39,"outputs":[{"name":"stdout","text":"The best hyperparameters are:\nUnits (first layer): 32\nActivation (first layer): sigmoid\nUnits (second layer): 64\nActivation (second layer): sigmoid\nLearning rate: 0.001\n","output_type":"stream"}]},{"cell_type":"code","source":"from keras.models import Sequential\nfrom keras.layers import Dense\nfrom imblearn.over_sampling import SMOTE\nimport random\n\n\nseed_value = 117\nrandom.seed(seed_value)\n\n# Perform SMOTE oversampling\nsmote = SMOTE(random_state=1)\nX_train_smote, y_train_smote = smote.fit_resample(X_train_transformed, y_train)\n    \n# Build the model\nmodel = Sequential()\n\nmodel.add(Dense(units=32, activation='sigmoid', input_shape=(8,)))\n\nmodel.add(Dense(units=64, activation='sigmoid'))\n\nmodel.add(Dense(units=1, activation='sigmoid'))\n\n# Compile the model\nmodel.compile(optimizer=Adam(learning_rate=0.001), loss='binary_crossentropy', metrics=['f1_score'])\n\n# Train the model\nhistory = model.fit(X_train_smote, y_train_smote, epochs=100, batch_size=32, validation_split=0, verbose=1)\nmodel.summary()\n\n# Evaluate the model\ny_pred_train = (model.predict(X_train_smote) > 0.5).astype(int)\ny_pred_test = (model.predict(X_test_transformed) > 0.5).astype(int)\n\ncm_train = confusion_matrix(y_train_smote, y_pred_train)\nreport_train = classification_report(y_train_smote, y_pred_train)\n\ncm_test = confusion_matrix(y_test, y_pred_test)\nreport_test = classification_report(y_test, y_pred_test)\n\nprint(\"Evaluation the Model on Training Set\")\nprint(f\"Confusion Matrix:\\n{cm_train}\")\nprint(f\"Classification Report:\\n{report_train}\")\nprint(\"-\"*80)\nprint(\"Evaluation the Model on Testing Set\")\nprint(f\"Confusion Matrix:\\n{cm_test}\")\nprint(f\"Classification Report:\\n{report_test}\")","metadata":{"execution":{"iopub.status.busy":"2024-06-25T16:52:10.539729Z","iopub.execute_input":"2024-06-25T16:52:10.540422Z","iopub.status.idle":"2024-06-25T16:52:18.895211Z","shell.execute_reply.started":"2024-06-25T16:52:10.540392Z","shell.execute_reply":"2024-06-25T16:52:18.894197Z"},"trusted":true},"execution_count":10,"outputs":[{"name":"stdout","text":"Epoch 1/100\n","output_type":"stream"},{"name":"stderr","text":"/opt/conda/lib/python3.10/site-packages/keras/src/layers/core/dense.py:87: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n","output_type":"stream"},{"name":"stdout","text":"\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 22ms/step - f1_score: 0.6807 - loss: 0.8527\nEpoch 2/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6507 - loss: 0.6778 \nEpoch 3/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6673 - loss: 0.6702 \nEpoch 4/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6484 - loss: 0.6598 \nEpoch 5/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6547 - loss: 0.6488 \nEpoch 6/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6700 - loss: 0.6299 \nEpoch 7/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6682 - loss: 0.6059 \nEpoch 8/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6977 - loss: 0.6009 \nEpoch 9/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6527 - loss: 0.5799 \nEpoch 10/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6775 - loss: 0.5560 \nEpoch 11/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step - f1_score: 0.6683 - loss: 0.5507 \nEpoch 12/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6578 - loss: 0.5415 \nEpoch 13/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6827 - loss: 0.5232 \nEpoch 14/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step - f1_score: 0.6501 - loss: 0.5214 \nEpoch 15/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6696 - loss: 0.5475 \nEpoch 16/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6667 - loss: 0.5185 \nEpoch 17/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6610 - loss: 0.4970 \nEpoch 18/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6428 - loss: 0.4914 \nEpoch 19/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step - f1_score: 0.6869 - loss: 0.5028 \nEpoch 20/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6906 - loss: 0.5032 \nEpoch 21/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6651 - loss: 0.5208 \nEpoch 22/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6832 - loss: 0.4895 \nEpoch 23/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6958 - loss: 0.5080 \nEpoch 24/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step - f1_score: 0.6562 - loss: 0.5172 \nEpoch 25/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6693 - loss: 0.5121 \nEpoch 26/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6705 - loss: 0.5009 \nEpoch 27/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6715 - loss: 0.4928 \nEpoch 28/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6236 - loss: 0.5051 \nEpoch 29/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6788 - loss: 0.4657 \nEpoch 30/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6345 - loss: 0.4542 \nEpoch 31/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6534 - loss: 0.4918 \nEpoch 32/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6847 - loss: 0.4770 \nEpoch 33/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6755 - loss: 0.4611 \nEpoch 34/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6714 - loss: 0.4817 \nEpoch 35/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6762 - loss: 0.4646 \nEpoch 36/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6630 - loss: 0.4939 \nEpoch 37/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6729 - loss: 0.4675 \nEpoch 38/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6693 - loss: 0.4913 \nEpoch 39/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6487 - loss: 0.4774 \nEpoch 40/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6405 - loss: 0.4954 \nEpoch 41/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6907 - loss: 0.5027 \nEpoch 42/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6550 - loss: 0.4870 \nEpoch 43/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6663 - loss: 0.4865 \nEpoch 44/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6863 - loss: 0.4776 \nEpoch 45/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6842 - loss: 0.4890 \nEpoch 46/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6787 - loss: 0.4937 \nEpoch 47/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6897 - loss: 0.4907 \nEpoch 48/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6705 - loss: 0.4854 \nEpoch 49/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6638 - loss: 0.4827 \nEpoch 50/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6778 - loss: 0.4633 \nEpoch 51/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6489 - loss: 0.4955 \nEpoch 52/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6821 - loss: 0.4832 \nEpoch 53/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6756 - loss: 0.4747 \nEpoch 54/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6757 - loss: 0.4705 \nEpoch 55/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6456 - loss: 0.4920 \nEpoch 56/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6815 - loss: 0.4781 \nEpoch 57/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6560 - loss: 0.4797 \nEpoch 58/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6614 - loss: 0.4468 \nEpoch 59/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6527 - loss: 0.4931 \nEpoch 60/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6845 - loss: 0.4874 \nEpoch 61/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6737 - loss: 0.4567 \nEpoch 62/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6542 - loss: 0.4828 \nEpoch 63/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6501 - loss: 0.4534 \nEpoch 64/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6643 - loss: 0.4732 \nEpoch 65/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6714 - loss: 0.4940 \nEpoch 66/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6763 - loss: 0.4813 \nEpoch 67/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6516 - loss: 0.4519 \nEpoch 68/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6725 - loss: 0.4736 \nEpoch 69/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6627 - loss: 0.5036 \nEpoch 70/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6609 - loss: 0.4668 \nEpoch 71/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6686 - loss: 0.4768 \nEpoch 72/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6652 - loss: 0.4611 \nEpoch 73/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6496 - loss: 0.4616 \nEpoch 74/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6817 - loss: 0.4597 \nEpoch 75/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6952 - loss: 0.4785 \nEpoch 76/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6792 - loss: 0.4753 \nEpoch 77/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6587 - loss: 0.4638 \nEpoch 78/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6643 - loss: 0.4819 \nEpoch 79/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6586 - loss: 0.4811 \nEpoch 80/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6658 - loss: 0.5088 \nEpoch 81/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6784 - loss: 0.4614 \nEpoch 82/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6591 - loss: 0.4522 \nEpoch 83/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6429 - loss: 0.4681 \nEpoch 84/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6629 - loss: 0.4606 \nEpoch 85/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6665 - loss: 0.5261 \nEpoch 86/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6577 - loss: 0.4634 \nEpoch 87/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6599 - loss: 0.4646 \nEpoch 88/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6561 - loss: 0.4736 \nEpoch 89/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6850 - loss: 0.4512 \nEpoch 90/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6603 - loss: 0.4715 \nEpoch 91/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6776 - loss: 0.4947 \nEpoch 92/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6554 - loss: 0.4777 \nEpoch 93/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6801 - loss: 0.4896 \nEpoch 94/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6741 - loss: 0.4422 \nEpoch 95/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6598 - loss: 0.4949 \nEpoch 96/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6712 - loss: 0.4617 \nEpoch 97/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6725 - loss: 0.4451 \nEpoch 98/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6842 - loss: 0.4682 \nEpoch 99/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6540 - loss: 0.4658 \nEpoch 100/100\n\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step - f1_score: 0.6608 - loss: 0.4689 \n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"\u001b[1mModel: \"sequential_6\"\u001b[0m\n","text/html":"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential_6\"</span>\n</pre>\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n┃\u001b[1m \u001b[0m\u001b[1mLayer (type)                   \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape          \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      Param #\u001b[0m\u001b[1m \u001b[0m┃\n┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n│ dense_14 (\u001b[38;5;33mDense\u001b[0m)                │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m)             │           \u001b[38;5;34m288\u001b[0m │\n├─────────────────────────────────┼────────────────────────┼───────────────┤\n│ dense_15 (\u001b[38;5;33mDense\u001b[0m)                │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m)             │         \u001b[38;5;34m2,112\u001b[0m │\n├─────────────────────────────────┼────────────────────────┼───────────────┤\n│ dense_16 (\u001b[38;5;33mDense\u001b[0m)                │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m)              │            \u001b[38;5;34m65\u001b[0m │\n└─────────────────────────────────┴────────────────────────┴───────────────┘\n","text/html":"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n┃<span style=\"font-weight: bold\"> Layer (type)                    </span>┃<span style=\"font-weight: bold\"> Output Shape           </span>┃<span style=\"font-weight: bold\">       Param # </span>┃\n┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n│ dense_14 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)             │           <span style=\"color: #00af00; text-decoration-color: #00af00\">288</span> │\n├─────────────────────────────────┼────────────────────────┼───────────────┤\n│ dense_15 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)             │         <span style=\"color: #00af00; text-decoration-color: #00af00\">2,112</span> │\n├─────────────────────────────────┼────────────────────────┼───────────────┤\n│ dense_16 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>)              │            <span style=\"color: #00af00; text-decoration-color: #00af00\">65</span> │\n└─────────────────────────────────┴────────────────────────┴───────────────┘\n</pre>\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"\u001b[1m Total params: \u001b[0m\u001b[38;5;34m7,397\u001b[0m (28.90 KB)\n","text/html":"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">7,397</span> (28.90 KB)\n</pre>\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m2,465\u001b[0m (9.63 KB)\n","text/html":"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">2,465</span> (9.63 KB)\n</pre>\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n","text/html":"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n</pre>\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"\u001b[1m Optimizer params: \u001b[0m\u001b[38;5;34m4,932\u001b[0m (19.27 KB)\n","text/html":"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Optimizer params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">4,932</span> (19.27 KB)\n</pre>\n"},"metadata":{}},{"name":"stdout","text":"\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 6ms/step\n\u001b[1m7/7\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 13ms/step\nEvaluation the Model on Training Set\nConfusion Matrix:\n[[268  96]\n [ 61 303]]\nClassification Report:\n              precision    recall  f1-score   support\n\n           0       0.81      0.74      0.77       364\n           1       0.76      0.83      0.79       364\n\n    accuracy                           0.78       728\n   macro avg       0.79      0.78      0.78       728\nweighted avg       0.79      0.78      0.78       728\n\n--------------------------------------------------------------------------------\nEvaluation the Model on Testing Set\nConfusion Matrix:\n[[120  33]\n [ 16  41]]\nClassification Report:\n              precision    recall  f1-score   support\n\n           0       0.88      0.78      0.83       153\n           1       0.55      0.72      0.63        57\n\n    accuracy                           0.77       210\n   macro avg       0.72      0.75      0.73       210\nweighted avg       0.79      0.77      0.77       210\n\n","output_type":"stream"}]}]}