精华内容
下载资源
问答
  • 在使用layer.tips()对同样使用Layer渲染的表单input控件进行吸附时,如果直接传入input对应的id或其他css选择器,由于Layer在进行二次渲染的时候会隐藏原始的input标签,用新的div层进行替换显示,所以会导致layer的tips...

    在使用layer.tips()对同样使用Layer渲染的表单input控件进行吸附时,如果直接传入input对应的id或其他css选择器,由于Layer在进行二次渲染的时候会隐藏原始的input标签,用新的div层进行替换显示,所以会导致layer的tips提示框无法正确吸附到上面,解决方法是在对input控件进行事件监听,在回调函数中初始化layer.tips,示例代码:

    // 算法切换
        form.on('radio', function (data) {
            // 显示算法公式tip
            let tip = ''
            switch (data.value) {
                case 'y1':
                    tip = '预测=上期*(同期/同期上期)';
                    break;
                case 'y2':
                    tip = '预测=同期';
                    break;
                case 'y3':
                    tip = '预测=本年前期均值';
                    break;
                case 'y4':
                    tip = '预测=上期'
                    break;
            }
            layer.tips(tip, data.othis[0], {
                tips: 3
            })
        })
    

    在这里插入图片描述

    需要注意的是,回调函数中给layer.tips传入的第二个变量(dom),应当使用.othis[0],可以通过控制台中输出form.on回调函数传入变量进行查看:
    在这里插入图片描述

    展开全文
  • 目的:XXXX项目中,很多的弹窗是利用freemarker的网页标签追加的形式实现的,网页弹框只是将隐藏的div显示出来,这样会使网页在预加载时速度变慢,增加页面加载和响应时间 解决方法如下:<已分中心管理的添加分...
  • 一、问题描述(单隐藏层的平面分类问题) 在Planar data数据集中分布着众多散点,X保存着每个散点的坐标,Y保存着每个散点对应的标签(0:红色,1:蓝色),要求用单隐层神经网络对该平面图形进行分类。 二、具体...

    一、问题描述(单隐藏层的平面分类问题)

    相关资料下载:Planar data classification
    在Planar data数据集中分布着众多散点,X保存着每个散点的坐标,Y保存着每个散点对应的标签(0:红色,1:蓝色),要求用单隐层神经网络对该平面图形进行分类。
    在这里插入图片描述

    二、具体实现

    引入机器学习库和相关工具

    import numpy as np # 科学计算包
    import matplotlib.pyplot as plt # 绘图包
    import sklearn # 提供数据挖掘和分析的工具
    import sklearn.datasets 
    import sklearn.linear_model
    from planar_utils import plot_decision_boundary, sigmoid, load_planar_dataset, load_extra_datasets # 加载数据集和一些必要的工具
    

    加载数据集并可视化散点

    # 加载数据集
    X,Y = load_planar_dataset()
    # 绘制散点图,X是含坐标的矩阵,Y是标签 红0蓝1
    plt.scatter(X[0, :], X[1, :], c=np.squeeze(Y), s=40, cmap=plt.cm.Spectral)
    plt.title("scatter pic")
    #打印矩阵维度和数量
    shape_X = X.shape
    shape_Y = Y.shape
    m = Y.shape[1]
    print("X的维度: " + str(shape_X))
    print("Y的维度: " + str(shape_Y))
    print("样本数量: " + str(m))
    

    在这里插入图片描述
    逻辑回归验证正确率
    LogisticRegressionCV使用交叉验证选择正则化系数C,而LogisticRegression每次指定正则化系数

    # 逻辑回归验证准确度
    clf = sklearn.linear_model.LogisticRegressionCV() # LogisticRegressionCV使用交叉验证选择正则化系数C,而LogisticRegression每次指定正则化系数
    clf.fit(X.T, Y.T)
    

    绘制图像边界 计算准确度
    计算准确度的时候分开计算蓝色和红色匹配的数量
    np.dot(Y, LR_predictions) + np.dot(1 - Y,1 - LR_predictions)

    plot_decision_boundary(lambda x: clf.predict(x), X, np.squeeze(Y)) #绘制决策边界
    plt.title("Logistic Regression")
    LR_predictions  = clf.predict(X.T)
    print ("逻辑回归的准确度: %d" % float((np.dot(Y, LR_predictions) + np.dot(1 - Y,1 - LR_predictions)) / float(Y.size) * 100) + "% " + "(正确标记的数据点所占的百分比)")
    print("同为1的数量: " , np.dot(Y, LR_predictions))
    print("同为0的数量: " , np.dot(1 - Y,1 - LR_predictions))
    

    在这里插入图片描述
    定义神经网络结构

    # 定义神经网络结构
    def layer_size(X, Y):
        n_x = X.shape[0]
        n_y = Y.shape[0]
        n_h = 4
        return (n_x, n_h, n_y)
    

    参数的随机初始化

    # 参数的随机初始化
    def initialization(n_x, n_h, n_y):
        # np.random.seed(2)
        W1 = np.random.randn(n_h, n_x)*0.01
        b1 = np.random.randn(n_h, 1)
        W2 = np.random.randn(n_y, n_h)*0.01
        b2 = np.random.randn(n_y, 1)
        
        parameters = {
            "W1": W1,
            "b1": b1,
            "W2": W2,
            "b2": b2
        }
        return parameters
    

    前向传播计算结果
    在这里插入图片描述

    # 前向传播计算结果
    def forward_propagation(X, parameters):
        W1 = parameters["W1"]
        b1 = parameters["b1"]
        W2 = parameters["W2"]
        b2 = parameters["b2"]
        
        Z1 = np.dot(W1, X)+b1
        A1 = np.tanh(Z1)
        Z2 = np.dot(W2, A1)+b2
        A2 = sigmoid(Z2)
        # cache是网络块中的计算结果缓存
        cache = {
            "Z1": Z1,
            "A1": A1,
            "Z2": Z2,
            "A2": A2
        }
        return (A2, cache)
    

    计算成本函数

    # 计算成本函数
    def cost_function(A2, Y, parameters):
        m = Y.shape[1]
        W1 = parameters["W1"]
        W2 = parameters["W2"]
        
        logprobs = np.multiply(np.log(A2), Y)+np.multiply((1-Y), np.log(1-A2))
        cost = -np.sum(logprobs)/m
        cost = float(np.squeeze(cost))
        return cost
    

    反向传播计算梯度
    在这里插入图片描述

    # 反向传播计算梯度
    def backward_propagation(parameters, cache, X, Y):
        m = Y.shape[1]
        W1 = parameters["W1"]
        W2 = parameters["W2"]
        A1 = cache["A1"]
        A2 = cache["A2"]
        
        dZ2 = A2 - Y
        dW2 = np.dot(dZ2, A1.T)/m
        db2 = np.sum(dZ2, axis=1, keepdims=True)/m
        dZ1 = np.multiply(np.dot(W2.T, dZ2), 1-np.power(A1, 2)) # 这一步计算式比较难理解
        dW1 = np.dot(dZ1, X.T)/m
        db1 = np.sum(dZ1, axis=1, keepdims=True)/m
        # 梯度
        grads = {
            "dW1": dW1,
            "db1": db1,
            "dW2": dW2,
            "db2": db2
        }
        return grads
    

    更新参数

    # 更新参数
    def update_para(parameters, grads, learning_rate):
        W1, W2 = parameters["W1"], parameters["W2"]
        b1, b2 = parameters["b1"], parameters["b2"]
        dW1, dW2 = grads["dW1"], grads["dW2"]
        db1, db2 = grads["db1"], grads["db2"]
        
        W1 = W1 - learning_rate * dW1
        b1 = b1 - learning_rate * db1
        W2 = W2 - learning_rate * dW2
        b2 = b2 - learning_rate * db2
        # 更新后的参数
        parameters = {
            "W1": W1,
            "b1": b1,
            "W2": W2,
            "b2": b2
        }
        return parameters
    

    整合函数到神经网络模型中

    # 整合函数到神经网络模型中
    def nn_model(X, Y, n_h, num_iterations, print_cost=False):
        n_x = layer_size(X, Y)[0]
        n_y = layer_size(X, Y)[2]
        parameters = initialization(n_x, n_h, n_y)
        W1 = parameters["W1"]
        b1 = parameters["b1"]
        W2 = parameters["W2"]
        b2 = parameters["b2"]
        
        for i in range(num_iterations):
            A2, cache = forward_propagation(X, parameters) # 前向传播计算结果和缓存
            cost = cost_function(A2, Y, parameters) # 计算成本
            grads = backward_propagation(parameters, cache, X, Y) # 反向传播计算梯度
            parameters = update_para(parameters, grads, learning_rate=0.5) # 梯度下降更新参数
            # 如果打印结果,则1000步打印一次结果
            if(print_cost):
                if(i%1000 == 0):
                    print("iter " + str(i) + "cost: " + str(cost))
        return parameters
    

    通过前向传播预测结果

    # 通过前向传播预测结果
    def predict(parameters, X):
        A2, cache = forward_propagation(X, parameters)
        predictions = np.round(A2) # 取整数的好处是不会出现小数标签,绘制图形更好看
        return predictions
    

    运行神经网络

    # 运行神经网络
    n_h = 5
    parameters = nn_model(X, Y, n_h, num_iterations=25000, print_cost=True)
    
    plot_decision_boundary(lambda x: predict(parameters, x.T), X, np.squeeze(Y)) # 绘制边界图像
    plt.title("Decision Boundary for hidden layer size " + str(n_h))
    
    prediction = predict(parameters, X)
    # 准确率的计算仍然是 匹配的点/总点数,匹配点的数量分同0和同1计算,如下
    print ('准确率: %d' % float((np.dot(Y, prediction.T) + np.dot(1 - Y, 1 - prediction.T)) / float(Y.size) * 100) + '%')
    

    训练结果

    iter 0cost: 0.708071085308046
    iter 1000cost: 0.30741440010693716
    iter 2000cost: 0.26601981480091225
    iter 3000cost: 0.25139451348937925
    iter 4000cost: 0.2298323066007118
    iter 5000cost: 0.2234268984966187
    iter 6000cost: 0.21873641221070306
    iter 7000cost: 0.21388024684888593
    iter 8000cost: 0.19533195452554392
    iter 9000cost: 0.1892464095610981
    iter 10000cost: 0.18496394205003877
    iter 11000cost: 0.18196909243120452
    iter 12000cost: 0.17972243505532348
    iter 13000cost: 0.17794110287197373
    iter 14000cost: 0.17647612528102935
    iter 15000cost: 0.17524134831706156
    iter 16000cost: 0.17418234038607008
    iter 17000cost: 0.17326220087879385
    iter 18000cost: 0.1724545312969843
    iter 19000cost: 0.17173966168538932
    iter 20000cost: 0.1711024741907582
    iter 21000cost: 0.17053106797985465
    iter 22000cost: 0.17001589646671766
    iter 23000cost: 0.16954918490791848
    iter 24000cost: 0.169124522707884
    准确率: 92%
    

    在这里插入图片描述
    准确率92%,对于该分类已经比较高了

    更改数据集再分类

    # 数据集
    noisy_circles, noisy_moons, blobs, gaussian_quantiles, no_structure = load_extra_datasets()
    
    datasets = {"noisy_circles": noisy_circles,
                "noisy_moons": noisy_moons,
                "blobs": blobs,
                "gaussian_quantiles": gaussian_quantiles}
    
    dataset = "noisy_moons"
    
    X, Y = datasets[dataset]
    X, Y = X.T, Y.reshape(1, Y.shape[0])
    
    if dataset == "blobs":
        Y = Y % 2
    
    plt.scatter(X[0, :], X[1, :], c=np.squeeze(Y), s=40, cmap=plt.cm.Spectral)
    
    #上一语句如出现问题请使用下面的语句:
    plt.scatter(X[0, :], X[1, :], c=np.squeeze(Y), s=40, cmap=plt.cm.Spectral)
    

    在这里插入图片描述

    # 运行数据网络
    n_h = 5
    parameters = nn_model(X, Y, n_h, num_iterations=25000, print_cost=True)
    
    plot_decision_boundary(lambda x: predict(parameters, x.T), X, np.squeeze(Y)) # 绘制边界图像
    plt.title("Decision Boundary for hidden layer size " + str(n_h))
    
    prediction = predict(parameters, X)
    # 准确率的计算仍然是 匹配的点/总点数,匹配点的数量分同0和同1计算,如下
    print ('准确率: %d' % float((np.dot(Y, prediction.T) + np.dot(1 - Y, 1 - prediction.T)) / float(Y.size) * 100) + '%')
    
    iter 0cost: 0.6953767909586918
    iter 1000cost: 0.2938169576936265
    iter 2000cost: 0.07705498285251608
    iter 3000cost: 0.062488993936143426
    iter 4000cost: 0.058931589658356966
    iter 5000cost: 0.056946048269672665
    iter 6000cost: 0.055645528178731835
    iter 7000cost: 0.054698321167242055
    iter 8000cost: 0.05395184439329581
    iter 9000cost: 0.05333117668530852
    iter 10000cost: 0.052796360926562376
    iter 11000cost: 0.05232364189395759
    iter 12000cost: 0.05189625128163916
    iter 13000cost: 0.05149926690336055
    iter 14000cost: 0.051120974867204225
    iter 15000cost: 0.05076631084235808
    iter 16000cost: 0.05044577096739575
    iter 17000cost: 0.05015438308266772
    iter 18000cost: 0.04988493864244256
    iter 19000cost: 0.049632881965477035
    iter 20000cost: 0.04939438719967626
    iter 21000cost: 0.04916468184485608
    iter 22000cost: 0.04893603383575437
    iter 23000cost: 0.04869585695442612
    iter 24000cost: 0.04843254504777489
    准确率: 98%
    

    在这里插入图片描述

    展开全文
  • 一、笔记 二、总代 planar_utils是自己写的生成数据代码,可以去文章底部复制 import numpy as np import matplotlib.pyplot as plt from planar_utils ... Y - 标签,维度为(输出的数量,训练/测试数量) (1,400)

    一、笔记

    在这里插入图片描述

    二、总代

    planar_utils是自己写的生成数据代码,可以去文章底部复制

    import numpy as np
    import matplotlib.pyplot as plt
    from planar_utils import * 
    def layer_sizes(X,Y,h):
        """
        参数:
         X - 输入数据集,维度为(输入的数量,训练/测试的数量) (2,400)
         Y - 标签,维度为(输出的数量,训练/测试数量)        (1,400)
         h - 隐藏层结点个数
        返回:
         n_x - 输入层的数量
         n_h - 隐藏层的数量
         n_y - 输出层的数量
        """
        n_x = X.shape[0]
        n_h = h
        n_y = Y.shape[0]
        return n_x,n_h,n_y
    def init_w_b(n_x,n_h,n_y):
        """
        参数:
            n_x - 输入层节点的数量
            n_h - 隐藏层节点的数量
            n_y - 输出层节点的数量
        返回:
            params - 包含参数的字典:
                W1 - 权重矩阵,维度为(n_h,n_x)
                b1 - 偏向量,维度为(n_h,1)
                W2 - 权重矩阵,维度为(n_y,n_h)
                b2 - 偏向量,维度为(n_y,1)
        """
        np.random.seed(2)
        W1 = np.random.randn(n_h,n_x)
        b1 = np.zeros(shape = (n_h,1))
        W2 = np.random.randn(n_y,n_h)
        b2 = np.zeros(shape = (n_y,1))
        params = {
            'W1' : W1,
            'W2' : W2,
            'b1' : b1,
            'b2' : b2        
        }
        return params
    def forward_propagation(X,params):
        """
        参数:
             X - 维度为(n_x,m)的输入数据。 m为样本个数
             params - 初始化函数(initialize_parameters)的输出
        返回:
             A2 - 使用sigmoid()函数计算的第二次激活后的数值
             cache - 包含“Z1”,“A1”,“Z2”和“A2”的字典类型变量
        """
        W1,W2 = params['W1'],params['W2']
        b1,b2 = params['b1'],params['b2']
        Z1 = np.dot(W1,X) + b1
        A1 = np.tanh(Z1)
        Z2 = np.dot(W2,A1) + b2
        A2 = sigmoid(Z2)
        cache = {
            'Z1' : Z1,
            'Z2' : Z2,
            'A1' : A1,
            'A2' : A2
        }
        return A2,cache
    def compute_cost(A2,Y):
        """
        计算方程中给出的交叉熵成本,
        参数:
             A2 - 使用sigmoid()函数计算的第二次激活后的数值
             Y - "True"标签向量,维度为(1,数量)
        返回:
             成本 - 交叉熵成本
        """
        m = Y.shape[1]
        cost = (-1/m) * np.sum(Y*np.log(A2) + (1-Y)*np.log(1-A2))
        return cost
    def backward_propagation(params,cache,X,Y):
        """
        使用上述说明搭建反向传播函数。
        参数:
         params - 包含我们的参数的一个字典类型的变量。
         cache - 包含“Z1”,“A1”,“Z2”和“A2”的字典类型的变量。
         X - 输入数据,维度为(2,数量)
         Y - “True”标签,维度为(1,数量)
        返回:
         grads - 包含W和b的导数一个字典类型的变量。
        """
        m = X.shape[1]
        W1,W2 = params['W1'],params['W2']
        b1,b2 = params['b1'],params['b2']
        Z1,Z2 = cache['Z1'],cache['Z2']
        A1,A2 = cache['A1'],cache['A2']
        dZ2 = A2 - Y
        dW2 = (1/m) * np.dot(dZ2,A1.T)
        db2 = (1/m) * np.sum(dZ2,axis=1,keepdims=True)
        dZ1 =  np.multiply(np.dot(W2.T,dZ2),1-np.power(A1,2))
        dW1 = (1/m) * np.dot(dZ1,X.T)
        db1 = (1/m) * np.sum(dZ1,axis=1,keepdims=True)
        grads = {
            'dW1' : dW1,
            'dW2' : dW2,
            'db1' : db1,
            'db2' : db2
        }
        return grads
    def optimizer(params,grads,l_rate = 1.2):
        """
        使用上面给出的梯度下降更新规则更新参数
        参数:
         params - 包含参数的字典类型的变量。
         grads - 包含导数值的字典类型的变量。
         learning_rate - 学习速率 
        返回:
         params - 包含更新参数的字典类型的变量。
        """
        W1,W2 = params['W1'],params['W2']
        b1,b2 = params['b1'],params['b2']
        dW1,dW2 = grads['dW1'],grads['dW2']
        db1,db2 = grads['db1'],grads['db2']
        W1 = W1 - l_rate * dW1
        W2 = W2 - l_rate * dW2
        b1 = b1 - l_rate * db1
        b2 = b2 - l_rate * db2
        params = {
            'W1' : W1,
            'W2' : W2,
            'b1' : b1,
            'b2' : b2
        }
        return params
    def model(X,Y,n_h,n_iters,learning_rate,print_cost = False):
        """
        参数:
            X - 数据集,维度为(2,示例数)
            Y - 标签,维度为(1,示例数)
            n_h - 隐藏层的数量
            num_iterations - 梯度下降循环中的迭代次数
            print_cost - 如果为True,则每1000次迭代打印一次成本数值
        返回:
            params - 模型学习的参数,它们可以用来进行预测。
        """
        n_x,n_h,n_y = layer_sizes(X,Y,n_h)
        params = init_w_b(n_x,n_h,n_y)
        for i in range(n_iters):
            A2,cache = forward_propagation(X,params)
            cost = compute_cost(A2,Y)
            grads = backward_propagation(params,cache,X,Y)
            params = optimizer(params,grads,l_rate=learning_rate)
            if print_cost:
                if i % 1000 == 0:
                    print('第',i,'次梯度下降迭代,cost=',str(cost))
        return params
    def predict(params,X):
        """
        使用学习的参数,为X中的每个示例预测一个类
        参数:
    		params - 包含参数的字典类型的变量。
    	    X - 输入数据(n_x,m)
        返回
    		Y_predict - 我们模型预测的向量(红色:0 /蓝色:1)
        """
        A2,cache = forward_propagation(X,params)
        Y_predict = np.round(A2)
        return Y_predict
    

    三、测试

    1、测试一

    测试数据在学习率为1.2,隐藏层结点个数为4,10000次梯度下降迭代后的准确率

    X,Y = load_planar_dataset()
    # print(Y)
    params = model(X,Y,4,10000,1.2,True)
    Y_predict = predict(params,X)
    # print(Y_predict)
    print('学习率为1.2,隐藏层结点个数为4经过10000次梯度下降迭代后,准确率为:',np.mean(Y_predict == Y)*100,'%')
    

    在这里插入图片描述

    2、测试二

    测试在学习率=1.2,梯度迭代次数=10000时,隐藏层结点个数 = [1,20],对应的准确率,并作出隐藏层结点-准确率曲线。

    X,Y = load_planar_dataset()
    hiden_size = np.arange(1,21) #这里可以修改隐藏层结点个数
    accs = []
    for i,h_n in enumerate(hiden_size):
        params = model(X,Y,h_n,10000,1.2,False)
        Y_predict = predict(params,X)
        acc = np.mean(Y_predict == Y)*100
        print('隐藏层结点个数为:',h_n,',准确率=',acc,'%')
        accs.append(acc)
    accs = np.array(accs)
    plt.plot(range(1,21),accs,color='red')
    plt.xticks(range(1,21))
    plt.title('Learning Rate=1.2,N_iters=10000')
    plt.xlabel('Hidden Layer Of Size')
    plt.ylabel('Accuracy')
    plt.show
    

    在这里插入图片描述
    可以看出,隐藏层结点=4时为最佳(>4的部分虽然也有更好的效果,但是提升并不大,但是模型复杂度太大,不划算)
    在这里插入图片描述

    3、测试三

    测试在隐藏层结点个数=4,梯度迭代次数=10000时,学习率 = [0.1,2.0],对应的准确率,并作出学习率-准确率曲线。

    #测试不同学习率下,模型准确率
    X,Y = load_planar_dataset()
    l_rates = np.linspace(0.1,2.0,num=20)
    accs = []
    for i,l_rate in enumerate(l_rates):
        params = model(X,Y,4,10000,l_rate,False)
        Y_predict = predict(params,X)
        acc = np.mean(Y_predict == Y)*100
        accs.append(acc)
        print('学习率=',l_rate,'正确率=',acc,'%')
    plt.plot(l_rates,accs,color='red')
    my_x_ticks = np.arange(0.1, 2.1, 0.1)
    plt.xticks(my_x_ticks)
    plt.xlabel('Learning Rate')
    plt.ylabel('Accuracy')
    plt.show
    

    在这里插入图片描述
    可以看出,当Learning Rate = 1.2时,模型最佳(Learing Rate = [0.7,1.2] 模型都可以达到最佳准确率,但是Learing Rate = 1.2迭代最快)

    在这里插入图片描述

    四、keras实现带有一个隐藏层的NN

    from keras.datasets import mnist
    from keras.models import Sequential
    from keras.layers import Dense
    from keras.utils import np_utils
    from keras.optimizers import SGD
    (x_train,y_train),(x_test,y_test) = mnist.load_data()
    x_train = x_train.reshape(x_train.shape[0],-1) / 255.0
    y_train = np_utils.to_categorical(y_train,num_classes=10)
    x_test = x_test.reshape(x_test.shape[0],-1) / 255.0
    y_test = np_utils.to_categorical(y_test,num_classes=10)
    model = Sequential()
    model.add(Dense(input_dim=784,units=100,activation='relu'))
    model.add(Dense(units=10,activation='sigmoid'))
    sgd = SGD(learning_rate=0.2)
    model.compile(optimizer=sgd,metrics=['accuracy'],loss='mse')
    model.fit(x_train,y_train,batch_size=32,epochs=10)
    loss,accuracy = model.evaluate(x_test,y_test)
    

    在这里插入图片描述

    五、planar_utils.py数据文件

    import matplotlib.pyplot as plt
    import numpy as np
    import sklearn
    import sklearn.datasets
    import sklearn.linear_model
    
    def plot_decision_boundary(model, X, y):
        # Set min and max values and give it some padding
        x_min, x_max = X[0, :].min() - 1, X[0, :].max() + 1
        y_min, y_max = X[1, :].min() - 1, X[1, :].max() + 1
        h = 0.01
        # Generate a grid of points with distance h between them
        xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
        # Predict the function value for the whole grid
        Z = model(np.c_[xx.ravel(), yy.ravel()])
        Z = Z.reshape(xx.shape)
        # Plot the contour and training examples
        plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
        plt.ylabel('x2')
        plt.xlabel('x1')
        plt.scatter(X[0, :], X[1, :], c=np.squeeze(y), cmap=plt.cm.Spectral)
    
    
    def sigmoid(x):
        s = 1/(1+np.exp(-x))
        return s
    
    def load_planar_dataset():
        np.random.seed(1)
        m = 400 # number of examples
        N = int(m/2) # number of points per class
        D = 2 # dimensionality
        X = np.zeros((m,D)) # data matrix where each row is a single example
        Y = np.zeros((m,1), dtype='uint8') # labels vector (0 for red, 1 for blue)
        a = 4 # maximum ray of the flower
    
        for j in range(2):
            ix = range(N*j,N*(j+1))
            t = np.linspace(j*3.12,(j+1)*3.12,N) + np.random.randn(N)*0.2 # theta
            r = a*np.sin(4*t) + np.random.randn(N)*0.2 # radius
            X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
            Y[ix] = j
    
        X = X.T
        Y = Y.T
    
        return X, Y
    
    def load_extra_datasets():  
        N = 200
        noisy_circles = sklearn.datasets.make_circles(n_samples=N, factor=.5, noise=.3)
        noisy_moons = sklearn.datasets.make_moons(n_samples=N, noise=.2)
        blobs = sklearn.datasets.make_blobs(n_samples=N, random_state=5, n_features=2, centers=6)
        gaussian_quantiles = sklearn.datasets.make_gaussian_quantiles(mean=None, cov=0.5, n_samples=N, n_features=2, n_classes=2, shuffle=True, random_state=None)
        no_structure = np.random.rand(N, 2), np.random.rand(N, 2)
    
        return noisy_circles, noisy_moons, blobs, gaussian_quantiles, no_structure
    
    
    展开全文
  • 该程序的功能是实现三层BP神经网络; 其中输入层有三个神经元,隐藏层有四个神经元...隐藏层节点的输入为layer1,输出为layer1_out 输出层节点的输入为layer2,输出为layer2_out import numpy as np import random impor

    该程序的功能是实现三层BP神经网络;
    其中输入层有三个神经元,隐藏层有四个神经元,输出层有三个神经元;
    程序的目的是随机生成一个(3,1)的矩阵,然后定义标签为(0,1,0),通过前向传导和反向传导,最终输出的结果接近标签值。
    生成的数据用X表示
    两层权重参数分别用W1,W2表示
    两层偏置参数分别用b1,b2表示
    隐藏层节点的输入为layer1,输出为layer1_out
    输出层节点的输入为layer2,输出为layer2_out

    import numpy as np
    import random
    import matplotlib.pyplot as plt
    
    ###生成数据
    X=np.random.randn(3,1)
    target=np.array([[0],
                     [1],
                     [0]])
    #生成权重参数
    W1=np.random.rand(4,3)
    b1=np.random.rand(4,1)
    W2=np.random.rand(3,4)
    b2=np.random.rand(3,1)
    
    
    def layer(W,data,b):
        out=np.dot(W,data)+b
        return out
    
    def sigmoid(x):
        s=1/(1+np.exp(-x))
        return s
    # def backsigmoid(y):
    #     s=1/(1+np.exp(-y))
    #     s=s*(1-s)
    #     return s
    #损失函数,均方误差
    def mean_squared_error(m,n):
        return 0.5*np.sum((m-n)**2)
    
    epoch1=[]
    
    if __name__ == "__main__":
         #学习率leaningrate
        loss1=[]
        leaningrate=0.1   
        epoch=0
        for i in range (100):
            #前向传到
            layer1=layer(W1,X,b1)
            layer1_out=sigmoid(layer1)
            layer2=layer(W2,layer1_out,b2)
            layer2_out=sigmoid(layer2)
            
            #计算损失函数
            loss=mean_squared_error(layer2_out,target)
            loss1.append(loss)
            epoch=epoch+1
            if i%10==0:
                print("损失函数loss=",loss)
                print("训练结果:",layer2_out)
            #反向传导
            pianW2=np.dot(np.dot(np.dot((layer2_out-target),layer2_out.T),(1-layer2_out)),layer1_out.T)
            #注意上一步和下一步的矩阵有些需要转置,需要计算一下矩阵的维度做出判断
            W2=W2-leaningrate*pianW2
            pianW1=np.dot((np.dot(np.dot(np.dot(np.dot(np.dot((layer2_out-target).T,layer2_out),(1-layer2_out).T),W2),layer1_out),(1-layer1_out).T)).T,X.T)
            W1=W1-leaningrate*pianW1
            
            
        plt.plot(loss1)
        plt.xlabel('Number of epochs')
        plt.ylabel('Training error')
        #最终的训练结果值是不固定的,因为每次训练都会生成新的输入和权重
    

    实验结果
    在这里插入图片描述

    附录给出了关于反向传导的推导链接 https://zhuanlan.zhihu.com/p/24801814
    下图是本程序的反向推导过程草稿,以备需要时复习
    在这里插入图片描述代码优化,主要的改变是定义了一个类

    import numpy as np
    import random
    import matplotlib.pyplot as plt
    
    
    class BP():
        def __init__(self,inputnum=5,hiddennum=6,outputnum=5,learning_rate=0.002):
            self.inputnum=inputnum
            self.hiddennum=hiddennum
            self.outputnum=outputnum
            self.learning_rate=learning_rate
        def generatedata(self):
            X=np.random.randn(self.inputnum,1)
            W1=np.random.rand(self.hiddennum,self.inputnum)
            b1=np.random.rand(self.hiddennum,1)
            W2=np.random.rand(self.outputnum,self.hiddennum)
            b2=np.random.rand(self.outputnum,1)
            target=np.array([[1],[0],[1],[1],[0]])
            return X,W1,b1,W2,b2,target
        def layer(self,W,data,b):
            out=np.dot(W,data)+b
            return out
        
        def sigmoid(self,x):
            s=1/(1+np.exp(-x))
            return s
        
        def mean_squared_error(self,m,n):
            return 0.5*np.sum((m-n)**2)
        
        def train(self):
            X,W1,b1,W2,b2,target=self.generatedata()
            loss1=[]
            epoch=0
            for i in range (2000):
            #前向传到
                layer1=self.layer(W1,X,b1)
                layer1_out=self.sigmoid(layer1)
                layer2=self.layer(W2,layer1_out,b2)
                layer2_out=self.sigmoid(layer2)
                
                #计算损失函数
                loss=self.mean_squared_error(layer2_out,target)
                loss1.append(loss)
                epoch=epoch+1
                if i%10==0:
                    print("损失函数loss=",loss)
                    print("训练结果:",layer2_out)
                #反向传导
                pianW2=np.dot(np.dot(np.dot((layer2_out-target),layer2_out.T),(1-layer2_out)),layer1_out.T)
                #注意上一步和下一步的矩阵有些需要转置,需要计算一下矩阵的维度做出判断
                W2=W2-self.learning_rate*pianW2
                pianW1=np.dot((np.dot(np.dot(np.dot(np.dot(np.dot((layer2_out-target).T,layer2_out),(1-layer2_out).T),W2),layer1_out),(1-layer1_out).T)).T,X.T)
                W1=W1-self.learning_rate*pianW1
            
            return loss1
    
    if __name__ == "__main__":
        bp=BP()
        bp.train()
        loss1=bp.train()
        plt.plot(loss1)
        plt.xlabel('epochs')
        plt.ylabel('loss')
        
        
        
    
    展开全文
  • layui+ ueiditor问题

    2019-08-09 17:52:50
    所以,引入之后,把标签改成了div包裹,但是相应的问题也出现了,不能动态的渲染,所以一进入页面,把盒子隐藏掉,之后再调用layer.open方法; 2 问题是在编辑的时候,ueiditor编辑器,一直赋值不上; 百度查了很久...
  • 关于Krpano实现全景按钮的简单动画

    千次阅读 2017-07-25 15:31:40
    关于Krpano实现全景按钮的简单动画本文讲述一个简单的按钮控制图片的显示隐藏:代码如下在你的皮肤 XML 文件里插入layer标签: <layer name="skin_logo" zorder="15" keep="true" url="2.png" align="lefttop" x=...
  • 实现一个随鼠标移动的光点,光点指到特定物体上会显示,否则隐藏 ①使用tag ②使用Layer 方法①  用target标签标记场景物体 创建一个Image UI 在相机上添加下列脚本 using System.Collections; ...
  • layui的table组件中,动态输出html或者xml会隐藏标签信息,如果需要原样显示,则需要对数据进行转义操作 解决方案: 1.引入util组件 layui.use(['form','layer','table','util'],function(){ var form = layui...
  • 内容的动态管理

    2017-08-30 17:00:03
    在首jsp页面上可以设置一个(a标签)之类的链接,点击...layer_show('自定义菜单', '${ctx}/test/addCustomMenu', '400', '300'); 然后经过返回一个路径,显示预先编辑的jsp页面,jsp页面菜单相隐藏<form action="" metho
  • params_dict可以根据自己的需要定制,任务量n_tasks,相当于标签数量,features特征数量,定制layer_sizes,比如官方定制了三个隐藏层,宽度为500的单层,宽度为1000的单层,宽度为1000的两层,dropouts(按照一定的...
  • 使得网络的输入层、隐藏层、输入层的数据直方图都在一个指定的范围内,有利于模型的收敛,有时候为了方便输出结果更好的逼近真实结果,还会对 标签数据进行相应的标准化处理 3、 标准化方法 1)、batch norm
  • 视图v0.6版中的功能:* * *新的侧边栏布局* * * * * * Tealium DataLayer支持* * *(页面视图和事件单击)新的过滤器功能–隐藏列表中不带参数的请求–隐藏特定URL –隐藏来自同一域的所有请求功能-具有下拉功能的...
  • 五、特别感谢我们借助了开源的力量,才得以快速构建出酱茄Free主题,在此特别感谢他们(排名不分先后):WordPress、JQuery、Layer.js、Codestar Framework、Font Awesome以及其他未标记的开源及创意… wordpress
  • dreamweaver的各种组件

    2008-06-26 16:55:56
    BoxIn Layer隐藏转场效果之一 ResizeImage 改变图形的大小 OpenControlWindow 开启控制视窗, 就是在新开启的视窗可以把target指向原本的視窗. Change Link 改变文字或图片连结的內容 Objects 名称 简介 ...
  •  1.3.2 文件开始标签<html> 7  1.3.3 文件头部标签<head> 7  1.3.4 文件标题标签<title> 7  1.3.5 文件主体标签<body> 7  1.3.6 编写文件的注意事项 8  1.4 编写第一个HTML文件 8  ...
  • android群雄传

    2016-08-13 16:02:16
    7.6.1 标签 175 7.6.2 SVG常用指令 176 7.6.3 SVG编辑器 177 7.6.4 Android中使用SVG 177 7.6.5 SVG动画实例 181 7.7 Android动画特效 188 7.7.1 灵动菜单 188 7.7.2 计时器动画 190 7.7.3 下拉展开动画 191...
  • AutoLISP学习导引.pdf

    2015-07-18 22:45:17
    暂时隐藏对话框 381 多层次对话框界面 383 重点复习 386 进阶挑战 386 autolisp函数分类摘要 387 基本函数 387 应用程序处理 387 算数 388 条件 388 错误处理 389 函数处理 389 序列处理 390 字符串处理 391 符号...
  • print('idex1 魔数:{},标签数:{}'.format(magic_number, label_num)) offset += struct.calcsize(fmt_header) labels = np.empty(shape=[0,10],dtype=float) #神经网络需要把label变成10位float的数组 ...
  • 一、script标签引入方式(需下载本项目文件夹css/pdfh5.css、js内所有文件) 1.引入css <link rel="stylesheet" href="css/pdfh5.css" /> 2.创建div <div id="demo"></div> 3.依次引入js(需...
  • 转来备用,以后慢慢学

    2010-05-21 14:14:33
     (2)按Ctrl+J产生一个浮动 Layer;¬  (3)按旋转并移动到适当位置后确认;¬  (4)现在可以按住Ctrl+Alt+Shift 后连续按“T”就可以有规律地复制出连续的物体。(只按住Ctrl+Shift则只是有规律移动)¬  27. 当我们...
  • 识别常见病毒,病毒一般是以隐藏形式藏匿在计算机的文件中,要把文件的隐藏属性打开。每一盘都有工具这个选项,如下图所示: 49 五.常用DOS命令 60 第一章COMS的设置 开机画面现在有两种,一种为AMI公司开发的,...
  • 3.2.16 <layer>─按层次编排文本 152 3.2.17 ─处理不支持层次 的浏览器 154 3.2.18 ─建立内嵌层次 155 3.2.19 使用确定文本位置 157 3.2.20 、、、、、 ─建立加说明的文本 158 第4章 图像 163 4.1 概述 163 4.1.1...

空空如也

空空如也

1 2
收藏数 28
精华内容 11
关键字:

layer隐藏标签