ml-疑惑之处

1.

尝试使用线性回归和岭回归来耍耍，但效果不咋地
特别是正则项c的取法，奇怪的一批
我觉得可以再那边的y上面动文章，可是不知咋弄
还有，岭回归的函数究竟是什么（不是损失函数 J 那个），和原本的线性函数没区别是吗

import numpy as np
import matplotlib.pyplot as plt
x = np.array([
    [3, 1],
    [2, 5],
    [1, 8],
    [6, 4],
    [5, 2],
    [3, 5],
    [5, 7],
    [4, -1]])
y = np.array([0, 1, 1, 0, 0, 1, 1, 0])
l, r = x[:, 0].min() - 1, x[:, 0].max() + 1
b, t = x[:, 1].min() - 1, x[:, 1].max() + 1
n = 500
grid_x, grid_y = np.meshgrid(np.linspace(l, r, n), np.linspace(b, t, n))
grid_z = np.piecewise(grid_x, [grid_x>grid_y, grid_x<grid_y], [1, 0])

plt.figure('Simple Classification', facecolor='lightgray')
plt.title('Simple Classification', fontsize=20)
plt.xlabel('x', fontsize=14)
plt.ylabel('y', fontsize=14)
plt.tick_params(labelsize=10)
plt.pcolormesh(grid_x, grid_y, grid_z, cmap='gray')
plt.scatter(x[:, 0], x[:, 1], c=y, cmap='brg', s=80)


#下面尝试用线性回归的方法来试试
#没啥就是觉得好玩
#我再确认一下这个y要么0要么1是干什么用的
#只是一个代表，表示x1>x2->0,x1<x2->1
#y=kx+b, distance=|kx0+b-y0|/(k**2+1)**1/2
#loss=(kx0+b-y0)**2/(k**2+1)
#原始的好像不大行，要不考虑下加入c*y来判定，类似岭回归？
#玩不了，这个不知道怎么把y=-1或+1加进去
lr=0.001
times=1000
w=2
b=2
x1=x[:,0]
x2=x[:,1]
c=-5
z=y
y=x2
x=x1
size=int(len(x))
# w=argmin(J(w)=(x.T+c*i).(-1)*x.T*y
#J=(y-w*x)**2+c*w*w
for i in range(times):
    loss=0
    loss=((y-w*x)**2+c*w*w).sum()
    d_k=((-2)*x*(y-w*x)+2*c*w).sum()
    d_b=(2*(y-w*x+b)).sum()
    w=w-d_k*lr
    b=b-d_b*lr
print(loss)
print(w,b)
x1=x
x2=y
x1_max=x1.max()
x1_min=x1.min()
test_x=np.linspace(x1_min,x1_max,100)
x1=test_x
pred_test_y=w*test_x+b
plt.title('try')
plt.plot(test_x, pred_test_y, '--', c='limegreen', label='Regression', linewidth=1)
plt.legend()
plt.show()

2.关于正向激励和特征重要性排序的实现

真的是这样弄吗

3.这是逻辑分类失败的结果

这里的奇怪之处在于结果
https://zhuanlan.zhihu.com/p/74874291

loss function采用的是这个
我的理解是y=w0+w1x1+w2x2
然后用的梯度下降法
但结果差异很大

import numpy as np
import math
import matplotlib.pyplot as mp


def loss_func(w0,w1,w2,x,y):
    x1 = x[:, 0]
    x2 = x[:, 1]
   # print('hello!!!!!!')
   # print('x1',x1)
   # print('x2',x2)
   # print('y',y)
    size_x=int(len(x))
   # print('size_x',size_x)
    fina=0
    e_y=0
    #sum
    for i in range(size_x):
        e_y=0
        p_y_1=0
       # print('i', i)
       # print('w0',w0,'w1',w1,'w2',w2)
       # print('x1[i]', x1[i])
        e_y = w0 + w1 * x1[i] + w2 * x2[i]
        e_y=(-1)*e_y
        #print('e_y:',e_y)

        p_y_1 = 1 / (1 + np.math.exp(e_y))
      #  print('p_y_1',p_y_1)
       # print('YYYYY'*50)


        times_1=math.log(p_y_1)
        temp=1-p_y_1
       # print('times1', times_1)
       # print('temp',temp)
        times_2=math.log(temp)


      #  print('times1',times_1)
       # print('times2',times_2)
        fina = y[i] * times_1 + (1 - y[i]) * times_2+fina
       # print('fina',fina)
       # print('_' * 50)
   # print('*'*50)
    return fina

#y=w0+w1*x1+w2*x2
def model_lr(x,y,times,lr=0.001,w0=1,w1=1,w2=1):
    size_x=int(len(x))
    #p(xi)表示什么
    x1=x[:,0]
    x2=x[:,1]
    loss_last=0
    loss_now=0
    for i in range(times):
       # print('round##########'*50)
       # print('round',i)
        loss_pre = loss_func(w0=w0,w1=w1,w2=w2,x=x,y=y)
       # print('loss_ready&&&&&&'*10)
        loss_last = (-1) * loss_pre / size_x
        # p_x表示x对应的y=1的概率

        d_w_0 = 0
        d_w_1 = 0
        d_w_2 = 0
        for j in range(size_x):
            e_x=0
            e_x = w0 + w1 * x1[j] + w2 * x2[j]
            e_x = (-1) * e_x
            e_x = math.exp(e_x)
            print('times:{:} size:{:} e_x'.format(i,j),e_x)
            d_w_0 = d_w_0+(y[j] * e_x / (1 + e_x))+ (1-y[j]) * e_x / (((e_x +1)**2) + (e_x +1))
            d_w_1 = d_w_1+d_w_0 * x1[j]
            d_w_2 = d_w_2+d_w_0 * x2[j]
        print('d_w_0',d_w_0)
        print('d_w_1',d_w_1)
        print('d_w_2',d_w_2)
        w0=w0-lr*d_w_0
        w1=w1-lr*d_w_1
        w2=w2-lr*d_w_2

        loss_now=loss_func(w0,w1,w2,x,y)
        loss_gap=abs(loss_now-loss_last)
        print('loss_now',loss_now)
        print('times:{:} size:{:} loss_gap'.format(i,j),loss_gap)
        if loss_gap>50:
            break


    print('w0',w0)
    print('w1', w1)
    print('w2', w2)
    return w0,w1,w2


def model_pred(w0,w1,w2,x):
    x1=x[:,0]
    x2=x[:,1]
    e_x = w0 + w1 * x1 + w2 * x2
    e_x = (-1) * e_x
    e_x = math.exp(e_x)

    sigmoid_result=1/(1+e_x)

    return sigmoid_result

#return  z
def jug(samples,size_x, num,model_w_list,y_list):
    jug_array=np.arange(size_x*num).reshape(size_x,num)
    for j in range(size_x):
        for i in range(num):
            #model = model_list[i]
            w0,w1,w2=model_w_list[i][0],model_w_list[i][1],model_w_list[i][2]
            t=[[]]
            t[0]=samples[j]
            sample_in=np.array(t)
            jug_array[j][i]=model_pred(w0=w0,w1=w1,w2=w2,x=sample_in)

    fin_array=np.arange(size_x*1).reshape(size_x,1)
    #y_list中的顺序以及确切数字
    z_pre=[]
    z=[]
    for k in range(size_x):
        a=jug_array[k,:]
        a_f=a.argsort()[::-1]
        #顺序数字
        z_pre.append(a_f[0])
        #得到对应数字
    for i in range(int(len(z_pre))):
        pos=z_pre[i]
        z.append(y_list[pos])
    return z


x = np.array([
    [3, 1],
    [2, 5],
    [1, 8],
    [6, 4],
    [5, 2],
    [3, 5],
    [4, 7],
    [4, -1]])
y = np.array([0, 1, 1, 0, 0, 1, 1, 0])
#print(y)
y_list=list(set(y))
#print(y_list)
num=int(len(set(y)))
#print(num)
size_x=int(len(x))
#print(size_x)
model_list=[]
# 逻辑分类器
# 每一个分类器都得到训练

#train
#w0 w1 w2
model_w_list=np.arange(num*3).reshape(num,3)
for i in range(num):
    print('round',i)
    #exec(f'model_{i} = lm.LogisticRegression(solver=\'liblinear\')')
    chara = y_list[i]
    #print('y',y)
    #y_new = np.where(y ==chara,1,0)
    #y_new=np.array(y_new).ravel()
    #print('y_new',y_new)
    model_w_list[i][0],model_w_list[i][1],model_w_list[i][2]=model_lr(x,y,times=300)
    #print('/'*50)
#print(len(set(list)))
#y=w0+w1*x1+w2*x2
#分类器的话，是不是相符的给1，不相符的给0这样


l, r = x[:, 0].min() - 1, x[:, 0].max() + 1
b, t = x[:, 1].min() - 1, x[:, 1].max() + 1
n = 500

grid_x, grid_y = np.meshgrid(np.linspace(l, r, n), np.linspace(b, t, n))
samples = np.column_stack((grid_x.ravel(), grid_y.ravel()))

size_x=int(len(grid_x))
grid_z=jug(samples,size_x,num,model_w_list=model_w_list,y_list=y_list)
print('grid_z',grid_z)