2026-01-07-机器学习相关算法

评估方法（留出法）#

1
import random
2
import numpy as np
3

4
def train_test_split(X,test_size=0.2,random_state=5):
5
    random.seed(random_state)
6
    n_samples = len(X)
7
    indices = np.arange(n_samples)
8
    train_indexs = list(set(random.sample(indices.tolist(),int(n_samples*(1-test_size)))))
9
    test_indexs = [k for k in indices if k not in train_indexs]
10
    return X[train_indexs],X[test_indexs]
11

12

13
test_size = 0.2
14
X = np.array([1,2,3,4,5,6,7,8,9,10])
15
train_X,test_X = train_test_split(X,test_size=test_size)
16
print(train_X,test_X)
17

18
print("debug_begin");
19
print(len(test_X) == int(len(X)*test_size))
20
print("debug_end");

评估方法（交叉验证法）#

1
import numpy as np
2
import random
3

4
def KFold(X,n_splits,is_shuffle=True,random_state=0):
5
    random.seed(random_state)
6
    n_samples = len(X)
7

8
    indices = np.arange(n_samples)
9

10
    train_index = []
11
    test_index = []
12
    result = []
13
    fold_sizes = np.full(n_splits,n_samples//n_splits,dtype=np.int)
14
    fold_sizes[:n_samples%n_splits] += 1
15
    current = 0
16
    for fold_size in fold_sizes:
17
        start, stop = current, current+fold_size
18
        test_index = indices[start:stop]
19
        train_index = list(set(indices)-set(indices[start:stop]))
20
        current = stop
21
        result.append([X[train_index],X[test_index]])
22
    return result
23

24
X = np.array([int(i) for i in input().strip().split()])
25
n_splits = int(input())
26
result = KFold(X,n_splits)
27

28

29
for S,T in result:
30
    print(S,T)
31

32

33
print("debug_begin");
34
res = []
35
for _,T in result:
36
    res += list(T)
37
if set(res)==set(list(X)) and len(X)==len(res):
38
    print(True)
39
else:
40
    print(False)
41
print("debug_end");

优化算法-梯度下降法 1#

1
import math
2
print("debug_begin");
3
def func_1d_test1(x):
4
    return x**2+1
5
def grad_1d_test1(x):
6
    return x*2
7

8
def func_1d_test2(x):
9
    return x**2 - 4*x +14
10
def grad_1d_test2(x):
11
    return x*2-4
12
print("debug_end");
13

14

15
def gradient_descent_1d(grad, cur_x=0.1, learning_rate=0.01, precision=0.0001, max_iters=10000):
16
    for i in range(max_iters):
17
        grad_cur = grad(cur_x)
18
        if abs(grad_cur) < precision:
19
            break  # 当梯度趋近为 0 时，视为收敛
20
        cur_x = cur_x - grad_cur * learning_rate
21

22
    return cur_x
23

24
print("debug_begin");
25
def test():
26
    print("%.7f" %gradient_descent_1d(grad_1d_test1, cur_x=10, learning_rate=0.2, precision=0.0001, max_iters=10000))
27
    print("%.7f" %gradient_descent_1d(grad_1d_test2, cur_x=10, learning_rate=0.2, precision=0.0001, max_iters=10000))
28
print("debug_end");
29

30
test()

优化算法-梯度下降法 2#

1
import math
2
import numpy as np
3

4
print("debug_begin");
5
import numpy as np
6
def func_2d_test1(x):
7
    return - math.exp(-(x[0] ** 2 + x[1] ** 2))
8
def grad_2d_test1(x):
9
    deriv0 = 2 * x[0] * math.exp(-(x[0] ** 2 + x[1] ** 2))
10
    deriv1 = 2 * x[1] * math.exp(-(x[0] ** 2 + x[1] ** 2))
11
    return np.array([deriv0, deriv1])
12

13
def func_2d_test2(x):
14
    return x[0]**2 + x[1]**2 +2*x[0]+1
15
def grad_2d_test2(x):
16
    deriv0 = 2*x[0]+2
17
    deriv1 = 2*x[1]
18
    return np.array([deriv0,deriv1])
19
print("debug_end");
20

21

22
def gradient_descent_2d(grad, cur_x=np.array([0.1,0.1]), learning_rate=0.01, precision=0.0001, max_iters=10000):
23
    for i in range(max_iters):
24
        grad_cur = grad(cur_x)
25
        if np.linalg.norm(grad_cur, ord=2) < precision:
26
            break  # 当梯度趋近为 0 时，视为收敛
27
        cur_x = cur_x - grad_cur * learning_rate
28

29

30
    return cur_x
31

32

33
print("debug_begin");
34
import numpy as np
35
def test():
36
    res = gradient_descent_2d(grad_2d_test1, cur_x=np.array([1,-1]), learning_rate=0.2, precision=0.0001, max_iters=10000)
37
    print("%.7f %.7f" %(res[0],res[1]) )
38
    res2 = gradient_descent_2d(grad_2d_test2, cur_x=np.array([2,2]), learning_rate=0.2, precision=0.0001, max_iters=10000)
39
    print("%.7f %.7f" %(res2[0],res2[1]) )
40
print("debug_end");
41

42
test()

线性回归-糖尿病预测#

1
import math
2
import numpy as np
3
import random
4
import  warnings
5
warnings.filterwarnings("ignore")
6

7
def load_diabetes():
8
    X = []
9
    y = []
10
    line = input()
11
    while line:
12
        dx = []
13
        data = [l for l in line.strip().split(',')]
14
        X.append(np.array([np.float(d) for d in data[:-1]]))
15
        y.append(np.float(data[-1]))
16
        line = input()
17
    return np.array(X),np.array(y)
18

19
def train_test_split(X,Y,test_size=0.2,random_state=2333):
20
    random.seed(random_state)
21
    n_samples = len(X)
22
    indices = np.arange(n_samples)
23
    train_indexs = list(set(random.sample(indices.tolist(),int(n_samples*(1-test_size)))))
24
    test_indexs = [k for k in indices if k not in train_indexs]
25
    return X[train_indexs],X[test_indexs],Y[train_indexs],Y[test_indexs]
26

27
X,y = load_diabetes()
28
import math
29
import numpy as np
30
import random
31
import  warnings
32
warnings.filterwarnings("ignore")
33

34
def load_diabetes():
35
    X = []
36
    y = []
37
    line = input()
38
    while line:
39
        dx = []
40
        data = [l for l in line.strip().split(',')]
41
        X.append(np.array([np.float(d) for d in data[:-1]]))
42
        y.append(np.float(data[-1]))
43
        line = input()
44
    return np.array(X),np.array(y)
45

46
def train_test_split(X,Y,test_size=0.2,random_state=2333):
47
    random.seed(random_state)
48
    n_samples = len(X)
49
    indices = np.arange(n_samples)
50
    train_indexs = list(set(random.sample(indices.tolist(),int(n_samples*(1-test_size)))))
51
    test_indexs = [k for k in indices if k not in train_indexs]
52
    return X[train_indexs],X[test_indexs],Y[train_indexs],Y[test_indexs]
53

54
X,y = load_diabetes()
55
class LinearRegression:
56
  def __init__(self):
57
    '''初始化模型'''
58
    self.coef_ = None
59
    self.interception_ = None
60
    self._theta = None
61

62
  def fit_normal(self,X_train,y_train):
63
    '''根据训练数据集X_train,y_train训练模型'''
64
    assert X_train.shape[0] == y_train.shape[0],'the number of X_train must equal to the number of y_train'
65
    X_b = np.hstack([np.ones((len(X_train),1)),X_train])
66
    self._theta = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y_train)
67
    self.interception_ = self._theta[0]
68
    self.coef_ = self._theta[1:]
69
    return self
70

71
  def predict(self,X_predict):
72
    assert self._theta is not None,'must fit before predict'
73
    assert X_predict.shape[1] == len(self.coef_),'the feature number of X_predict must equal to X_train '
74

75
    X_b = np.hstack([np.ones((len(X_predict),1)),X_predict])
76
    return X_b.dot(self._theta)
77

78
  def mse(self,y,y_pre):
79
    return np.average((y-y_pre)**2)
80

81
  def rmse(self,y,y_pre):
82
    return np.sqrt(self.mse(y,y_pre))
83

84
  def r2_score(self,y,y_pre):
85
    return 1-(self.mse(y,y_pre)/np.var(y))
86

87
  def score(self,X_test,y_test):
88
    '''根据测试数据集确定当前模型的准确度'''
89
    y_predict = self.predict(X_test)
90
    return self.r2_score(y_test,y_predict),self.rmse(y_test,y_predict)
91

92
  def __repr__(self):
93
    return 'LinearRegression()'
94

95
x_train,x_test,y_train,y_test = train_test_split(X,y)
96

97
reg = LinearRegression()
98
reg.fit_normal(x_train,y_train)
99
r2,rmse = reg.score(x_test,y_test)
100

101

102
print("debug_begin");
103
def test(rmse,r2):
104
    if rmse>50 or r2>0.5:
105
        print(True)
106
    else:
107
        print(False)
108

109
print("debug_end");
110
test(rmse,r2)
111

112

113
print("debug_begin");
114
def test(rmse,r2):
115
    if rmse>50 or r2>0.5:
116
        print(True)
117
    else:
118
        print(False)
119

120
print("debug_end");
121
test(rmse,r2)

逻辑回归-乳腺癌预测#

1
import numpy as np
2
import random
3
import warnings
4
warnings.filterwarnings("ignore")
5

6
def load_breast_cancer():
7
    X = []
8
    y = []
9
    line = input()
10
    while line:
11
        dx = []
12
        data = [np.float64(l) for l in line.strip().split(',')]
13
        X.append(np.array(data[:-1]))
14
        y.append(int(data[-1]))
15
        line = input()
16
    return np.array(X),np.array(y)
17

18
def train_test_split(X,Y,test_size=0.2,random_state=5):
19
    n_samples = len(X)
20
    indices = np.arange(n_samples)
21
    train_indexs = list(set(random.sample(indices.tolist(),int(n_samples*(1-test_size)))))
22
    test_indexs = [k for k in indices if k not in train_indexs]
23
    return X[train_indexs],X[test_indexs],Y[train_indexs],Y[test_indexs]
24

25
X,y = load_breast_cancer()
26
x_train,x_test,y_train,y_test = train_test_split(X,y)
27
class Logisticregression():
28

29

30
    def __init__(self, learn_rate = 0.001, max_iteration=10000):
31

32
        self.learn_rate = learn_rate
33
        self.max_iteration = max_iteration
34
        self._X_train = None
35
        self._y_train = None
36
        self._w = None
37

38
    def fit(self, X_train, y_train):
39

40
        m_samples, n_features = X_train.shape
41
        self._X_train = np.insert(X_train, 0, 1, axis=1)
42
        self._y_train = np.reshape(y_train, (m_samples, 1))
43
        limit = np.sqrt(1 / n_features)
44
        w = np.random.uniform(-limit, limit, (n_features, 1))
45
        b = 0
46
        self.w = np.insert(w, 0, b, axis=0)
47
        iteration = 0
48
        while iteration < self.max_iteration:
49
            h_x = self._X_train.dot(self.w)
50
            y_pred = 1/(1+np.exp(- h_x))
51
            w_grad = self._X_train.T.dot(y_pred - self._y_train)
52
            self.w = self.w - self.learn_rate * w_grad
53
            iteration = iteration + 1
54

55
    def predict(self, X_test):
56

57
        X_test = np.insert(X_test, 0, 1, axis=1)
58
        h_x = X_test.dot(self.w)
59
        y_pripr_1 = (1/(1+np.exp(-h_x)))
60
        y_pripr_0 = 1 - y_pripr_1
61
        y_cal = y_pripr_1 - y_pripr_0
62
        y_class = np.where(y_cal > 0, 1, 0)
63
        return y_class
64

65
    def score(self, X_test, y_test):
66

67
        j = 0
68
        y_test = np.reshape(y_test,(len(y_test),1))
69
        y_hat = self.predict(X_test)
70
        for i in range(y_test.shape[0]):
71
            if y_hat[i,0] == y_test[i,0]:
72
                j += 1
73
        acc = j / len(y_test)
74
        y_test = list(y_test.reshape((1,-1))[0])
75
        y_hat = list(y_hat.reshape((1,-1))[0])
76

77
        precision = self.get_precision(y_test,y_hat)
78
        recall = self.get_recall(y_test,y_hat)
79
        auc = self.get_auc(y_test,y_hat)
80
        return acc,precision,recall,auc
81

82

83
    def get_precision(self,y,y_hat):
84
        true_positive = sum(yi and yi_hat for yi,yi_hat in zip(y,y_hat))
85
        predicted_positive = sum(y_hat)
86
        return true_positive/predicted_positive
87

88
    def get_recall(self,y,y_hat):
89
        true_positive = sum(yi and yi_hat for yi,yi_hat in zip(y,y_hat))
90
        actual_positive = sum(y)
91
        return true_positive/actual_positive
92

93

94
    def get_tnr(self,y,y_hat):
95
        true_negative = sum(1-(yi or yi_hat) for yi,yi_hat in zip(y,y_hat))
96
        actual_negative = len(y) - sum(y)
97
        return true_negative/actual_negative
98

99
    def get_roc(self,y,y_hat):
100
        thresholds = sorted(set(y_hat),reverse=True)
101
        ret = [[0,0]]
102
        for threshold in thresholds:
103
            y_hat = [int(yi_hat >= threshold) for yi_hat in y_hat]
104
            ret.append([self.get_recall(y,y_hat),1-self.get_tnr(y,y_hat)])
105
        return ret
106

107
    def get_auc(self,y,y_hat):
108
        roc = iter(self.get_roc(y,y_hat))
109
        tpr_pre, fpr_pre = next(roc)
110
        auc = 0
111
        for tpr,fpr in roc:
112
            auc += (tpr+tpr_pre)*(fpr-fpr_pre)/2
113
            tpr_pre = tpr
114
            fpr_pre = fpr
115
        return auc
116

117
lr = Logisticregression()
118
lr.fit(x_train,y_train)
119
acc,precision,recall,auc = lr.score(x_test,y_test)
120

121

122
print("debug_begin");
123
def test(acc,auc):
124
    if acc>0.8 or auc>0.8:
125
        print(True)
126
    else:
127
        print(False)
128
print("debug_end");
129
test(acc,auc)

svm-手写数字识别#

1
import numpy as np
2
import  warnings
3
import random
4
warnings.filterwarnings("ignore")
5

6
def load_digits():
7
    X = []
8
    y = []
9
    line = input()
10
    while line:
11
        dx = []
12
        data = [l for l in line.strip().split(',')]
13
        X.append(np.array([np.float(d) for d in data[:-1]]))
14
        y.append(np.int(data[-1]))
15
        line = input()
16
        if '#' in line:
17
            break
18
    return np.array(X),np.array(y)
19

20
def train_test_split(X,Y,test_size=0.2,random_state=5):
21
    n_samples = len(X)
22
    assert len(X)==len(Y)
23

24
    indices = np.arange(n_samples)
25
    random.seed(random_state)
26

27
    train_indexs = list(set(random.sample(indices.tolist(),int(n_samples*(1-test_size)))))
28
    test_indexs = [k for k in indices if k not in train_indexs]
29
    return X[train_indexs,:],X[test_indexs,:],Y[train_indexs],Y[test_indexs]
30

31
X,y = load_digits()
32
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5)
33
class SVC():
34
    def __init__(self,X,Y,alpha,steps,reg):
35
        self.X = X
36
        self.y = Y
37
        self.alpha = alpha
38
        self.steps = steps
39
        self.reg = reg
40
        self.model(self.X,self.y,self.alpha,self.steps,self.reg)
41

42
    def lossAndGradNaive(self,X,Y,W,reg):
43
        dW=np.zeros(W.shape)
44
        loss = 0.0
45
        num_class=W.shape[0]
46
        num_X=X.shape[0]
47
        for i in range(num_X):
48
            scores=np.dot(W,X[i])
49
            cur_scores=scores[int(Y[i])]
50
            for j in range(num_class):
51
                if j==Y[i]:
52
                    continue
53
                margin=scores[j]-cur_scores+1
54
                if margin>0:
55
                    loss+=margin
56
                    dW[j,:]+=X[i]
57
                    dW[int(Y[i]),:]-=X[i]
58
        loss/=num_X
59
        dW/=num_X
60
        loss+=reg*np.sum(W*W)
61
        dW+=2*reg*W
62
        return loss,dW
63

64
    def lossAndGradVector(self,X,Y,W,reg):
65
        dW=np.zeros(W.shape)
66
        N=X.shape[0]
67
        Y_=X.dot(W.T)
68
        margin=Y_-Y_[range(N),Y.astype(int)].reshape([-1,1])+1.0
69
        margin[range(N),Y.astype(int)]=0.0
70
        margin=(margin>0)*margin
71
        loss=0.0
72
        loss+=np.sum(margin)/N
73
        loss+=reg*np.sum(W*W)
74

75
        countsX=(margin>0).astype(int)
76
        countsX[range(N),Y.astype(int)]=-np.sum(countsX,axis=1)
77
        dW+=np.dot(countsX.T,X)/N+2*reg*W
78
        return loss,dW
79

80
    def predict(self,X,W):
81
        X=np.hstack([X, np.ones((X.shape[0], 1))])
82
        Y_=np.dot(X,W.T)
83
        Y_pre=np.argmax(Y_,axis=1)
84
        return Y_pre
85

86
    def accuracy(self,X,Y):
87
        Y_pre=self.predict(X,self.W)
88
        acc=(Y_pre==Y).mean()
89
        return acc
90

91
    def model(self,X,Y,alpha,steps,reg):
92
        X=np.hstack([X, np.ones((X.shape[0], 1))])
93
        W = np.random.randn(10,X.shape[1]) * 0.0001
94
        for step in range(steps):
95
            loss,grad=self.lossAndGradNaive(X,Y,W,reg)
96
            W-=alpha*grad
97
        self.W = W
98

99
svc=SVC(X_train,y_train,0.01,25,0.5)
100
acc = svc.accuracy(X_test,y_test)
101

102

103
print("debug_begin");
104
def test_acc(acc):
105
    res = True if acc>0.85 else False
106
    print(res)
107
print("debug_end");
108

109
test_acc(acc)

svm-梯度下降实现 SVM 多分类问题#

1
import numpy as np
2
import warnings
3

4
def  load_iris():
5
        X  =  []
6
        y  =  []
7
        line  =  input()
8
        while  line:
9
            dx  =  []
10
            data  =  [l  for  l  in  line.strip().split(',')]
11
            X.append(np.array([np.float(d)  for  d  in  data[:-1]]))
12
            y.append(np.int(data[-1]))
13
            line  =  input()
14
            if '#' in line:
15
                break
16
        return  np.array(X),np.array(y)
17

18
x,y = load_iris()
19
print("debug_begin");
20
def test_acc(acc):
21
        res = True if acc>=0.9 else False
22
        print(res)
23
print("debug_end");
24

25
def normalize_data(data):
26
    mean = np.mean(data, axis=0)
27
    std = np.std(data, axis=0)
28
    for i in range(data.shape[0]):
29
        data[i, :] = (data[i, :] - mean) / std
30
    return  data
31

32
def convert_to_one_hot(y, C):
33
    return np.eye(C)[y.reshape(-1)]
34

35
batchsz = 150
36

37
def obtain_w_via_gradient_descent(x, c, y, penalty_c, threshold = 1e-19, learn_rate = 1e-4):
38
    """ 利用梯度下降法求解如下的SVM问题：min 1/2 * w^T * w + C * Σ_i=1:n（max(0, 1 - y_i * (w^T * x_i + b))）
39
    :param x: 训练样本 x = [x_1, x_2, ..., x_i]
40
    :param c: 类别数
41
    :param y: 样本标签 y = [y_1, y_2, ..., y_c]
42
    :param threshold: 梯度下降停止阈值
43
    """
44
    data_num = np.shape(x)[1]
45
    feature_dim = np.shape(x)[0]
46
    w = np.ones([feature_dim, c], dtype=np.float32)
47
    b = np.ones([c, 1], dtype=np.float32)
48
    dl_dw = np.zeros([feature_dim, c], dtype=np.float)
49
    dl_db = np.zeros([c, 1], dtype=np.float)
50
    it = 1
51
    th = 0.1
52
    while it < 50000 and th > threshold:
53
        a = np.tile(b, [1, data_num])
54
        ksi = (np.transpose(w) @ x + np.tile(b, [1, data_num])) * y
55
        index_martix = ksi < 1
56

57
        for class_num in range(c):
58
            index_vector = index_martix[class_num, :]
59

60
            if True in index_vector:
61
                x_c = x[:, index_vector]
62

63
                data_num_c = np.shape(x_c)[1]
64
                e = np.ones([data_num_c, 1], dtype=np.float)
65
                y_c = np.reshape(y[class_num, index_vector], [data_num_c, 1])
66
                w_c = np.reshape(w[:, class_num], [feature_dim, 1])
67
                b_c = b[class_num]
68

69
                dl_dw[:, class_num] = (w_c + 2 * penalty_c * (x_c @ np.transpose(x_c) @ w_c +
70
                                                              x_c @ e * b_c -
71
                                                              x_c @ y_c))[:, 0]
72
                dl_db[class_num, 0] = 2 * penalty_c * (b_c * data_num_c +
73
                                                       np.transpose(w_c) @ x_c @ e -
74
                                                       np.transpose(y_c) @ e)
75
            else:
76
                w_c = np.reshape(w[:, class_num], [feature_dim, 1])
77
                dl_dw[:, class_num] = w_c[:, 0]
78
                dl_db[class_num, 0] = 0
79

80
        w_ = w - learn_rate * (dl_dw / np.linalg.norm(dl_dw, ord=2))
81
        b_ = b - learn_rate * dl_db
82

83
        th = np.sum(np.square(w_ - w)) + np.sum(np.square(b_ - b))
84
        it = it + 1
85

86
        w = w_
87
        b = b_
88

89
        y_predict = np.transpose(w) @ x + np.tile(b, [1, data_num])
90
        correct_prediction = np.equal(np.argmax(y_predict, 0), np.argmax(y, 0))
91
        accuracy = np.mean(correct_prediction.astype(np.float))
92

93
    return accuracy
94

95
warnings.filterwarnings("ignore")
96

97
x = normalize_data(x)
98
y = y.astype(np.int)
99
y_onehot = convert_to_one_hot(y,3)
100
y_onehot[y_onehot==0]=-1
101

102
x = np.transpose(x)
103
y_onehot = np.transpose(y_onehot)
104
w = np.array([[1,1,1],[1,1,1]])
105
b = np.array([[1],[1],[1]])
106
acc = obtain_w_via_gradient_descent(x,3,y_onehot,0.5)
107

108
test_acc(acc)

音乐

音乐

评估方法（留出法）#

评估方法（交叉验证法）#

优化算法-梯度下降法 1#

优化算法-梯度下降法 2#

线性回归-糖尿病预测#

逻辑回归-乳腺癌预测#

svm-手写数字识别#

svm-梯度下降实现 SVM 多分类问题#

分享到社交平台

评论

音乐

目录