神经网络反向传播算法在Python中不起作用

2023-12-24

我正在用 Python 编写一个神经网络，遵循示例here http://page.mi.fu-berlin.de/rojas/neural/chapter/K7.pdf。考虑到神经网络在训练一万次后未能产生正确的值（在误差范围内），反向传播算法似乎不起作用。具体来说，我正在训练它来计算以下示例中的正弦函数：

import numpy as np

class Neuralnet:
    def __init__(self, neurons):
        self.weights = []
        self.inputs = []
        self.outputs = []
        self.errors = []
        self.rate = .1
        for layer in range(len(neurons)):
            self.inputs.append(np.empty(neurons[layer]))
            self.outputs.append(np.empty(neurons[layer]))
            self.errors.append(np.empty(neurons[layer]))
        for layer in range(len(neurons)-1):
            self.weights.append(
                np.random.normal(
                    scale=1/np.sqrt(neurons[layer]), 
                    size=[neurons[layer], neurons[layer + 1]]
                    )
                )

    def feedforward(self, inputs):
        self.inputs[0] = inputs
        for layer in range(len(self.weights)):
            self.outputs[layer] = np.tanh(self.inputs[layer])
            self.inputs[layer + 1] = np.dot(self.weights[layer].T, self.outputs[layer])
        self.outputs[-1] = np.tanh(self.inputs[-1])

    def backpropagate(self, targets):
        gradient = 1 - self.outputs[-1] * self.outputs[-1]
        self.errors[-1] = gradient * (self.outputs[-1] - targets)
        for layer in reversed(range(len(self.errors) - 1)):
            gradient = 1 - self.outputs[layer] * self.outputs[layer]
            self.errors[layer] = gradient * np.dot(self.weights[layer], self.errors[layer + 1])
        for layer in range(len(self.weights)):
            self.weights[layer] -= self.rate * np.outer(self.outputs[layer], self.errors[layer + 1])

def xor_example():
    net = Neuralnet([2, 2, 1])
    for step in range(100000):
        net.feedforward([0, 0])
        net.backpropagate([-1])
        net.feedforward([0, 1])
        net.backpropagate([1])
        net.feedforward([1, 0])
        net.backpropagate([1])
        net.feedforward([1, 1])
        net.backpropagate([-1])
    net.feedforward([1, 1])
    print(net.outputs[-1])

def identity_example():
    net = Neuralnet([1, 3, 1])
    for step in range(100000):
        x = np.random.normal()
        net.feedforward([x])
        net.backpropagate([np.tanh(x)])
    net.feedforward([-2])
    print(net.outputs[-1])

def sine_example():
    net = Neuralnet([1, 6, 1])
    for step in range(100000):
        x = np.random.normal()
        net.feedforward([x])
        net.backpropagate([np.tanh(np.sin(x))])
    net.feedforward([3])
    print(net.outputs[-1])

sine_example()

输出未能接近tanh(sin(3)) = 0.140190616。我怀疑涉及错误索引或对齐的错误，但 Numpy 没有引发任何此类错误。关于我哪里出错了有什么提示吗？

EDIT:我忘记添加偏置神经元。这是更新后的代码：

import numpy as np

class Neuralnet:
    def __init__(self, neurons):
        self.weights = []
        self.outputs = []
        self.inputs = []
        self.errors = []
        self.offsets = []
        self.rate = .01
        for layer in range(len(neurons)-1):
            self.weights.append(
                np.random.normal(
                    scale=1/np.sqrt(neurons[layer]), 
                    size=[neurons[layer], neurons[layer + 1]]
                    )
                )
            self.outputs.append(np.empty(neurons[layer]))
            self.inputs.append(np.empty(neurons[layer]))
            self.errors.append(np.empty(neurons[layer]))
            self.offsets.append(np.random.normal(scale=1/np.sqrt(neurons[layer]), size=neurons[layer + 1]))
        self.inputs.append(np.empty(neurons[-1]))
        self.errors.append(np.empty(neurons[-1]))

    def feedforward(self, inputs):
        self.inputs[0] = inputs
        for layer in range(len(self.weights)):
            self.outputs[layer] = np.tanh(self.inputs[layer])
            self.inputs[layer + 1] = self.offsets[layer] + np.dot(self.weights[layer].T, self.outputs[layer])

    def backpropagate(self, targets):
        self.errors[-1] = self.inputs[-1] - targets
        for layer in reversed(range(len(self.errors) - 1)):
            gradient = 1 - self.outputs[layer] * self.outputs[layer]
            self.errors[layer] = gradient * np.dot(self.weights[layer], self.errors[layer + 1])
        for layer in range(len(self.weights)):
            self.weights[layer] -= self.rate * np.outer(self.outputs[layer], self.errors[layer + 1])
            self.offsets[layer] -= self.rate * self.errors[layer + 1]

def sine_example():
    net = Neuralnet([1, 5, 1])
    for step in range(10000):
        x = np.random.uniform(-5, 5)
        net.feedforward([x])
        net.backpropagate([np.sin(x)])
    net.feedforward([np.pi])
    print(net.inputs[-1])

def xor_example():
    net = Neuralnet([2, 2, 1])
    for step in range(10000):
        net.feedforward([0, 0])
        net.backpropagate([-1])
        net.feedforward([0, 1])
        net.backpropagate([1])
        net.feedforward([1, 0])
        net.backpropagate([1])
        net.feedforward([1, 1])
        net.backpropagate([-1])
    net.feedforward([1, 1])
    print(net.outputs[-1])

def identity_example():
    net = Neuralnet([1, 3, 1])
    for step in range(10000):
        x = np.random.normal()
        net.feedforward([x])
        net.backpropagate([x])
    net.feedforward([-2])
    print(net.outputs[-1])

identity_example()

我认为你训练神经网络的方式是错误的。您有一个超过 10000 次迭代的循环，并在每个循环中提供一个新样本。在这种情况下，神经网络永远不会接受训练。

（说法有误！请查看更新！）

你需要做的是生成大量真实样本Y = sin(X)，将其提供给您的网络ONCE并向前和向后迭代训练集，以最小化成本函数。要检查算法，您可能需要根据迭代次数绘制成本函数，并确保成本下降。

另一个重要的点是权重的初始化。您的数量非常大，网络将需要很长时间才能收敛，尤其是在使用低速率时。在一些小范围内生成初始权重是一个很好的做法[-eps .. eps]均匀地。

在我的代码中，我实现了两个不同的激活函数：sigmoid() and tanh()。您需要根据所选函数缩放输入：[0 .. 1] and [-1 .. 1]分别。

以下是一些显示成本函数和结果预测的图像sigmoid() and tanh()激活函数：

正如你所看到的sigmoid()激活比激活给出了更好的结果tanh().

当使用网络时我也得到了更好的预测[1, 6, 1]，与具有 4 层的更大网络相比[1, 6, 4, 1]。因此神经网络的大小并不总是关键因素。以下是对上述 4 层网络的预测：

这是我的代码和一些评论。我尝试在可能的情况下使用您的符号。

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

class Neuralnet:
    def __init__(self, neurons, activation):
        self.weights = []
        self.inputs = []
        self.outputs = []
        self.errors = []
        self.rate = 0.5
        self.activation = activation    #sigmoid or tanh

        self.neurons = neurons
        self.L = len(self.neurons)      #number of layers

        eps = 0.12;    # range for uniform distribution   -eps..+eps              
        for layer in range(len(neurons)-1):
            self.weights.append(np.random.uniform(-eps,eps,size=(neurons[layer+1], neurons[layer]+1)))            


    ###################################################################################################    
    def train(self, X, Y, iter_count):

        m = X.shape[0];

        for layer in range(self.L):
            self.inputs.append(np.empty([m, self.neurons[layer]]))        
            self.errors.append(np.empty([m, self.neurons[layer]]))

            if (layer < self.L -1):
                self.outputs.append(np.empty([m, self.neurons[layer]+1]))
            else:
                self.outputs.append(np.empty([m, self.neurons[layer]]))

        #accumulate the cost function
        J_history = np.zeros([iter_count, 1])


        for i in range(iter_count):

            self.feedforward(X)

            J = self.cost(Y, self.outputs[self.L-1])
            J_history[i, 0] = J

            self.backpropagate(Y)


        #plot the cost function to check the descent
        plt.plot(J_history)
        plt.show()


    ###################################################################################################    
    def cost(self, Y, H):     
        J = np.sum(np.sum(np.power((Y - H), 2), axis=0))/(2*m)
        return J

    ###################################################################################################
    def feedforward(self, X):

        m = X.shape[0];

        self.outputs[0] = np.concatenate(  (np.ones([m, 1]),   X),   axis=1)

        for i in range(1, self.L):
            self.inputs[i] = np.dot( self.outputs[i-1], self.weights[i-1].T  )

            if (self.activation == 'sigmoid'):
                output_temp = self.sigmoid(self.inputs[i])
            elif (self.activation == 'tanh'):
                output_temp = np.tanh(self.inputs[i])


            if (i < self.L - 1):
                self.outputs[i] = np.concatenate(  (np.ones([m, 1]),   output_temp),   axis=1)
            else:
                self.outputs[i] = output_temp

    ###################################################################################################
    def backpropagate(self, Y):

        self.errors[self.L-1] = self.outputs[self.L-1] - Y

        for i in range(self.L - 2, 0, -1):

            if (self.activation == 'sigmoid'):
                self.errors[i] = np.dot(  self.errors[i+1],   self.weights[i][:, 1:]  ) *  self.sigmoid_prime(self.inputs[i])
            elif (self.activation == 'tanh'):
                self.errors[i] = np.dot(  self.errors[i+1],   self.weights[i][:, 1:]  ) *  (1 - self.outputs[i][:, 1:]*self.outputs[i][:, 1:])

        for i in range(0, self.L-1):
            grad = np.dot(self.errors[i+1].T, self.outputs[i]) / m
            self.weights[i] = self.weights[i] - self.rate*grad

    ###################################################################################################
    def sigmoid(self, z):
        s = 1.0/(1.0 + np.exp(-z))
        return s

    ###################################################################################################
    def sigmoid_prime(self, z):
        s = self.sigmoid(z)*(1 - self.sigmoid(z))
        return s    

    ###################################################################################################
    def predict(self, X, weights):

        m = X.shape[0];

        self.inputs = []
        self.outputs = []
        self.weights = weights

        for layer in range(self.L):
            self.inputs.append(np.empty([m, self.neurons[layer]]))        

            if (layer < self.L -1):
                self.outputs.append(np.empty([m, self.neurons[layer]+1]))
            else:
                self.outputs.append(np.empty([m, self.neurons[layer]]))

        self.feedforward(X)

        return self.outputs[self.L-1]


###################################################################################################
#                MAIN PART

activation1 = 'sigmoid'     # the input should be scaled into [ 0..1]
activation2 = 'tanh'        # the input should be scaled into [-1..1]

activation = activation1

net = Neuralnet([1, 6, 1], activation) # structure of the NN and its activation function


##########################################################################################
#                TRAINING

m = 1000 #size of the training set
X = np.linspace(0, 4*math.pi, num = m).reshape(m, 1); # input training set


Y = np.sin(X) # target

kx = 0.1 # noise parameter
noise = (2.0*np.random.uniform(0, kx, m) - kx).reshape(m, 1)
Y = Y + noise # noisy target

# scaling of the target depending on the activation function
if (activation == 'sigmoid'):
    Y_scaled = (Y/(1+kx) + 1)/2.0
elif (activation == 'tanh'):
    Y_scaled = Y/(1+kx)


# number of the iteration for the training stage
iter_count = 20000
net.train(X, Y_scaled, iter_count) #training

# gained weights
trained_weights = net.weights

##########################################################################################
#                 PREDICTION

m_new = 40 #size of the prediction set
X_new = np.linspace(0, 4*math.pi, num = m_new).reshape(m_new, 1);

Y_new = net.predict(X_new, trained_weights) # prediction

#rescaling of the result 
if (activation == 'sigmoid'):
    Y_new = (2.0*Y_new - 1.0) * (1+kx)
elif (activation == 'tanh'):
    Y_new = Y_new * (1+kx)

# visualization
plt.plot(X, Y)
plt.plot(X_new, Y_new, 'ro')
plt.show()

raw_input('press any key to exit')

UPDATE

我想收回有关您代码中使用的训练方法的声明。该网络确实可以在每次迭代中仅使用一个样本进行训练。我在使用 sigmoid 和 tanh 激活函数的在线训练中得到了有趣的结果：

使用 Sigmoid 进行在线训练（成本函数和预测）

使用 Tanh 进行在线训练（成本函数和预测）

可以看出，选择 Sigmoid 作为激活函数具有更好的性能。成本函数看起来不如离线训练期间那么好，但至少它趋于下降。

我在你的实现中绘制了成本函数，它看起来也很不稳定：

使用 sigmoid 甚至 ReLU 函数尝试代码可能是个好主意。

这是更新后的源代码。之间切换online and offline训练模式只是改变method多变的。

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

class Neuralnet:
    def __init__(self, neurons, activation):
        self.weights = []
        self.inputs = []
        self.outputs = []
        self.errors = []
        self.rate = 0.2
        self.activation = activation    #sigmoid or tanh

        self.neurons = neurons
        self.L = len(self.neurons)      #number of layers

        eps = 0.12;    #range for uniform distribution   -eps..+eps              
        for layer in range(len(neurons)-1):
            self.weights.append(np.random.uniform(-eps,eps,size=(neurons[layer+1], neurons[layer]+1)))            


    ###################################################################################################    
    def train(self, X, Y, iter_count):

        m = X.shape[0];

        for layer in range(self.L):
            self.inputs.append(np.empty([m, self.neurons[layer]]))        
            self.errors.append(np.empty([m, self.neurons[layer]]))

            if (layer < self.L -1):
                self.outputs.append(np.empty([m, self.neurons[layer]+1]))
            else:
                self.outputs.append(np.empty([m, self.neurons[layer]]))

        #accumulate the cost function
        J_history = np.zeros([iter_count, 1])


        for i in range(iter_count):

            self.feedforward(X)

            J = self.cost(Y, self.outputs[self.L-1])
            J_history[i, 0] = J

            self.backpropagate(Y)


        #plot the cost function to check the descent
        #plt.plot(J_history)
        #plt.show()


    ###################################################################################################    
    def cost(self, Y, H):     
        J = np.sum(np.sum(np.power((Y - H), 2), axis=0))/(2*m)
        return J


    ###################################################################################################
    def cost_online(self, min_x, max_x, iter_number):
        h_arr = np.zeros([iter_number, 1])
        y_arr = np.zeros([iter_number, 1])

        for step in range(iter_number):
            x = np.random.uniform(min_x, max_x, 1).reshape(1, 1)

            self.feedforward(x)
            h_arr[step, 0] = self.outputs[-1]
            y_arr[step, 0] = np.sin(x)



        J = np.sum(np.sum(np.power((y_arr - h_arr), 2), axis=0))/(2*iter_number)
        return J

    ###################################################################################################
    def feedforward(self, X):

        m = X.shape[0];

        self.outputs[0] = np.concatenate(  (np.ones([m, 1]),   X),   axis=1)

        for i in range(1, self.L):
            self.inputs[i] = np.dot( self.outputs[i-1], self.weights[i-1].T  )

            if (self.activation == 'sigmoid'):
                output_temp = self.sigmoid(self.inputs[i])
            elif (self.activation == 'tanh'):
                output_temp = np.tanh(self.inputs[i])


            if (i < self.L - 1):
                self.outputs[i] = np.concatenate(  (np.ones([m, 1]),   output_temp),   axis=1)
            else:
                self.outputs[i] = output_temp

    ###################################################################################################
    def backpropagate(self, Y):

        self.errors[self.L-1] = self.outputs[self.L-1] - Y

        for i in range(self.L - 2, 0, -1):

            if (self.activation == 'sigmoid'):
                self.errors[i] = np.dot(  self.errors[i+1],   self.weights[i][:, 1:]  ) *  self.sigmoid_prime(self.inputs[i])
            elif (self.activation == 'tanh'):
                self.errors[i] = np.dot(  self.errors[i+1],   self.weights[i][:, 1:]  ) *  (1 - self.outputs[i][:, 1:]*self.outputs[i][:, 1:])

        for i in range(0, self.L-1):
            grad = np.dot(self.errors[i+1].T, self.outputs[i]) / m
            self.weights[i] = self.weights[i] - self.rate*grad


    ###################################################################################################
    def sigmoid(self, z):
        s = 1.0/(1.0 + np.exp(-z))
        return s

    ###################################################################################################
    def sigmoid_prime(self, z):
        s = self.sigmoid(z)*(1 - self.sigmoid(z))
        return s    

    ###################################################################################################
    def predict(self, X, weights):

        m = X.shape[0];

        self.inputs = []
        self.outputs = []
        self.weights = weights

        for layer in range(self.L):
            self.inputs.append(np.empty([m, self.neurons[layer]]))        

            if (layer < self.L -1):
                self.outputs.append(np.empty([m, self.neurons[layer]+1]))
            else:
                self.outputs.append(np.empty([m, self.neurons[layer]]))

        self.feedforward(X)

        return self.outputs[self.L-1]


###################################################################################################
#                MAIN PART

activation1 = 'sigmoid'     #the input should be scaled into [0..1]
activation2 = 'tanh'        #the input should be scaled into [-1..1]

activation = activation1

net = Neuralnet([1, 6, 1], activation) # structure of the NN and its activation function


method1 = 'online'
method2 = 'offline'

method = method1

kx = 0.1 #noise parameter

###################################################################################################
#                TRAINING

if (method == 'offline'):

    m = 1000 #size of the training set
    X = np.linspace(0, 4*math.pi, num = m).reshape(m, 1); #input training set


    Y = np.sin(X) #target


    noise = (2.0*np.random.uniform(0, kx, m) - kx).reshape(m, 1)
    Y = Y + noise #noisy target

    #scaling of the target depending on the activation function
    if (activation == 'sigmoid'):
        Y_scaled = (Y/(1+kx) + 1)/2.0
    elif (activation == 'tanh'):
        Y_scaled = Y/(1+kx)


    #number of the iteration for the training stage
    iter_count = 20000
    net.train(X, Y_scaled, iter_count) #training

elif (method == 'online'):

    sampling_count = 100000 # number of samplings during the training stage


    m = 1 #batch size

    iter_count = sampling_count/m

    for layer in range(net.L):
        net.inputs.append(np.empty([m, net.neurons[layer]]))        
        net.errors.append(np.empty([m, net.neurons[layer]]))

        if (layer < net.L -1):
            net.outputs.append(np.empty([m, net.neurons[layer]+1]))
        else:
            net.outputs.append(np.empty([m, net.neurons[layer]]))    

    J_history = []
    step_history = []

    for i in range(iter_count):
        X = np.random.uniform(0, 4*math.pi, m).reshape(m, 1)

        Y = np.sin(X) #target
        noise = (2.0*np.random.uniform(0, kx, m) - kx).reshape(m, 1)
        Y = Y + noise #noisy target

        #scaling of the target depending on the activation function
        if (activation == 'sigmoid'):
            Y_scaled = (Y/(1+kx) + 1)/2.0
        elif (activation == 'tanh'):
            Y_scaled = Y/(1+kx)

        net.feedforward(X)
        net.backpropagate(Y_scaled)


        if (np.remainder(i, 1000) == 0):
            J = net.cost_online(0, 4*math.pi, 1000)
            J_history.append(J)
            step_history.append(i)

    plt.plot(step_history, J_history)
    plt.title('Batch size ' + str(m) + ', rate ' + str(net.rate) + ', samples ' + str(sampling_count))
    #plt.ylim([0, 0.1])

    plt.show()

#gained weights
trained_weights = net.weights

##########################################################################################
#                 PREDICTION

m_new = 40 #size of the prediction set
X_new = np.linspace(0, 4*math.pi, num = m_new).reshape(m_new, 1);

Y_new = net.predict(X_new, trained_weights) #prediction

#rescaling of the result 
if (activation == 'sigmoid'):
    Y_new = (2.0*Y_new - 1.0) * (1+kx)
elif (activation == 'tanh'):
    Y_new = Y_new * (1+kx)

#visualization

#fake sine curve to show the ideal signal
if (method == 'online'):
    X = np.linspace(0, 4*math.pi, num = 100)
    Y = np.sin(X)

plt.plot(X, Y)

plt.plot(X_new, Y_new, 'ro')
if (method == 'online'):
    plt.title('Batch size ' + str(m) + ', rate ' + str(net.rate) + ', samples ' + str(sampling_count))
plt.ylim([-1.5, 1.5])
plt.show()

raw_input('press any key to exit')

现在我对您当前的代码有一些评论：

您的正弦函数如下所示：

def sine_example():
    net = Neuralnet([1, 6, 1])
    for step in range(100000):
        x = np.random.normal()
        net.feedforward([x])
        net.backpropagate([np.tanh(np.sin(x))])
    net.feedforward([3])
    print(net.outputs[-1])

我不知道你为什么在目标输入中使用 tanh 。如果您确实想使用正弦正切作为目标，则需要将其缩放为[-1..1]，因为 tanh(sin(x)) 返回范围内的值[-0.76..0.76].

接下来是训练集的范围。你用x = np.random.normal()生成样本。以下是此类输入的分布：

之后你希望你的网络预测正弦3，但网络在训练阶段几乎从未见过这个数字。我会在更广泛的范围内使用均匀分布来生成样本。

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

神经网络反向传播算法在Python中不起作用的相关文章

InterfaceError：连接已关闭（使用 django + celery + Scrapy）

当我在 Celery 任务中使用 Scrapy 解析函数有时可能需要 10 分钟时我得到了这个信息我用姜戈 1 6 5 django celery 3 1 16 芹菜 3 1 16 psycopg2 2 5 5 我也使用了psyc
将字符串转换为带有毫秒和时区的日期时间 - Python

我有以下 python 片段 from datetime import datetime timestamp 05 Jan 2015 17 47 59 000 0800 datetime object datetime strptime t
使用 openCV 对图像中的子图像进行通用检测

免责声明我是计算机视觉菜鸟我看过很多关于如何在较大图像中查找特定子图像的堆栈溢出帖子我的用例有点不同因为我不希望它是具体的而且我不确定如何做到这一点如果可能的话但我感觉应该如此我有大量图像数据集有时其中一些图像是数据集的
如何使用固定的 pandas 数据框进行动态 matplotlib 绘图？

我有一个名为的数据框benchmark returns and strategy returns 两者具有相同的时间跨度我想找到一种方法以漂亮的动画风格绘制数据点以便它显示逐渐加载的所有点我知道有一个matplotlib animat
Pycharm Python 控制台不打印输出

我有一个从 Pycharm python 控制台调用的函数但没有显示输出 In 2 def problem1 6 for i in range 1 101 2 print i end In 3 problem1 6 In 4 另一方面像
Flask 和 uWSGI - 无法加载应用程序 0 (mountpoint='')（找不到可调用或导入错误）

当我尝试使用 uWSGI 启动 Flask 时出现以下错误我是这样开始的 gt cd gt root localhost uwsgi socket 127 0 0 1 6000 file path to folder run py ca
Spark的distinct()函数是否仅对每个分区中的不同元组进行洗牌

据我了解 distinct 哈希分区 RDD 来识别唯一键但它是否针对仅移动每个分区的不同元组进行了优化想象一个具有以下分区的 RDD 1 2 2 1 4 2 2 1 3 3 5 4 5 5 5 在此 RDD 上的不同键上所有重复键
朴素贝叶斯分类器仅基于先验概率做出决策

我试图根据推文的情绪将推文分为三类买入持有卖出我正在使用 R 和包 e1071 我有两个数据框一个训练集和一组需要预测情绪的新推文训练集数据框 text sentiment this stock is a good buy Bu
如何使用装饰器禁用某些功能的中间件？

我想模仿的行为csrf exempt see here https docs djangoproject com en 1 11 ref csrf django views decorators csrf csrf exempt and h
从列表中的数据框列中搜索部分字符串匹配 - Pandas - Python

我有一个清单 things A1 B2 C3 我有一个 pandas 数据框其中有一列包含用分号分隔的值某些行将包含与上面列表中的一项的匹配它不会是完美的匹配因为它在其中包含字符串的其他部分该列例如该列中的一行可能有哇这里
Python：字符串不会转换为浮点数[重复]

这个问题在这里已经有答案了我几个小时前写了这个程序 while True print What would you like me to double line raw input gt if line done break else f
Python - 按月对日期进行分组

这是一个简单的问题起初我认为很简单而忽略了它一个小时过去了我不太确定所以我有一个Python列表datetime对象我想用图表来表示它们 x 值是年份和月份 y 值是此列表中本月发生的日期对象的数量也许一个例子可以更好地证明这
从 pygame 获取 numpy 数组

我想通过 python 访问我的网络摄像头不幸的是由于网络摄像头的原因 openCV 无法工作 Pygame camera 使用以下代码就像魅力一样 from pygame import camera display camera in
Nuitka 未使用 nuitka --recurse-all hello.py [错误] 编译 exe

我正在尝试通过 nuitka 创建一个简单的 exe 这样我就可以在我的笔记本电脑上运行它而无需安装 Python 我在 Windows 10 上并使用 Anaconda Python 3 我输入 nuitka recurse all h
Python：计算字典的重复值

我有一本字典如下 dictA unit1 test1 alpha unit1 test2 beta unit2 test1 alpha unit2 test2 gamma unit3 test1 delta unit3 test2 gamm
检查所有值是否作为字典中的键存在

我有一个值列表和一本字典我想确保列表中的每个值都作为字典中的键存在目前我正在使用两组来确定字典中是否存在任何值 unmapped set foo set bar keys 有没有更Pythonic的方法来测试这个感觉有点像黑客您的方
如何从没有结尾的管道中读取 python 中的 stdin

当管道来自打开时不知道正确的名称我无法从 python 中的标准输入或管道读取数据文件我有作为例子管道测试 py import sys import time k 0 try for line in sys stdin k k
协方差矩阵的对角元素不是 1 pandas/numpy

我有以下数据框 A B 0 1 5 1 2 6 2 3 7 3 4 8 我想计算协方差 a df iloc 0 values b df iloc 1 values 使用 numpy 作为 cov numpy cov a b I get ar
Python：元类属性有时会覆盖类属性？

下面代码的结果让我感到困惑 class MyClass type property def a self return 1 class MyObject object metaclass MyClass a 2 print MyObject
Pandas 与 Numpy 数据帧

看这几行代码 df2 df copy df2 1 df 1 df 1 values 1 df2 ix 0 0 我们的教练说我们需要使用 values属性来访问底层的 numpy 数组否则我们的代码将无法工作我知道 pandas Data

随机推荐

没有模块命名常量

我想用 Tastypie 框架做示例应用程序我将 Tastypie 添加到已安装的应用程序并进行了修改urls py根据需要添加from tastypie api import Api 但当我打开http localhost 8000
iPhone 应用程序中出现奇怪的不需要的动画

我不想发布这个但我在我正在开发的 iPhone 应用程序中看到了不需要的动画我以前从未在我的应用程序或任何其他应用程序中见过这种情况此应用程序仅适用于 iOS 4 2 和 iPhone 即使在 iPhone4 上也会发生这种奇怪的情况
元组函数的 N 元版本

是否有一个库具有 n 元版本的元组函数例如first 等通过 Template Haskell 或使用其他方法理想情况下我想说 select 3 0 1 我们用它来表示 lambda x y z gt x y 对于一个通用的对于功能
如何在 Internet Explorer 中的全高表格中制作全高单元格

我有下一个html代码 table style width 100 height 100 tr td td tr table
我如何教 ProGuard 删除它保留但我不使用的东西？

我有一个 Android 项目proguard rules pro文件为app模块仅包含以下内容 ProGuard rules dontobfuscate dontwarn android arch util paging CountedD
获取特定格式日期的唯一 ID？

我有可以生成随机唯一 ID 的代码但是有没有办法可以编辑此代码以便它以特定方式如 yyyy mm dd 0001 获取日期我希望每次单击generateid按钮时最后4位数字加1 所以它将更改为 0002 这是我当前的代码有没有可
如何在 Java 中识别/处理文本文件换行符？

我从不同的系统获取不同格式的文件我需要将它们导入到我们的数据库中导入过程的一部分是检查行长度以确保格式正确我们似乎在处理来自添加了一个字符的 UNIX 系统的文件时遇到了问题我怀疑这是由于 UNIX 和 Windows 平台上的回车
Airflow：如何删除 DAG？

我已经启动了 Airflow 网络服务器并安排了一些 dags 我可以在 Web GUI 上看到这些 dags 如何删除正在运行并在 Web GUI 中显示的特定 DAG 有 Airflow CLI 命令可以做到这一点吗我环顾四周但找不
在 AMP 中运行 JavaScript

我对 JavaScript 应该如何在 AMP 页面中运行感到有点困惑据我了解我的 JavaScript 必须在 iframe 中执行此类 iframe 必须放置在页面下方至少从顶部起 75 并且必须通过 https 提供服务这确
std::runtime_error::runtime_error(const std::string&) 如何满足 std::Exception 对 throw() 的要求？

std exception要求它的构造函数是throw Yet std runtime error接受一个std string作为它的参数这表明它正在存储一个std string某处因此作业或复制构造必须在某个地方进行而对于std
http.sslVerify=false 不会在 git config 中禁用 ssl 验证

Issue 我一直在尝试通过来自企业 GitHub 服务器的 http 代理在 git 全局配置中设置从 Ubuntu AWS 实例克隆 git 存储库从代理克隆可以工作但是从实例克隆通过代理我收到以下错误致命无法访问 ht
在 Visual Studio 中调试 JavaScript 时出现“没有为当前文档加载符号”

我正在开发一个 NET 3 5 网站一个解决方案下有三个项目我在这个项目中使用 jQuery 我想使用 Visual Studio JavaScript 调试器来单步执行我的 JavaScript 代码如果我在任何 js 文件中设置断
QLabel Qt/c++ 文本的渐变颜色

我尝试为 QLabel 文本设置渐变颜色我正在尝试使用 setStyleSheet 函数但它不起作用我阅读这篇文章 https www qtcentre org threads 32781 don t work qlineargrad
data.table join + update with mult='first' 给出了意想不到的结果

在下面的示例中我有一个用户表和一个事务表其中一个用户可以有 0 个 1 个或多个事务我执行连接更新mult first 在 users 表上尝试插入一列指示每个用户第一次发生事务的日期 library data table v1
如何从 XLL UDF 返回数组

我正在尝试使用 C API 为 Excel 编写一个数组构造函数作为工作表函数 Goal array cons 1 2 3 gt 1 2 3 但是我没有正确初始化 XLOPER12 在 Excel 中我的函数当前返回 NUM 我正在将参
模块已经成功安装，但是导入时却找不到？ - Python

我正在尝试使用 graphviz Python 模块但遇到了这个问题我在命令提示符下安装了它但它没有显示在 IPython 中我还有一个 Python 3 5 32 位解释器它显示在其中但我正在尝试弄清楚如何安装它以便它在
如何找出 Instruments 中保留对象的内容？

我最近将我的 iOS 项目转换为 ARC 视图控制器之一没有调用其 dealloc 方法并且没有根据 Instruments 进行释放我已经仔细检查了我的所有属性并将适当的属性设置为弱我还确保任何将视图控制器作为委托的东西都在 vie
ZLIB 解压 - 客户端

我正在以 ZLIB 压缩输入流使用 Javascript Ajax JQuery 我需要在客户端解压缩它有办法这样做吗我已经在 J AVA 中工作了如下所示但需要在客户端执行此操作 url new URL getCodeBase
如何在S3中保存数据流？ aws-sdk-go 示例不起作用？

我正在尝试将给定的数据流持久保存到 S3 兼容存储中在流结束之前大小是未知的大小可能从 5MB 到 500GB 不等我尝试了不同的可能性但没有找到比自己实现分片更好的解决方案我最好的猜测是使用我的流填充固定大小的缓冲区并将其写入
神经网络反向传播算法在Python中不起作用

我正在用 Python 编写一个神经网络遵循示例here http page mi fu berlin de rojas neural chapter K7 pdf 考虑到神经网络在训练一万次后未能产生正确的值在误差范围内反向传播算法

神经网络反向传播算法在Python中不起作用

神经网络反向传播算法在Python中不起作用 的相关文章

随机推荐

热门标签

神经网络反向传播算法在Python中不起作用的相关文章