精华内容
下载资源
问答
  • import matplotlib.pyplot as plt from tensorflow import keras import tensorflow as tf import matplotlib as mpl import pandas as pd import numpy as np import sklearn import time import sys ...
  • 1.代码没有引入深度学习包,实现了简单的随机梯度下降算法。 2.理论较简单。 # coding:utf8 # Author:Chaz import sys,time import numpy as np g = open("reviews.txt","r") reviews = list(map...

    1.代码没有引入深度学习包,实现了简单的随机梯度下降算法。

    2.理论较简单。

    # coding:utf8
    # Author:Chaz
    import sys,time
    import numpy as np
    
    g = open("reviews.txt","r")
    reviews = list(map(lambda x:x[:-1],g.readlines()))
    g.close()
    
    f = open("labels.txt","r")
    labels = list(map(lambda x:x[:-1].upper(),f.readlines()))
    f.close()
    
    class SentimentNetwork():
        def __init__(self,reviews,labels,hidden_nodes = 10 ,learning_rate = 0.1):
            np.random.seed(1)
            self.pre_process_data(reviews,labels)
            self.init_network(len(self.review_vocab),hidden_nodes,1,learning_rate)
    
        def pre_process_data(self,reviews,labels):
            review_vocab = set()
            for review in reviews:
                for word in review.split(" "):
                    review_vocab.add(word)
            self.review_vocab = list(review_vocab)
    
            label_vocab = set()
            for label in labels:
                label_vocab.add(label)
            self.label_vocab = list(label_vocab)
    
            self.review_vocab_size = len(self.review_vocab)
            self.label_vocab_size = len(self.label_vocab)
    
            self.word2index = {}
            for i,word in enumerate(review_vocab):
                self.word2index[word] = i
    
            self.label2index = {}
            for i,label in enumerate(label_vocab):
                self.label2index[label] = i
    
        def init_network(self,input_nodes,hidden_nodes,output_nodes,learning_rate):
            self.input_nodes = input_nodes
            self.hidden_nodes = hidden_nodes
            self.output_nodes = output_nodes
    
            self.learning_rate = learning_rate
    
            self.weight_0_1 = np.zeros((self.input_nodes,self.hidden_nodes))
            self.weight_1_2 = np.random.normal(0.0,self.output_nodes**-0.5,(self.hidden_nodes,self.output_nodes))
    
            self.layer_0 = np.zeros((1,self.input_nodes))
            self.layer_1 = np.zeros((1, hidden_nodes))
    
        def update_input_layer(self,review):
            self.layer_0 *=0
            for word in review.split(" "):
                if word in self.word2index.keys():
                    # print(self.word2index[word])
                    # print(self.layer_0[0])
                    self.layer_0[0][self.word2index[word]] = 1
    
    
        def get_target_for_label(self,label):
            if label == "POSITIVE":
                return 1
            else:
                return 0
    
        def sigmoid(self,x):
            return 1/(1 + np.exp(-x))
    
        def sigmoid_output_2_derivative(self,output):
            return output * (1 - output)
    
        def train(self,train_reviews_raw,train_labels):
            train_reviews = list()
            for review in train_reviews_raw:
                indices = set()
                for word in review.split(" "):
                    if (word in self.word2index.keys()):
                        indices.add(self.word2index[word])
                train_reviews.append(list(indices))
            assert (len(train_reviews) == len(train_labels))
            correct_so_far = 0
            start = time.time()
    
            for i in range(len(train_reviews)):
                review = train_reviews[i]
                label = train_labels[i]
                self.update_input_layer(train_reviews_raw[i])
                self.layer_1 *= 0
                for index in review:
                    self.layer_1 += self.weight_0_1[index]
    
                layer_2 = self.sigmoid(self.layer_1.dot(self.weight_1_2))
    
                layer_2_error = layer_2 - self.get_target_for_label(label) # Output layer error is the difference between desired target and actual output.
                layer_2_delta = layer_2_error * self.sigmoid_output_2_derivative(layer_2)
    
                layer_1_error = layer_2_delta.dot(self.weight_1_2.T) # errors propagated to the hidden layer
                layer_1_delta = layer_1_error # hidden layer gradients - no nonlinearity so it's the same as the error
    
                self.weight_1_2 -= self.layer_1.T.dot(layer_2_delta) * self.learning_rate # update hidden-to-output weights with gradient descent step
                for index in review:
    
                    self.weight_0_1[index] -= layer_1_delta[0] * self.learning_rate
    
                if layer_2 > 0.5 and label == "POSITIVE":
                    correct_so_far += 1
                elif layer_2 <0.5 and label =="NEGATIVE":
                    correct_so_far += 1
    
                elapsed_time = float(time.time() - start)
    
                reviews_per_second = i / elapsed_time if elapsed_time > 0 else 0
    
                sys.stdout.write("\rProgress:" + str(100 * i / float(len(train_reviews)))[:4] \
                                 + "% Speed(reviews/sec):" + str(reviews_per_second)[0:5] \
                                 + " #Correct:" + str(correct_so_far) + " #Trained:" + str(i + 1) \
                                 + " Training Accuracy:" + str(correct_so_far * 100 / float(i + 1))[:4] + "%")
                if i % 2500 == 0 :
                    print("")
    
    
        def test(self,test_reviews,test_labels):
            correct = 0
            start = time.time()
    
            for i in range(len(test_reviews)):
                pred = self.run(test_reviews[i])
                if pred == test_labels[i]:
                    correct +=1
                elapsed_time = float(time.time() - start)
    
                reviews_per_second = i / elapsed_time if elapsed_time > 0 else 0
                sys.stdout.write("\rProgress:" + str(100 * i / float(len(test_reviews)))[:4] \
                             + "% Speed(reviews/sec):" + str(reviews_per_second)[0:5] \
                             + " #Correct:" + str(correct) + " #Tested:" + str(i + 1) \
                             + " Test Accuracy:" + str(correct * 100 / float(i + 1))[:4] + "%")
        def run(self,review):
            self.update_input_layer(review.lower())
            # print(self.layer_0.shape,self.weight_0_1.shape)
            layer_1 = self.layer_0.dot(self.weight_0_1)
            # print(layer_1.shape,self.weight_1_2.shape)
            layer_2 = self.sigmoid(layer_1.dot(self.weight_1_2))
    
            if layer_2[0] > 0.5 :
                return "POSITIVE"
            else:
                return "NEGATIVE"
    
    mlp = SentimentNetwork(reviews[:-1000],labels[:-1000],learning_rate=0.001)
    mlp.train(reviews[:-1000],labels[:-1000])
    mlp.test(reviews[-1000:],labels[-1000:])
    View Code

    某一层w梯度 = 输入.T * ((后一层delta * 后一层权重.T == error)* 激活函数导数 ==这一层delta)* 学习速率

     

    转载于:https://www.cnblogs.com/jackzone/p/8413745.html

    展开全文
  • import numpy as np import pandas as pd # 准备数据 # 评分矩阵 R = np.array([[4, 0, 2, 0, 1], [0, 2,...# 算法实现 """ @输入参数: R: M*N的评分矩阵 K: 隐特征向量维度 max_iter:最大迭代次数 alpha:步长 lamd
    import numpy as np
    import pandas as pd
    
    # 准备数据
    # 评分矩阵
    R = np.array([[4, 0, 2, 0, 1], [0, 2, 3, 0, 0], [1, 0, 2, 4, 0], [5, 0, 0, 3, 1], [0, 0, 1, 5, 1], [0, 3, 2, 4, 1]])
    print(len(R))
    
    # 算法实现
    """
    @输入参数:
    R: M*N的评分矩阵
    K: 隐特征向量维度
    max_iter:最大迭代次数
    alpha:步长
    lamda:正则化系数
    
    @输出:
    分解之后的P,Q
    P:初始化用户特征矩阵M*K
    Q:初始化物品特征矩阵N*K
    """
    # 给定超参数
    K = 50  
    max_iter = 5000
    alpha = 0.0002
    lamda = 0.0001
    
    
    # 核心算法
    def LFM_grad_desc(R, K=2, max_iter=1000, alpha=0.0001, lamda=0.005):
        # 基本唯独参数
        M = len(R)
        N = len(R[0])
        # P,Q初始值,随机生成
        P = np.random.rand(M, K)
        Q = np.random.rand(N, K)
        Q = Q.T
        # 开始迭代
        for step in range(max_iter):
            # 对所有的用户u,物品i做遍历,对应的特征向量Pu,Qi梯度下降
            for u in range(M):
                for i in range(N):
                    # 对于每一个大于0的评分,求出预测评分误差
                    if R[u][i] > 0:
                        eui = np.dot(P[u, :], Q[:, i]) - R[u][i]
                        # 代入公式,按照梯度下降算法更新当前的Pu,Qi
                        for k in range(K):
                            P[u][k] = P[u][k] - alpha * (2 * eui * Q[k][i] + 2 * lamda * P[u][k])
                            Q[k][i] = Q[k][i] - alpha * (2 * eui * P[u][k] + 2 * lamda * Q[k][i])
            # u , i遍历完成,所有特征向量更新完成,可以得到P,Q,可以计算预测评分矩阵
            predR = np.dot(P, Q)
            # 计算当前损失函数
            cost = 0
            for u in range(M):
                for i in range(N):
                    if R[u][i] > 0:
                        cost += (np.dot(P[u, :], Q[:, i]) - R[u][i]) ** 2
                        # 加上正则化项
                        for k in range(K):
                            cost += lamda * (P[u][k] ** 2 + Q[k][i] ** 2)
            if cost < 0.001:
                break
        return P, Q.T, cost
    
    
    p, q, cost = LFM_grad_desc(R, K, max_iter, alpha, lamda)
    print(p)
    print(q)
    print(cost)
    pop =p.dot(q.T)
    print(pop)
    print(R)
    
    
    展开全文
  • 梯度下降代码

    2018-08-14 14:04:00
    1 #!usr/bin/python3 2 # coding:utf-8 3 4 # BGD 批梯度下降代码实现 5 # SGD 随机梯度下降代码实现 6 import numpy as np 7 8 import ran...

    https://blog.csdn.net/panghaomingme/article/details/79384922

     

     

     1 #!usr/bin/python3
     2 # coding:utf-8
     3  
     4 # BGD 批梯度下降代码实现
     5 # SGD 随机梯度下降代码实现
     6 import numpy as np
     7  
     8 import random
     9  
    10  
    11 def batchGradientDescent(x, y, theta, alpha, m, maxInteration):
    12     x_train = x.transpose()
    13     for i in range(0, maxInteration):
    14         hypothesis = np.dot(x, theta)
    15         # 损失函数
    16         loss = hypothesis - y
    17         # 下降梯度
    18         gradient = np.dot(x_train, loss) / m
    19         # 求导之后得到theta
    20         theta = theta - alpha * gradient
    21     return theta
    22  
    23  
    24 def stochasticGradientDescent(x, y, theta, alpha, m, maxInteration):
    25     data = []
    26     for i in range(4):
    27         data.append(i)
    28     x_train = x.transpose()
    29     for i in range(0, maxInteration):
    30         hypothesis = np.dot(x, theta)
    31         # 损失函数
    32         loss = hypothesis - y
    33         # 选取一个随机数
    34         index = random.sample(data, 1)
    35         index1 = index[0]
    36         # 下降梯度
    37         gradient = loss[index1] * x[index1]
    38         # 求导之后得到theta
    39         theta = theta - alpha * gradient
    40     return theta
    41  
    42  
    43 def main():
    44     trainData = np.array([[1, 4, 2], [2, 5, 3], [5, 1, 6], [4, 2, 8]])
    45     trainLabel = np.array([19, 26, 19, 20])
    46     print(trainData)
    47     print(trainLabel)
    48     m, n = np.shape(trainData)
    49     theta = np.ones(n)
    50     print(theta.shape)
    51     maxInteration = 500
    52     alpha = 0.01
    53     theta1 = batchGradientDescent(trainData, trainLabel, theta, alpha, m, maxInteration)
    54     print(theta1)
    55     theta2 = stochasticGradientDescent(trainData, trainLabel, theta, alpha, m, maxInteration)
    56     print(theta2)
    57     return
    58  
    59  
    60 if __name__ == "__main__":
    61     main()

     

    转载于:https://www.cnblogs.com/zhangbojiangfeng/p/9474298.html

    展开全文
  • 在学习了有关梯度下降算法后,自己动手实现了一边,选用的也是最为简单的线性回归作为例子梯度下降的的相关原理及推导网上有很多,由于个人不擅长推理总结,我就不再画蛇添足了,贴几个我看完之后觉的不错的帖子,在...

    在学习了有关梯度下降算法后,自己动手实现了一遍,选用的也是最为简单的线性回归作为例子

    梯度下降的的相关原理及推导网上有很多,由于个人不擅长推理总结,我就不再画蛇添足了,贴几个我看完之后觉的不错的帖子,在此感谢各位博主

    深度解读最流行的优化算法:梯度下降

    一文看懂常用的梯度下降算法

    梯度下降的三种形式BGD、SGD、以及MBGD

    梯度下降的三种形式BGD、SGD、以及MBGD

    最后两个是不同的博客,但他们的标题相同

    三种算法中文名分别为

    1. 批量梯度下降(Batch gradient descent)

    2. 随机梯度下降(Stochastic gradient descent)

    3. 小批量梯度下降(Mini-batch gradient descent)

    不过都叫梯度下降算法,可见他们的核心是没有变的,变化的只是取训练集的方式,而梯度下降最核心的就是对函数求偏导,这个是在高等数学里有的。

    首先是BGD,他是使用所有数据集进行训练。具体代码为:

    import  matplotlib.pyplot as plt
    import random
    import matplotlib
    
    #生成数据
    def data():
        x = range(10)
        y = [(2*s+4) for s in x]
        for i in range(10):
            y[i] = y[i]+random.randint(0,8)-4
        return x, y
    
    #使用梯度下降进行训练
    def diedai(x,y):
        flag = True
        a = random.randint(0,5)
        b = random.randint(0,10)
        m = len(x)
        arf = 0.005 #学习率
        n = 0
        sum1 = 0
        sum2 = 0
        exp = 0.000001
        error0 = 0
        error1 = 0
        while flag:
    
            for i in range(m):  #计算对应的偏导数
                sum1 = a*x[i]+b-y[i]
                sum2 = (a*x[i]+b-y[i])*x[i]
                error1 = (a*x[i]+b-y[i])**2
            a = a - sum2*arf/m  #对a,b进行更新
            b = b - sum1*arf/m
    
            if abs(error1-error0)<exp: #计算误差
                break
            error0 = error1
            print('a=%f,b=%f,error=%f' % (a, b, error1))
    
            if n > 500:
                #flag = False
                break
            n += 1
            if n % 10 == 0:
                print('第%d次迭代:a=%f,b=%f' % (n, a, b))
        return a,b
    
    #使用最小二乘法计算结果
    def calculation(x, y):
        c1 = 0
        c2 = 0
        c3 = 0
        c4 = 0
        n = len(x)
        for i in range(n):
            c1 += x[i]*y[i]
            c2 += x[i]*x[i]
            c3 += x[i]
            c4 += y[i]
        a = (n*c1-c3*c4) /( n*c2-c3*c3)  #利用公式计算a, b
        b = (c2*c4-c3*c1) / (n*c2-c3*c3)
        return a, b
    
    
    if __name__ == '__main__':
        x,y = data()
    
        a1,b1 = diedai(x,y)
        X1 = range(10)
        Y1 = [(a1*s+b1) for s in X1]
        print('梯度下降y=%fX+%f'%(a1,b1))
    
        a2,b2 = calculation(x,y)
        X2 = range(10)
        Y2 = [(a2*s+b2) for s in X2]
        print('最小二乘法y=%fX+%f'%(a2,b2))
    
        matplotlib.rcParams['font.sans-serif'] = ['SimHei'] #设置字体中文,防止乱码
        plt.scatter(x, y, color = 'red',label = '数据')
        plt.plot(X1, Y1, color = 'blue',label = '梯度下降')
        plt.plot(X2, Y2, color = 'green',label = '最小二乘法')
        plt.legend()
        plt.show()
    

    这里我使用了最小二乘法作为参考

    训练的结果为


    可以很明显的看出,两种方法是存在偏差的,至于原因我也很想知道,也许是梯度下降算法作为迭代算法迭代的不够彻底,不过这也只是我的猜测,希望谁知道的能和我透露一下

    批量梯度下降算法由于是使用了所有的数据集,因此,当数据集很大时,他的计算会出现溢出,或者计算时间非常长的问题,而随机梯度下降算法就很好的解决了问题,他的每次迭代使用的是一组数据,也就是一个结果(y)和他对应的变量(x),下面是他的代码:

    from matplotlib import pyplot as plt
    import  random
    
    
    #生成数据
    def data():
        x = range(10)
        y = [(2*i+4) for i in x]
        for i in range(10):
            y[i] = y[i]+random.randint(0,8)-4
        return x,y
    
    
    #使用随机梯度下降训练
    def SGD(x,y):
        error0 = 0
        step_size = 0.001
        esp = 1e-6
        #a = random.randint(0,4)
        #b = random.randint(0,8)
        a = 1.2  #将给a,b随机赋初始值
        b = 3.5
        m = len(x)
        n = 0
        while True:
            i = random.randint(0,m-1)
            print(i)
            sum0 = a * x[i] + b - y[i]
            sum1 = (a * x[i] + b - y[i])*x[i]
            error1 = (a * x[i] + b - y[i])**2  #计算模型和结果的误差
    
            a = a - sum1*step_size/m
            b = b - sum0*step_size/m
            print('a=%f,b=%f,error=%f'%(a,b,error1))
    
            if abs(error1-error0)<esp:  #误差很小,可以终止迭代
                break
            error0 = error1
            n = n+1
            if n%20==0:
                print('第%d次迭代'%n)
            if (n>500):
                break
        return a,b
    if __name__ == '__main__':
        x,y = data()
        a,b = SGD(x,y)
        X = range(10)
        Y = [(a*i+b) for i in X]
    
        plt.scatter(x,y,color='red')
        plt.plot(X,Y)
        plt.show()
    
    运算结果为:


    和批量梯度下降算法一样他也能很好的得到结果,不过这个算法也存在缺陷,那就是由于每次迭代只是用一组数据,因此他受噪声/离群点/异常值的影响非常大,由此有了一种折中的方法,那就只小批量梯度下降算法,他在每次迭代时使用一批数据,这批数据可以自行选择也可以随机产生,大小也可自由自定,越大越接近批量梯度下降算法,越小越接近随机梯度下降算法,下面是我的代码:

    from  matplotlib import pyplot as plt
    import random
    
    #生成数据
    def data():
        x = range(10)
        y = [(3*i+2) for i in x]
        for i in range(len(y)):
            y[i] = y[i]+random.randint(0,5)-3
        return x,y
    
    #用小批量梯度下降算法进行迭代
    def MBGD(x,y):
        error0 = 0
        error1 = 0
        n = 0
        m = len(x)
        esp = 1e-6
        step_size = 0.01  #选择合理的步长
        a = random.randint(0,10)  #给a,b赋初始值
        b = random.randint(0,10)
        while True:
            trainList = []
            for i in range(5):  #创建随机的批量
                trainList.append(random.randint(0,m-1))
    
            for i in range(5):  #对数据进行迭代计算
                s = trainList[i]
                sum0 = a*x[s]+b-y[s]
                sum1 = (a*x[s]+b-y[s])*x[s]
                error1 = error1+(a*x[s]+b-y[s])**2
            a = a - sum1*step_size/m
            b = b - sum0*step_size/m
            print('a=%f,b=%f,error=%f'%(a,b,error1))
    
            if error1-error0<esp:
                break
    
            n = n+1
            if n>500:
                break
        return a, b
    if __name__ == '__main__':
        x,y = data()
        a,b = MBGD(x,y)
        X = range(len(x))
        Y = [(a*i+b) for i in X]
    
        plt.scatter(x,y,color='red')
        plt.plot(X,Y,color='blue')
        plt.show()

    运行结果为:

    这就是三种梯度下降算法了,有什么问题欢迎各位指正



    展开全文
  • 批梯度下降和随机梯度下降存在着一定的差异,主要是在theta的更新上,批量梯度下降使用的是将所有的样本都一批次的引入到theta的计算中,而随机梯度下降在更新theta时只是随机选择...# BGD 批梯度下降代码实现 # SGD...
  • 梯度下降: 分治法—可能会错过更好的取值。如果数据集或者维度大,代价也大。
  • 梯度下降法的python代码实现(多元线性回归最小化损失函数)1、梯度下降法主要用来最小化损失函数,是一种比较常用的最优化方法,其具体包含了以下两种不同的方式:批量梯度下降法(沿着梯度变化最快的方向进行搜索...
  • 上一期有写过关于机器学习的基础概念和梯度下降算法的基础公式和三种分类 今天内容: 1.梯度下降算法的矩阵算法及代码实现 2.凸函数 3.海森矩阵与泰勒展开式
  • 1. 梯度下降代码实现 先随机构造一些散点,再用一条直线来拟合这些散点 import random import matplotlib.pyplot as plt # 构造数据 X = [i/100 for i in range(100)] # 100个数据(0-0.99) Y = [3 * x + 4 + random...
  • 在学习线性回归的时候很多课程都会讲到用梯度下降法求解参数,对于梯度下降算法怎么求出这个解讲的较少,自己实现一遍算法比较有助于理解算法,也能注意到比较细节的东西。具体的数学推导可以参照这一篇博客...
  • 我们先创建一组数据,来对这组数据应用一下三种梯度下降看下区别。我们先创建一组数据,来对这组数据应用一下三种梯度下降看下区别。我们在python里面实现可视化,首先需要导入一些必要的包import 然后,我们自己...
  • 前言梯度下降法是深度学习领域用于最优化的常见方法,根据使用的batch大小,可分为随机梯度下降法(SGD)和批量梯度下降法(BGD)和小批量梯度下降法(MBGD),这里简单介绍下并且提供Python代码演示。 如有谬误,...
  • 三种梯度算法:1.批量梯度下降(BGD)指在计算梯度下降...小批量梯度下降(MBGD)每次迭代使用一个以上又不是全部的样本代码实现1.导包和保存图片import numpy as np #导入操作系统 import os #画图 %matplotlib in...
  • 批量梯度下降算法和随机梯度下降算法的代码实现 随机梯度下降和批量梯度下降都是梯度下降方法的一种,都是通过求偏导的方式求参数的最优解。批量梯度下降算法:,。是通过对每一个样本求偏导,然后挨个更新。...
  • 第十一节梯度下降之手动实现梯度下降和随机梯度下降代码(6) 我们回忆一下,之前咱们讲什么了?梯度下降,那么梯度下降是一种什么算法呢?函数最优化算法。那么它做的是给我一个函数,拿到这个函数之后,我可以...
  • 线性分类器-梯度下降实现代码 之前我们从简单的开始,先给出一条直线,然后依次给出一些点,每给一个点,就按照规则对点进行分类,现在我们往前进一步,给定一群数据点,用直线把他们分开!
  • 1概述梯度下降(Gradient Descent)在机器学习中是很常用的算法,它不仅被用在了线性回归上,还被广泛应用于机器学习的众多领域,它的主要目的是通过迭代找到目标函数的最小值,或者收敛到最小值。本文将从一个下山的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,541
精华内容 616
关键字:

梯度下降代码实现