In training data, each data has n attributes and a class of class flags. We can think that these data are in an n-dimensional space. Our goal is to find a n − 1 dimensional hyperplane, which can divide the data into two parts or parts, each of which belongs to the same category.

In fact, there are many hyperplanes like this, and we have to find one of the best. Therefore, a constraint is added: the distance from the hyperplane to the nearest data point on each side is maximum. It also becomes the maximum interval hyperplane. This classifier also becomes the maximum interval classifier. A support vector machine (SVM) is a two-class or multiple-classifier.

For training data set T, the data can be divided into two categories: C1 and C2. For functions: $f\left(x\right)=w{x}^T+b$ (Linear classifier). Data for C1 classes $w{x}^T+b\ge 1$. At least one of them. $x_i,f\left(x_i\right)=1$ This point is called the nearest point. Data for C2 classes $x{w}^T+b\le -1$. At least one of them $x_i,f(x_i)=-1$. This point is also the nearest point. The above two constraints can be combined as: $y_{i}f\left(x_i\right)=y_i\left(w{x}^T+b\right)\ge 1$. $y_i$ is the corresponding classification value of $x_i$ (−1 or 1). Seek $w$ and $b$, then the hyperplane function is $w{x}^T+b=0$. In order to obtain the optimal $f\left(x\right)$, in training data, we expected that the distance from each point to the hyperplane would be the largest.

One advantage of the SVM is that it supports non-linear classification. It is combined with Lagrange multiplier method and KKT condition, and the kernel function can generate nonlinear classifier.

$w={\displaystyle \underset{i=1}{\overset{n}{\sum }}{\alpha }_i{y}_i{x}_i}$; $f\left(x\right)={\displaystyle \underset{i=1}{\overset{n}{\sum }}{\alpha }_i{y}_{i}K\left(x_i,x\right)+b}$, here $x_i$: training data i; $y_i$: label value of training data i; ${\alpha }_i$: the Lagrange multiplier of the training data i; $K\left(x_1,x_2\right)=\exp \left(-\frac{\left|\right|x_1-x_2|{|}^2}{2{\sigma }^{12}}\right)$: Kernel function; $\alpha ,\sigma$ and $b$ is the value generated by the training data.

By adjusting $\sigma$ to match the size of the dimension, the larger $\sigma$, the lower the dimension.

According to the theory of machine learning, nonlinear problems can be transformed into linear problems by mapping to high dimensions. For example, a point in two dimensions. $\langle x_1,x_2\rangle$ can be mapped to a 5-dimensional space with five dimensions: $x_1,x_2,x_1{x}_2,x_1^2,x_2^2$. Mapping to high dimensions has two questions: how does one map? Another problem is that the calculation becomes more complicated. Fortunately, we can use the kernel function to solve this problem.

Kernel function, also known as kernel technique (kernel trick). The kernel function provides a method to calculate the inner product of the high dimensional space by the vector value of the original space, regardless of the way of mapping.

We can replace $K\left(x_1,x_2\right)$ with a kernel function.

There are many kinds of kernel functions, generally using Gauss kernel, the following formula:

$K\left(x_1,x_2\right)=\exp \left(-\frac{\left|\right|x_1-x_2|{|}^2}{2{\sigma }^{12}}\right)$

Because there are too many incomplete values of bank financial data obtained by tushare data interface, and the number of banks is too small. Therefore, the use of API on Uqer site to obtain.

Data operating income and net profit: income and revenue.

The profit ratio = NIncome/revenue.

Access to data on current assets and current liabilities:

Current assets = tradingFA + loanToOthBankFi + intReceiv + purResaleFa + CReserCB + derivAssets + deposInOthBfi + preciMetals + investAsReceiv;

current liabilities = CBBorr + depos + loanFrOthBankFi + tradingFL + soldForRepura + payrollPayable + taxesPayable + intPayable + bondPayable + deposFrOthBfi + derivLiab;

Current ratio = current assets/current liabilities.

The exact meaning of these variables can be found in the data menu in the mining platform.

In addition, we collect data by looking at bank annual reports and rating reports issued by credit rating agencies.

Import Python’s numpy, pandas, sklearn, matplotlib module and train_test_split, pyplot, svm function.

import numpy as np

import pandas as pd

import sklearn

from sklearn.model_selection import train_test_split

from sklearn import svm

import matplotlib as mpl

import matplotlib.pyplot as plt

data=np.loadtxt(‘F:/2glkx/data/zonghe1.txt’,delimiter=‘,’)

# using loadtxt to read data can directly convert text data into arrays for easy operation

# to facilitate subsequent training, set the AAA to 3 AA to 2.5 AA to 2

Data = np.loadtxt(‘F:/2glkx/data/zonghe1.txt’,delimiter=‘,’)

# convert floating-point data to a string for later operations

data=data.astype(Str)

x, y = np.split (data, (2,), axis = 1)

x_train, x_test, y_train, y_test = sklearn.model_selection.train_test_split (x, y, random_state = 1, train_size = 0.6)

1) split (data, segmentation position, axis 1 (horizontal partition) or 0 (vertical segmentation);

2) sklearn. model_selection. train_test_split randomly divided into training set and test set.

train_test_split (train_data, train_target, test_size = number, random_state = 0).

Parameter interpretation:

train_data: the sample feature set to be partitioned.

train_target: sample results to be partitioned.

test_size: the percentage of test_size: samples, if an integer, is the number of samples.

random_state: is the seed of random numbers.

Random number seed: in fact, the number of random numbers, in case of repeated trials, ensure that the same set of random numbers. For example, if you fill in 1 at a time, you will get the same random array if the other parameters are the same. But fill in 0 or not, each time will be different. The generation of random numbers depends on the seeds. The relationship between random numbers and seeds follows the following two rules: different seeds produce different random numbers and the same seeds produce the same random numbers even if the instances are different.

# clf = svm.SVC (C = 0.1, kernel = ‘linear’, decision_function_shape = ‘ovr’)

clf = svm.SVC (C = 0.8, kernel = ‘rbf’, gamma = 100, decision_function_shape = ‘ovr’)

clf.fit(x_train, y_train.ravel())

When kernel = ‘linear’,The larger C is, the better the classification effect is, but it is possible to over-fit (defaul C = 1).

In kernel = ‘rbf’, the smaller the gamma value is, the more continuous the classification interface is, and the more “scattered” is, the better the classification effect is, but it may be over-fitted.

When decision_function_shape = ‘ovr’ is defined as one v rest, that is, one category is divided from other categories, and when decision_function_shape = ‘ovo’ is defined as the one v one, is divided into two categories, the result of multi-classification is simulated by two-classification method.

The following results were obtained:

SVC (C = 0.8, cache_size = 200, class_weight = None, coef0 = 0.0,

decision_function_shape = ‘ovr’, degree = 3, gamma = 100, kernel = ‘rbf’,

max_iter = −1, probability = False, random_state = None, shrinking = True,

tol = 0.001, verbose = False)

After several attempts, gamma = 100 can achieve the best effect.

print (clf.score (x_train, y_train))

print (clf.score (x_test, y_test))

The following results were obtained:

0.7962962962962963

0.5277777777777778

It can be seen from above that the accuracy of the SVC classifier is 0.80 for the training set and 0.53 for the test set.