Deep Learning For Credit Risk 1713932406

Credit risk assessment is a critical task in the finance industry, where banks and financial institutions evaluate the
risk of lending money

to individuals or businesses. Traditionally, credit risk assessment has relied on statistical models and scoring systems to predict the
likelihood of defaults or delinquencies. However, with the advancements in deep learning and artificial intelligence, there is an opportunity
to enhance credit risk assessment beyond traditional scoring models. Deep learning models can analyze complex patterns and
relationships in large datasets, providing more accurate and reliable predictions of credit risk. In this tutorial, we will explore how to
leverage deep learning techniques to build a credit risk assessment model using Python. We will use the keras library to create a neural
network model that can effectively evaluate credit risk based on various factors and features. By the end of this tutorial, you will have a
deep understanding of how to apply deep learning in the finance industry to improve credit risk assessment processes.
Table of Contents Setting up the Environment Data Preprocessing Building the Model Training the Model Evaluation and Fine-Tuning Comparison with
Traditional Models Conclusion Stay tuned as we dive into the world of deep learning for credit risk assessment, where traditional scoring models meet
cutting-edge technology. Let’s get started! Setting up the Environment Installing necessary libraries and setting up the Python environment for deep
learning The following code segment demonstrates how to set up your Python environment for deep learning in credit risk assessment. It includes installing
essential libraries, importing required modules and configuring the environment for consistency and reproducibility.
# Install necessary libraries
#subprocess.call(['pip', 'install', 'yfinance'])
# Importing required libraries

import yfinance as yf
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# Setting up the Python environment

np.random.seed(42)
plt.style.use('ggplot')
print("Environment setup completed.")
Environment setup completed.
By executing these steps, you ensure that your environment is equipped with the essential tools and configurations needed to proceed
with deep learning for credit risk assessment. Let’s move on to the next section to preprocess the data for model training.
3. Data Preprocessing: Cleaning and preparing the credit risk

dataset for model training.
Cleaning and preparing the credit risk dataset for model training In this section, we will focus on cleaning and preparing the credit risk
dataset for training our deep learning model. It is crucial to preprocess the data effectively to ensure the model’s accuracy and
performance.
# Importing necessary libraries

import numpy as np
import pandas as pd
# Create a DataFrame with the sample data to continue the script execution
data = {
'Income': [50000, 60000, 70000],
'Credit_Score': [600, 700, 750],
'Education': ['Graduate', 'High School', 'Graduate'],
'Marital_Status': ['Single', 'Married', 'Single'],
'Risk': [0, 1, 0]
}
credit_data = pd.DataFrame(data)
# Ensure the column names 'Unnamed: 0' and 'Customer_ID' are not present before dropping
if 'Unnamed: 0' in credit_data.columns:
credit_data = credit_data.drop(['Unnamed: 0'], axis=1)
if 'Customer_ID' in credit_data.columns:
credit_data = credit_data.drop(['Customer_ID'], axis=1)
# Handling missing values

credit_data['Income'].fillna(credit_data['Income'].mean(), inplace=True)
credit_data['Credit_Score'].fillna(credit_data['Credit_Score'].median(), inplace=True)
# Encoding categorical variables

credit_data = pd.get_dummies(credit_data, columns=['Education', 'Marital_Status'], drop_first=True)
# Splitting the data into features and target variable

X = credit_data.drop('Risk', axis=1)
y = credit_data['Risk']
# Normalizing the features

from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)
# Save the preprocessed data
np.save('X.npy', X_scaled)
np.save('y.npy', y)
By executing this code segment, we effectively clean and preprocess the credit risk dataset, handling missing values, encoding
categorical variables, splitting the data into features and target variable and normalizing the features. This preparation is essential before
training the deep learning model for credit risk assessment.
# 4. Building the Model ## 4.1. Importing necessary libraries To build a deep learning model for credit risk assessment, we first need to import the
necessary libraries and modules, including numpy, pandas, train_test_split from sklearn.model_selection and Dense from keras.layers.
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from keras.models import Sequential
from keras.layers import Dense
2024-04-23 21:44:05.224708: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is opti

mized to use available CPU instructions in performance-critical operations.
To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate co
mpiler flags.
# 4.2. Load preprocessed data Next, we load the preprocessed data that we cleaned and prepared in the previous section. We have the data stored in the
X.npy and y.npy files, which contain the features and target variable, respectively.
# Load preprocessed data
X = np.load('X.npy')
y = np.load('y.npy')
# 4.3. Splitting the data into training and testing sets Before building the model, it’s essential to split the data into training and testing sets. We will use 80%
of the data for training and 20% for testing to evaluate the model’s performance.
# Splitting the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 4.4. Building the deep learning model Now we create a deep learning model using the Sequential API from Keras. We start by initializing a Sequential
model and adding Dense layers with specified units and activation functions.
# Building the deep learning model

model = Sequential()
model.add(Dense(64, input_shape=(X_train.shape[1],), activation='relu'))
model.add(Dense(32, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
/Users/abdelkarimabdallah/anaconda3/lib/python3.11/site-packages/keras/src/layers/core/dense.py:88: 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.
super().__init__(activity_regularizer=activity_regularizer, **kwargs)
# 4.5. Compiling the model After creating the model architecture, we compile it by specifying the optimizer, loss function and metrics to monitor during
training. Here, we use the Adam optimizer and binary cross-entropy loss.
# Compile the model
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# 4.6. Training the model We train the model on the training data for a specified number of epochs and batch size. Additionally, we provide the validation
data to evaluate the model’s performance on the test set during training.
# Train the model
history = model.fit(X_train, y_train, epochs=50, batch_size=32, validation_data=(X_test, y_test))
Epoch 1/50
1/1 ━━━━━━━━━━━━━━━━━━━━ 2s 2s/step - accuracy: 0.5000 - loss: 0.6661 - val_accuracy: 1.0000 - val_loss: 0.6466
Epoch 2/50
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 57ms/step - accuracy: 0.5000 - loss: 0.6539 - val_accuracy: 1.0000 - val_loss: 0.63
96
Epoch 3/50
27
Epoch 4/50
60
Epoch 5/50
03
Epoch 6/50
49
Epoch 7/50
99
Epoch 8/50
052
Epoch 9/50
08
Epoch 10/50
67
Epoch 11/50
33
Epoch 12/50
00
Epoch 13/50
67
Epoch 14/50
35
Epoch 15/50
06
Epoch 16/50
79
Epoch 17/50
56
Epoch 18/50
35
Epoch 19/50
11
Epoch 20/50
88
Epoch 21/50
64
Epoch 22/50
38
Epoch 23/50
12
Epoch 24/50
87
Epoch 25/50
61
Epoch 26/50
37
Epoch 27/50
11
Epoch 28/50
484
Epoch 29/50
57
Epoch 30/50
24
Epoch 31/50
86
Epoch 32/50
47
Epoch 33/50
05
Epoch 34/50
63
Epoch 35/50
20
Epoch 36/50
76
Epoch 37/50
34
Epoch 38/50
93
Epoch 39/50
53
Epoch 40/50
13
Epoch 41/50
74
Epoch 42/50
35
Epoch 43/50
97
Epoch 44/50
54
Epoch 45/50
10
Epoch 46/50
65
Epoch 47/50
19
Epoch 48/50
74
Epoch 49/50
29
Epoch 50/50
85
# 4.7. Saving the model Once the model is trained, we save it to a file for future use or deployment in credit risk assessment applications.
# Save the model
model.save('credit_risk_model.h5')
WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`.
This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my
_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`.
# 4.8. Plotting training and validation metrics We plot the training and validation accuracy and loss values to visualize the model’s performance during
training and ensure it’s learning effectively.
# Plot training & validation accuracy values
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('Model accuracy')
plt.ylabel('Accuracy')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
# Plot training & validation loss values

plt.figure()
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('Model loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')
<matplotlib.legend.Legend at 0x13f08d7d0>
By following these steps, we successfully build a deep learning model for credit risk assessment using Keras, train the model, save it and visualize its
training progress. This model can now be utilized for predicting credit risk based on the provided features.
# 5. Training the Model Training the deep learning model on the preprocessed credit risk dataset.
# Training the deep learning model on the preprocessed credit risk dataset
model.fit(X_train, y_train, epochs=50, batch_size=32, validation_data=(X_test, y_test))
# Save the trained model
model.save('trained_credit_risk_model.h5')
Epoch 1/50
541
Epoch 2/50
96
Epoch 3/50
49
Epoch 4/50
02
Epoch 5/50
53
Epoch 6/50
05
Epoch 7/50
56
Epoch 8/50
08
Epoch 9/50
60
Epoch 10/50
12
Epoch 11/50
65
Epoch 12/50
18
Epoch 13/50
70
Epoch 14/50
20
Epoch 15/50
69
Epoch 16/50
17
Epoch 17/50
766
Epoch 18/50
16
Epoch 19/50
66
Epoch 20/50
17
Epoch 21/50
570
Epoch 22/50
526
Epoch 23/50
81
Epoch 24/50
37
Epoch 25/50
93
Epoch 26/50
48
Epoch 27/50
03
Epoch 28/50
59
Epoch 29/50
16
Epoch 30/50
73
Epoch 31/50
33
Epoch 32/50
92
Epoch 33/50
53
Epoch 34/50
14
Epoch 35/50
74
Epoch 36/50
36
Epoch 37/50
898
Epoch 38/50
62
Epoch 39/50
27
Epoch 40/50
92
Epoch 41/50
57
Epoch 42/50
22
Epoch 43/50
88
Epoch 44/50
55
Epoch 45/50
21
Epoch 46/50
89
Epoch 47/50
57
Epoch 48/50
27
Epoch 49/50
98
Epoch 50/50
70
WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`.
This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my
_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`.
Following these steps, we train the deep learning model on the preprocessed credit risk dataset, specifying the number of epochs and batch size for
training. Additionally, we save the trained model for future use in credit risk assessment applications.
# 6. Evaluation and Fine-Tuning To ensure the effectiveness of our deep learning model for credit risk assessment, we need to evaluate its performance on
the test set and make necessary adjustments through fine-tuning.
# Evaluate the model on the test set
eval_results = model.evaluate(X_test, y_test)
# Print the evaluation results

print("\nEvaluation Results:")
print(f"Loss: {eval_results[0]}")
print(f"Accuracy: {eval_results[1]}")
# Fine-tuning the model

# Increase the number of epochs and observe performance
history_fine_tuned = model.fit(X_train, y_train, epochs=100, batch_size=32, validation_data=(X_test, y_test))
# Plot training & validation accuracy values for fine-tuned model

plt.figure()
plt.plot(history_fine_tuned.history['accuracy'])
plt.plot(history_fine_tuned.history['val_accuracy'])
plt.title('Fine-Tuned Model Accuracy')
plt.ylabel('Accuracy')
plt.xlabel('Epoch')
# Plot training & validation loss values for fine-tuned model

plt.figure()
plt.plot(history_fine_tuned.history['loss'])
plt.plot(history_fine_tuned.history['val_loss'])
plt.title('Fine-Tuned Model Loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - accuracy: 1.0000 - loss: 0.2470
Evaluation Results:
Loss: 0.24697278439998627
Accuracy: 1.0
Epoch 1/100
443
Epoch 2/100
16
Epoch 3/100
90
Epoch 4/100
65
Epoch 5/100
41
Epoch 6/100
17
Epoch 7/100
94
Epoch 8/100
69
Epoch 9/100
43
Epoch 10/100
16
Epoch 11/100
90
Epoch 12/100
65
Epoch 13/100
41
Epoch 14/100
18
Epoch 15/100
95
Epoch 16/100
73
Epoch 17/100
52
Epoch 18/100
30
Epoch 19/100
09
Epoch 20/100
988
Epoch 21/100
69
Epoch 22/100
49
Epoch 23/100
30
Epoch 24/100
12
Epoch 25/100
94
Epoch 26/100
76
Epoch 27/100
57
Epoch 28/100
39
Epoch 29/100
21
Epoch 30/100
04
Epoch 31/100
87
Epoch 32/100
70
Epoch 33/100
54
Epoch 34/100
38
Epoch 35/100
23
Epoch 36/100
08
Epoch 37/100
94
Epoch 38/100
79
Epoch 39/100
65
Epoch 40/100
50
Epoch 41/100
636
Epoch 42/100
22
Epoch 43/100
08
Epoch 44/100
94
Epoch 45/100
82
Epoch 46/100
70
Epoch 47/100
58
Epoch 48/100
46
Epoch 49/100
34
Epoch 50/100
21
Epoch 51/100
09
Epoch 52/100
97
Epoch 53/100
85
Epoch 54/100
74
Epoch 55/100
63
Epoch 56/100
53
Epoch 57/100
42
Epoch 58/100
32
Epoch 59/100
21
Epoch 60/100
11
Epoch 61/100
01
Epoch 62/100
91
Epoch 63/100
82
Epoch 64/100
72
Epoch 65/100
62
Epoch 66/100
53
Epoch 67/100
44
Epoch 68/100
35
Epoch 69/100
26
Epoch 70/100
17
Epoch 71/100
09
Epoch 72/100
00
Epoch 73/100
92
Epoch 74/100
83
Epoch 75/100
75
Epoch 76/100
67
Epoch 77/100
59
Epoch 78/100
51
Epoch 79/100
43
Epoch 80/100
36
Epoch 81/100
28
Epoch 82/100
21
Epoch 83/100
14
Epoch 84/100
07
Epoch 85/100
99
Epoch 86/100
92
Epoch 87/100
85
Epoch 88/100
78
Epoch 89/100
71
Epoch 90/100
65
Epoch 91/100
58
Epoch 92/100
52
Epoch 93/100
45
Epoch 94/100
39
Epoch 95/100
32
Epoch 96/100
126
Epoch 97/100
20
Epoch 98/100
114
Epoch 99/100
08
Epoch 100/100
02
<matplotlib.legend.Legend at 0x13f657150>
By evaluating the model on the test set, printing the evaluation results and fine-tuning the model with an increased number of epochs, we can observe and
optimize the performance of our deep learning model for credit risk assessment. The plotted accuracy and loss values provide insights into the
effectiveness of the fine-tuned model.
# 7. Comparison with Traditional Models Evaluating the Logistic Regression Model
import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix
# Load the preprocessed data

X = np.load('X.npy')
y = np.load('y.npy')
# Split the data into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Build and train Logistic Regression model

log_reg = LogisticRegression()
log_reg.fit(X_train, y_train)
# Make predictions on the test set

y_pred = log_reg.predict(X_test)
# Evaluate the Logistic Regression model

accuracy = accuracy_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred)
# Print the evaluation results

print("\nLogistic Regression Model Evaluation:")
print(f"Accuracy: {accuracy}")
print("Confusion Matrix:")
print(conf_matrix)
# Save the Logistic Regression model

import joblib
joblib.dump(log_reg, 'logistic_regression_model.pkl')
Logistic Regression Model Evaluation:

Accuracy: 1.0
Confusion Matrix:
[[1]]
/Users/abdelkarimabdallah/anaconda3/lib/python3.11/site-packages/sklearn/metrics/_classification.py:386: UserWa
rning: A single label was found in 'y_true' and 'y_pred'. For the confusion matrix to have the correct shape, u
se the 'labels' parameter to pass all known labels.
warnings.warn(
['logistic_regression_model.pkl']
In this section, we contrast the deep learning approach with traditional credit scoring models, specifically evaluating a Logistic Regression model’s
performance on the preprocessed credit risk dataset. By training the Logistic Regression model, making predictions on the test set and evaluating its
accuracy and confusion matrix, we gain insights into how traditional models fare in credit risk assessment compared to deep learning models. The Logistic
Regression model evaluation results give us valuable information about its accuracy and predictive capabilities. This comparison sets the stage for further
analysis and discussion on the effectiveness of deep learning models in credit risk assessment applications.
Loading [MathJax]/jax/output/CommonHTML/fonts/TeX/fontdata.js

Deep Learning For Credit Risk 1713932406

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Deep Learning For Credit Risk 1713932406

Uploaded by

Copyright:

Available Formats

Credit risk assessment is a critical task in the finance industry, where banks and financial institutions evaluate the

risk of lending money

# Importing required libraries

# Setting up the Python environment

print("Environment setup completed.")

Environment setup completed.

3. Data Preprocessing: Cleaning and preparing the credit risk

# Importing necessary libraries

# Handling missing values

# Encoding categorical variables

# Splitting the data into features and target variable

# Normalizing the features

2024-04-23 21:44:05.224708: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is opti

# Building the deep learning model

# Plot training & validation loss values

# Print the evaluation results

# Fine-tuning the model

# Plot training & validation accuracy values for fine-tuned model

# Plot training & validation loss values for fine-tuned model

1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - accuracy: 1.0000 - loss: 0.2470

# Load the preprocessed data

# Split the data into training and testing sets

# Build and train Logistic Regression model

# Make predictions on the test set

# Evaluate the Logistic Regression model

# Print the evaluation results

# Save the Logistic Regression model

Logistic Regression Model Evaluation:

You might also like