pip install imblearn

pip install xgboost

pip install lightgbm

cor_rate_data = pd.read_csv('corporate_rating.csv')
cor_rate_data.head()

cor_rate_data['Rating Agency Name'].value_counts().to_frame()

agency_mapping = {"Standard & Poor's Ratings Services" : "S&P",
                  "Egan-Jones Ratings Company" : "Egan-Jones",
                  "Moody's Investors Service" : "Moody's",
                  "Fitch Ratings" : "Fitch",
                  "DBRS" : "DBRS"}

cor_rate_data['Rating Agency Name'] = cor_rate_data['Rating Agency Name'].map(agency_mapping)
cor_rate_data['Rating Agency Name'].value_counts().to_frame()

plt.figure(figsize = (10,6))
cor_rate_data['Rating Agency Name'].value_counts().plot(kind = 'bar',
                                                        color=plt.cm.tab20.colors[:len(cor_rate_data['Rating Agency Name'].value_counts())])
plt.title('Frequency of Rating Agencies', fontsize = 14)
plt.xlabel('Name of Agencies')
plt.ylabel('Counts')
plt.show()

cor_rate_data = pd.get_dummies(cor_rate_data,
                               columns = ['Rating Agency Name'],
                               prefix = 'Agency',
                               drop_first=True,
                               dtype = float)
cor_rate_data.head()

cor_rate_data['Sector'].value_counts().to_frame()

plt.figure(figsize = (12,6))
cor_rate_data['Sector'].value_counts().plot(kind = 'bar', color = 'orange')
plt.title('Distribution Of Sectors')
plt.ylabel('Counts')
plt.show()

cor_rate_data = cor_rate_data.drop(columns = ['Sector','Name','Date', 'Symbol'])
cor_rate_data.head()

rating_order = ['AAA', 'AA', 'A', 'BBB', 'BB', 'B', 'CCC', 'CC', 'C' , 'D' ]
cor_rate_data['Rating'].value_counts().reindex(rating_order).to_frame().T

rating_mapping = {'AAA': 0, 'AA': 1, 'A': 2, 'BBB' : 3, 'BB' : 4, 'B' : 5, 'CCC' : 6, 'CC' : 7, 'C' : 8, 'D' : 8}
cor_rate_data['Rating'] = cor_rate_data['Rating'].map(rating_mapping).fillna(method='ffill')
cor_rate_data.head()

X = cor_rate_data.drop(columns=['Rating'])
y = cor_rate_data['Rating']
sampling_strategy = {label: 671 for label in set(y)}

adasyn = ADASYN(sampling_strategy = sampling_strategy, n_neighbors=2, random_state=2023311161)
X_resampled, y_resampled = adasyn.fit_resample(X, y)

y_resampled.value_counts().to_frame()

rating_remapping = {value: key for key, value in rating_mapping.items()} # switch key and value of rating_mapping dictionary
rating_remapping[8] = 'C'

rating_order2 = [x for x in rating_order if x != 'D']
y_resampled_rating = y_resampled.map(rating_remapping)
y_resampled_rating.value_counts().reindex(rating_order2).to_frame().T

plt.figure(figsize = (12,6))
y_resampled_rating.value_counts().reindex(rating_order2).plot(kind = 'bar')
plt.ylabel('counts')
plt.title('The Number of Ratings')
plt.show()

cor_rate_data_adasyn = pd.concat([y_resampled, X_resampled], axis = 1)
cor_rate_data_adasyn.head()

data_train, data_test = train_test_split(cor_rate_data_adasyn, test_size=0.2, random_state = 2023311161)
X_train, y_train = data_train.iloc[:,2:30], data_train.iloc[:,0]
X_test, y_test = data_test.iloc[:,2:30], data_test.iloc[:,0]
X_test.head()

# OrderedModel in statsmodels is too poor.

LR_model = LogisticRegression(random_state=2023311161 ,
                              multi_class='multinomial',
                              solver='newton-cg',
                              max_iter=5000)

LR_model = LR_model.fit(X_train, y_train)
y_pred_LR = LR_model.predict(X_test)
acc_olr = accuracy_score(y_test, y_pred_LR)
print("Ordered Logistic Regression Accuracy :",acc_olr) # 0.5935

f1_olr = f1_score(y_test, y_pred_LR, average = average)
print("Ordered Logistic Regression f1 score :", f1_olr) # 0.5709

LDA_model = LinearDiscriminantAnalysis()
LDA_model.fit(X_train,y_train)
y_pred_LDA = LDA_model.predict(X_test)
acc_LDA = accuracy_score(y_test, y_pred_LDA)
print("LDA Accuracy :",acc_LDA)

f1_LDA = f1_score(y_test, y_pred_LDA, average = average)
print("LDA f1 score :", f1_LDA)

QDA_model = QuadraticDiscriminantAnalysis()
QDA_model.fit(X_train,y_train)
y_pred_QDA = QDA_model.predict(X_test)
acc_QDA = accuracy_score(y_test, y_pred_QDA)
print("QDA Accuracy :",acc_QDA)

f1_QDA = f1_score(y_test, y_pred_QDA, average = average)
print("QDA f1 score :", f1_QDA)

KNN_model = KNeighborsClassifier(n_neighbors = 3)
KNN_model.fit(X_train,y_train)
y_pred_KNN = KNN_model.predict(X_test)
acc_KNN = accuracy_score(y_test, y_pred_KNN)
print("KNN Accuracy :",acc_KNN)

f1_KNN = f1_score(y_test, y_pred_KNN, average = average)
print("KNN f1 score :", f1_KNN)

SVC_model = svm.SVC(gamma= 'auto')
SVC_model.fit(X_train, y_train)
y_pred_SVM = SVC_model.predict(X_test)
acc_SVM = accuracy_score(y_test, y_pred_SVM)
print("SVM Accuracy :",acc_SVM)

f1_SVM = f1_score(y_test, y_pred_SVM, average = average)
print("SVM f1 score :", f1_SVM)

RF_model = RandomForestClassifier(random_state=2023311161)
RF_model.fit(X_train,y_train)
y_pred_RF = RF_model.predict(X_test)
acc_RF = accuracy_score(y_test, y_pred_RF)
print("Random Forest Accuracy :",acc_RF)

f1_RF = f1_score(y_test, y_pred_RF, average = average)
print("Random Forest f1 score :", f1_RF)

GBT_model = GradientBoostingClassifier(random_state=2023311161)
GBT_model.fit(X_train, y_train)
y_pred_GBT = GBT_model.predict(X_test)
acc_GBT = accuracy_score(y_test, y_pred_GBT)
print("GBT Accuracy :",acc_GBT)

f1_GBT = f1_score(y_test, y_pred_GBT, average = average)
print("GBT f1 score :", f1_GBT)

xgb_model = XGBClassifier(objective='multi:softmax', num_class=len(y_train.unique()), random_state=2023311161)
xgb_model.fit(X_train, y_train)
y_pred_xgb = xgb_model.predict(X_test)
acc_xgb = accuracy_score(y_test, y_pred_xgb)
print("XGBoost accuracy :", acc_xgb)

f1_xgb = f1_score(y_test, y_pred_xgb, average = average)
print("XGBoost f1 score :", f1_xgb)

lgb_model = lgb.LGBMClassifier(random_state=2023311161)
lgb_model.fit(X_train, y_train)
y_pred_lightGBM = lgb_model.predict(X_test)
acc_lightGBM = accuracy_score(y_test, y_pred_lightGBM)
print("LightGBM accuracy :", acc_lightGBM)

f1_lightGBM = f1_score(y_test, y_pred_lightGBM, average = average)
print("LightGBM f1 score :", f1_lightGBM)

models = ['Ordered Logistic', 'LDA','QDA', 'KNN','SVC','Random Forest','Gradient Boosting','XGBoost','LightGBM']
accuracy = [acc_olr, acc_LDA, acc_QDA, acc_KNN, acc_SVM, acc_RF, acc_GBT, acc_xgb, acc_lightGBM]
df_acc = pd.DataFrame({'model' : models, 'accuracy' : accuracy})
df_acc = df_acc.sort_values('accuracy', ascending = True)

plt.figure(figsize = (12,6))
ax = sns.barplot(data=df_acc, x='model', y='accuracy',  palette='viridis')

# Add accuracy values on top of each bar
for p in ax.patches:
    ax.annotate(f'{p.get_height():.3f}',  # Format with two decimals
                (p.get_x() + p.get_width() / 2., p.get_height()),
                ha='center', va='bottom', fontsize=10)
plt.ylabel('Accuracy')
plt.title('The accuracies for distinct models')
plt.show()

f1_scores = [f1_olr, f1_LDA, f1_QDA, f1_KNN, f1_SVM, f1_RF, f1_GBT, f1_xgb, f1_lightGBM]
df_f1 = pd.DataFrame({'model' : models, 'f1_score' : f1_scores})
df_f1 = df_f1.sort_values('f1_score', ascending = True)

plt.figure(figsize = (12,6))
ax = sns.barplot(data=df_f1, x='model', y='f1_score', color='skyblue')

for p in ax.patches:
    ax.annotate(f'{p.get_height():.3f}',  # Format with two decimals
                (p.get_x() + p.get_width() / 2., p.get_height()),
                ha='center', va='bottom', fontsize=10)
plt.ylabel('f1 score')
plt.title('The f1 scores for distinct models')
plt.show()

df_LGB_importance = pd.DataFrame({'feature' : X_train.columns,
                                  'importance' : lgb_model.feature_importances_})
df_LGB_importance = df_LGB_importance.sort_values(by = 'importance', ascending = True)

plt.figure(figsize = (16,10))
bars = plt.barh(df_LGB_importance['feature'], df_LGB_importance['importance'], color = 'green')
for bar, value in zip(bars, df_LGB_importance['importance']):
    plt.text(bar.get_width() + 0.01, bar.get_y() + bar.get_height() / 2,
             f'{value:.0f}', va='center', fontsize=9, color='black')
plt.xlabel('Feature Importance')
plt.title('Feature Importance - LightGBM')
plt.show()

df_LGB_importance = df_LGB_importance.sort_values(by = 'importance', ascending = False)
df_LGB_importance['feature'].iloc[:5].to_frame().T

cor_rate_data.loc[:,"currentRatio":"payablesTurnover"].describe()

cor_rate_data_correlation = cor_rate_data.loc[:,"currentRatio":"payablesTurnover"].corr()
cor_rate_data_correlation

plt.figure(figsize=(16, 12))
plt.imshow(cor_rate_data_correlation, cmap='coolwarm', interpolation='none', aspect='auto')
plt.colorbar(label='Correlation Coefficient')
plt.xticks(range(len(cor_rate_data_correlation.index)), cor_rate_data_correlation.index, rotation=90)
plt.yticks(range(len(cor_rate_data_correlation.index)), cor_rate_data_correlation.index)
plt.title("Correlation Matrix", fontsize=30)
plt.tight_layout()
plt.show()