猫史档案馆

在【优化方法】线性最小二乘中回复

import numpy as np
import warnings
from matplotlib import pyplot as plt
class least_square():
    def __init__(self):
        self.number = 2
        self.data = []
        self.datax = []
        self.label = []
        self.labely = []
        self.p = 0
        self.prediction = []
    def fit_function_number(self,x):
        if x < 2 or int(x) != x:
            raise Exception("fit_function's Number can't be this:(Int and larger than 1)", x)
        self.number = x
    def input_data(self,data,label):
        self.datax = data
        self.labely = label
        data_memroy = []
        xdata_memroy = []
        for a in range(len(data)):
            xdata_memroy = []
            for b in range(self.number):
                xdata_memroy.append(data[a]**b)
            data_memroy.append(xdata_memroy)
        self.data = np.array(data_memroy)
        self.label = np.array([label]).T
    def fit(self):
        self.p = np.linalg.inv(self.data.T.dot(self.data))*(self.data.T.dot(self.label))
        prediction = np.zeros((len(self.p),self.number))
        for a in range(len(self.p)):
            prediction += self.p[a]
        self.prediction = prediction[0]
        warnings.warn('Result is from b-->kn')
        return prediction[0]
    def predict(self,x):
        result = 0
        for i in range(self.number):
            result += self.prediction[i] * (x**i)
        return result
if __name__ == '__main__':
    least_square = least_square()
    x = [1,2,3,4,5]
    y = [7,13,28,40,68]
    least_square.fit_function_number(20)
    least_square.input_data(x,y)
    a = least_square.fit()
    plt.scatter(x,y)
    x1 = np.linspace(1,6,100)
    y1 = least_square.predict(x1)
    plt.plot(x1,y1)
    plt.show()

2018-11-24T12:09:11 点赞:0

在【影评——西虹市首富】之喜剧背后惨不忍睹的真相中回复

http://www.le.com/ptv/vplay/1938988.html?ch=360_kan

2018-11-30T23:01:23 点赞:0

在【梯度下降，最终章】线性回归中回复

补一下链式求导法则证明：

求导法则：若一个函数满足：h(x)= f(g(x))
我们要求∂f/∂x也就是x对于h的偏导数，这有很大计算量，但是：我们将∂f/∂x化简为：∂f/∂g*∂g/∂x（对这两个函数分别求导）。上过小学的人都知道∂f/∂g*∂g/∂x=∂f/∂x，这里就不多赘述了。然后就得到了： h‘(x)=f’(g(x))*g‘(x)
证毕

2018-12-01T11:07:14 点赞:0

在【优化方法】神经网络中回复

import numpy as np
from matplotlib import pyplot as plt
import tqdm
data = np.array([[1,0,1],
                 [0,0,1],
                 [1,1,1],
                 [0,1,1],
                 [1,1,0]])
label = np.array([[1,0,1,0,1]]).T
np.random.seed(1)
def sigmod(x,der=False):
    result = 1/(1+np.exp(-x))
    if not der:
        return result
    else:
        return x*(1-x)
lr = 0.1
l0 = 2*np.random.random((3,3))-1
l1 = 2*np.random.random((3,1))-1

for i in tqdm.tqdm(range(100000)):
    out0 = sigmod(data.dot(l0))
    out1 = sigmod(out0.dot(l1))
    loss = np.sum((out1 - label) ** 2)
    l1_c = np.dot(out0.T, (label - out1) * sigmod(out1, der=True))
    l1 += l1_c*lr
    l0 += np.dot(data.T,l1_c.T*sigmod(out0,der=True))*lr
print(out1)

2层神经网络

2018-12-07T21:45:06 点赞:0

在【优化方法】神经网络中回复

多层神经网络对数据的模式有更高的见解，但是它也有很多问题，比如： center_image 就很难分辨出（0,1,1）和（1,1,0）的区别。因为它对数据分类的标准不再是公式化的了，而是抽象到了一个更高的层次。

很显然神经网络把1的个数与结果联系在了一次，同时还有一些1的位置关系。但单层神经网络却只能考虑1的位置关系。

2018-12-07T22:26:34 点赞:0

在【优化方法】神经网络中回复

如果想获得更快的收敛速度，可以把损失函数换成交叉熵损失。

2018-12-07T22:27:18 点赞:0

在【编程一小时】两行命令教你把.py转为.exe 中回复

2018-12-08T21:17:38 点赞:0

在 python库pykit 中回复

请问一下你是怎么把你做的发到pip上去的？

2018-12-09T10:56:16 点赞:0

在【优化方法】神经网络中回复

import numpy as np
from matplotlib import pyplot as plt
import tqdm
data = np.array([[0,0,1],
                 [0,1,1],
                 [1,0,1],
                 [1,1,1]])
label = np.array([[0],
                  [1],
                  [1],
                  [0]])
np.random.seed(1)
layer0 = 2*np.random.random((3,4))-1
l0_b = 1
layer1 = 2*np.random.random((4,1))-1
l1_b = 1

def sigmod(x,deriv=False):
    output = 1/(1+np.exp(-x))
    if deriv:
        return output*(1-output)
    else:
        return output
lr = 1

for i in tqdm.tqdm(range(100000)):
    out1 = sigmod(data.dot(layer0)+l0_b)
    out2 = sigmod(out1.dot(layer1)+l1_b)

    layer1_error = (label - out2)
    layer1_deriv = layer1_error*sigmod(out2,True)

    layer0_error = layer1_deriv.dot(layer1.T)
    layer0_deriv = layer0_error*sigmod(out1,True)

    layer1 += out1.T.dot(layer1_deriv)*lr
    l1_b += layer1_deriv
    layer0 += data.T.dot(layer0_deriv)*lr
    l0_b += layer0_deriv

print(out2)

之前的两层有个地方写错了，忘记加乘l1了，改了一下现在，然后加了一个偏置单元

2018-12-14T20:23:34 点赞:0

在【优化方法】神经网络中回复

用这个算法分类之前的鸢尾花：

import numpy as np
from matplotlib import pyplot as plt
import tqdm
from sklearn.datasets import load_iris

data_f = load_iris()
target = data_f.target.tolist()
data = data_f.data
data = [x.tolist() for x in data]
del data[90:150]
del target[90:150]
for i in range(len(data)):
    del data[i][2:4]
data = np.array(data)
label = np.array([target]).T

np.random.seed(1)
layer0 = 2*np.random.random((2,30))-1
l0_b = 1
layer1 = 2*np.random.random((30,1))-1
l1_b = 1

def sigmod(x,deriv=False):
    output = 1/(1+np.exp(-x))
    if deriv:
        return output*(1-output)
    else:
        return output
lr = 0.01

for i in range(100000):
    out1 = sigmod(data.dot(layer0)+l0_b)
    out2 = sigmod(out1.dot(layer1)+l1_b)


    layer1_error = (label - out2)
    layer1_deriv = layer1_error*sigmod(out2,True)

    layer0_error = layer1_deriv.dot(layer1.T)
    layer0_deriv = layer0_error*sigmod(out1,True)

    layer1 += out1.T.dot(layer1_deriv)*lr
    l1_b += layer1_deriv
    layer0 += data.T.dot(layer0_deriv)*lr
    l0_b += layer0_deriv
    print("Loss:" + str(np.mean(layer1_error)) + "      第" + str(i) + "/100000轮")

print(out2)