2020-11-2 逻辑回归 二分类 2.1

import math
import torch
import numpy as np

def sigmoid(x):
    '''
    ①定义sigmoid函数,只能传一位数字
    '''
    if x>700:
        x=700
    if x<-700:
        x=-700
    res=1/(1+math.exp(-x))
    return res

def mul_1(a,b):
    '''
    ①把两个横着的一维矩阵对应乘起来，然后相加，得数是一个数字
    ②y=a0·x0+a1·x1+…+an·xn
    '''
    a=torch.tensor([tensor_to_list(a)])
    b=torch.tensor([tensor_to_list(b)])
    res=a.float().mm(b.float().t())
    return res

def tensor_to_list(x):
    '''
    将tensor转换成list形式
    '''
    y=np.array(x)
    res=list(y)
    return res


# 【文件操作】
def addwrite(filename,strr):
    with open(filename,'a+',encoding='utf-8')as f:
        f.write(str(strr))
def cleanfile(filename):
    with open(filename,'w',encoding='utf-8')as f:
        pass

方法一

# 【输入】①数据 ②标记 ③学习率
x=[[1,0],[1,1],[1,2],[1,3]]
y=[[0],[0],[1],[1]]

def Logistic_Regression__in_list_out_list(in_datas__list,in_targets__list,choose_training_times__int,out_times__int):
    '''
    输入“数据集” 和 “每一条数据集对应的标记张量”，
    输入“训练次数” 和 “每多少次输出”
    输出的内容是 “当前训练到第几次” 、“西塔张量【重要】”、“当前得分”、“两次的得分差值”
    return的是“最后的西塔张量”
    '''
    # 得到输入x,y
    x=torch.tensor(in_datas__list)
    y=torch.tensor(in_targets__list)

    # 得到西塔的大小，初始化西塔
    leng=x.shape
    leng = list(leng)[1]
    xita = torch.rand(1,leng)
    xita = torch.tensor(tensor_to_list(xita)[0])
    
    aefa=10.
    pinggu_qian=0
    pinggu_xian=0

    logs=[]
    
    try:
        for times in range(choose_training_times__int):
        #【核心 得分函数求导】
            sum=0 #算员
            for t in range(len(x)):#算员
                sum+=x[t]*(sigmoid(mul_1(xita,x[t]))-y[t])#算员

        #【核心 更新】
            xita=xita-aefa*sum

        #【评估】
            pinggu_qian=pinggu_xian
            pinggu=1
            for t in range(len(x)):
                pinggu=pinggu* (sigmoid(mul_1(xita,x[t]))**y[t])*(1-sigmoid(mul_1(xita,x[t])))**(1-y[t]) 
            pinggu_xian=pinggu  
        #【自动改学习率】  
            deerta=pinggu_xian-pinggu_qian
           # 【deerta为前后两次得分函数的差值 】       
            if deerta<=0:
                aefa=0.7*aefa
            if deerta>0:
                if deerta<0.000001:
                    aefa= aefa*1.42
            if aefa>10:
                aefa=10
            po=tensor_to_list(xita)
        # 【输出】
            if times%out_times__int==0:
                q1=times+1
                q2=po
                q3=tensor_to_list(pinggu_xian)
                logs.append([q1,q2,q3])
#                 print(times+1," | 西塔向量：",po," | 得分函数：",tensor_to_list(pinggu_xian),"| 相邻两次提高得分：",tensor_to_list(deerta)," |  \n")
    except:
        pass
    
    return po,tensor_to_list(pinggu_xian),logs

xi,score,logs=Logistic_Regression__in_list_out_list(in_datas__list=x,in_targets__list=y,choose_training_times__int=10000,out_times__int=1000)
for i in logs:
    print(i)
print(xi,score)

方法二

def Logistic_Regression__in_list_out_list(i,xx,yy,aefa,xita,pinggu_qian,pinggu_xian,max_aefa):
    '''
    输入“数据集” 和 “每一条数据集对应的标记张量”，
    输入“训练次数” 和 “每多少次输出”
    输出的内容是 “当前训练到第几次” 、“西塔张量【重要】”、“当前得分”、“两次的得分差值”
    return的是“最后的西塔张量”
    '''
    # 得到输入x,y
    x=torch.tensor(xx)
    y=torch.tensor(yy)


    xita=torch.tensor(xita)
    aefa=aefa
    pinggu_qian=pinggu_qian
    pinggu_xian=pinggu_xian

    log=[]
    
    try:
        sum=0 #算员
        for t in range(len(x)):#算员
            sum+=x[t]*(sigmoid(mul_1(xita,x[t]))-y[t])#算员

        xita=xita-aefa*sum

    #【评估】
        pinggu_qian=pinggu_xian
        pinggu=1
        for t in range(len(x)):
            pinggu=pinggu* (sigmoid(mul_1(xita,x[t]))**y[t])*(1-sigmoid(mul_1(xita,x[t])))**(1-y[t]) 
        pinggu_xian=pinggu  
        
    #【自动改学习率】  
        deerta=pinggu_xian-pinggu_qian
       # 【deerta为前后两次得分函数的差值 】       
        if deerta<=0:
            aefa=0.7*aefa
        if deerta>0:
            if deerta<0.000001:
                aefa= aefa*1.42
        if aefa>max_aefa:
            aefa=max_aefa
        po=tensor_to_list(xita)
    # 【输出】
        q2=po
        q3=tensor_to_list(pinggu_xian)
#         q3=[str('%.07f'%i) for i in q3]
        log.append([i,q2,q3,aefa])
#                 print(times+1," | 西塔向量：",po," | 得分函数：",tensor_to_list(pinggu_xian),"| 相邻两次提高得分：",tensor_to_list(deerta)," |  \n") 
        log=log[0]
        wrong=0
    except:
        wrong=1
#         pass
#         return xx,yy,aefa,tensor_to_list(xita),float(pinggu_qian),float(pinggu_xian),log
        

    
    return xx,yy,aefa,tensor_to_list(xita),float(pinggu_qian),float(pinggu_xian),log,wrong

x=[[1,0],[1,1],[1,2],[1,3]]
y=[[0],[0],[1],[1]]

# 得到西塔的大小，初始化西塔
xita = (tensor_to_list(torch.rand(1,list(torch.tensor(x).shape)[1]))[0])
aefa=10
pinggu_qian=0
pinggu_xian=0

# cleanfile("data.txt")
for i in range(10000):
    x,y,aefa,xita,pinggu_qian,pinggu_xian,log,wrong=Logistic_Regression__in_list_out_list(i,x,y,aefa,xita,pinggu_qian,pinggu_xian,max_aefa=10)
    if wrong:
        break
#     if i%1000==0:
#         addwrite("data.txt",str(log)+'\n')
    if i%1000==0:
        
        print(log)
#     print(log)
#     with open('da.txt','a+',encoding='utf-8')as f:
#         f.write(str(log))
        
#     print(float('%.5f'%aefa),xita,str('%.05f'%(pinggu_xian-pinggu_qian)),log)

log