线性回归的从零开始实现 讨论区


#23

loss.backward(),backward的实现在那里看?


#24

请问 设置梯度更新率的时候 loss 有时 是 INF 有时 是 NAN 请问二者有什么区别


#25
    niter +=1
    curr_loss = nd.mean(loss).asscalar()
    moving_loss = (1 - smoothing_constant) * moving_loss + (smoothing_constant) * curr_loss

    # correct the bias from the moving averages
    est_loss = moving_loss/(1-(1-smoothing_constant)**niter)

请问,est_loss 为什么等于moving_loss/(1-(1-smoothing_constant)**niter)?请原谅我的数学能力比较低


#26

请教一下,梯度下降时为什么要一个循环呢?

def SGD(params, lr):
    for param in params:
        param[:] = param - lr * param.grad

我这样写也是可以的,而且效率更高吧

def grad_descent(params, rate):
    params[:] -= rate*params.grad

#27

autograd不支持in-place操作


#28

看到多层感知机,明白了。不同层的params是用list合在一起的传给SGD的,所以没有for不能处理这种情况


#29

为什么需要算出平滑平均移动损失moving_loss,这个对训练模型有什么指导意义?如果只用loss本身来指导训练会有什么问题?


#30

这个平滑损失是在bp之后,对训练没有任何影响,只是为了plot


#31
w = nd.random_normal(shape=(num_inputs, 1))
b = nd.zeros((1,))
params = [w, b]

为什么之后params就与wb绑定了呢?


#32

作为一个初学者,我有两点不太清楚,还请指教:

  1. y[i] = 2 * X[i][0] - 3.4 * X[i][1] + 4.2 + noise,公式从何而来?难道是源数据里x,y的对应关系的公式?
  2. 既然已知true_w = [2, -3.4],true_b = 4.2结果,为什么还要预测?

我理解中的预测,比如已知某段周期的值,x, y作为输入值,推测下一周期的x,y。
请各位大神原谅我的无知〜〜〜:disappointed_relieved:


#33

请问
import mxnet 之后
console 无法退出 这个情况要怎么解决呀?


#34

可视化预测和 Ground Truth 的部分

fg2.plot(X[:sample_size, 1].asnumpy(),
         net(X[:sample_size, :]).asnumpy(), 'or', label='Estimated')

为啥用 X[:,1],而不是 X[:,0],求指导 :blush: 北京地区的小伙伴我可以请吃火锅以表谢意 :rofl:


#36

关于mxnet得autograd的疑问

最近通过教程在学习mxnet,发现mxnet自动微分的函数很强大,也很好用。但是对下面这段段代码有点疑问:

from mxnet import autograd
x = nd.array([[1, 2], [3, 4]])
x.attach_grad()
with autograd.record():
    y = x * 2
    z = y * x
z.backward()
x.grad == 4*x

这里的z.backward就是z对x的求导结果,但是如果 我还想知道y对x的求导结果呢?我应该怎么操作。尝试用下面的代码会报错:

from mxnet import autograd
x = nd.array([[1, 2], [3, 4]])
x.attach_grad()
with autograd.record():
    y = x * 2
    z = y * x
z.backward()
y.backward()
print(x.grad)

请问这个为什么会报错,应该如何改正?


#37
backward(out_grad=None, retain_graph=False, train_mode=True) method of mxnet.ndarray.ndarray.NDArray instance
    Compute the gradients of this NDArray w.r.t variables.
    
    Parameters
    ----------
    out_grad : NDArray, optional
        Gradient with respect to head.
    retain_graph : bool, optional
        Whether to retain the computaion graph for another backward
        pass on the same graph. By default the computaion history
        is cleared.
    train_mode : bool, optional
        Whether to compute gradient for training or inference.

可以看一下retain_graph参数,默认清除了computaion历史,要知道y对x的求导结果,可以修改如下:

from mxnet import nd
from mxnet import autograd

x = nd.array([[1, 2], [3, 4]])
x.attach_grad()
with autograd.record():
    y = x * 2
    z = y * x
z.backward(retain_graph=True)
print(x.grad)
y.backward()
print(x.grad)

#39

谢谢,讲解得比较详细。


#40

这里只是一个用模拟数据来教大家使用线性回归的例子而已吧。因为使用模拟数据就能知道自己拟合的模型的参数是否收敛到真值了


#41

通过读取numpy(pandas)数据进行多元回归,报错:

最近我想通过pandas读取excel的数据,作为多元回归模型的输入,但是运行的时候报错:

d:\program files (x86)\jenkins\workspace\mxnet\mxnet\src\operator./elemwise_op_common.h:123: Check failed: assign(&dattr, (*vec)[i]) Incompatible attr in node FullyConnected at 1-th input: expected float64, got float32

相关代码如下:

dataSet = pd.read_excel('final.xlsx')
feature_index=['gop_raw','gop_lat','gop_lat2','wer','ins','silence']
InputX = nd.array(dataSet.loc[:,feature_index],dtype='float64')
InputY = nd.array(dataSet.loc[:,'rg'],dtype='float64')

batch_size = 64
def data_iter():
    idx = list(range(len(InputY)))
    random.shuffle(idx)
    for i in range(0,len(InputY),batch_size):
        j = nd.array(idx[i:min(i+batch_size,len(InputY))])
        yield nd.take(InputX,j),nd.take(InputY,j)

net = gluon.nn.Sequential()
#net.add(gluon.nn.Dense(256,activation='relu'))
net.add(gluon.nn.Dense(1))
    
net.initialize()
cost_loss = gluon.loss.L2Loss()

trainer=gluon.Trainer(net.collect_params(),'sgd',{'learning_rate':0.1})
epochs = 10
for epoch in range(epochs):
    total_loss = 0.0
    for data,label in data_iter():
        with autograd.record():
            output=net(data)
            loss = cost_loss(output,label)
        loss.backward()
        trainer.step(batch_size)
        total_loss += nd.sum(loss).asscalar()
    print("Epoch %d,average loss:%f"%(epoch,total_loss/len(InputY)))

其中截取data,并打印data的数据如下:

print(data)

[[  0.2568131    0.68032658   0.76785748  61.02         0.21186441   0.198     ]
 [  0.16683672   0.49571033   0.64637287  80.51         0.11864407
    0.12179487]]
<NDArray 2x6 @cpu(0)>

请问,这种错误到底是如何产生的,原因是什么,应该如何避免。谢谢。


#42

w 和b都要进行反向传播来迭代


#43

已解决,怎么关闭这条评论,是我自己不应该将InputXInputY改成float64,去掉dtype='float64'就不会报错了。


#44

大家好,我刚开始玩这个第一课的线性回归,我的想法是用线性回归做MNIST的识别。
理论上,好像这样不是太合适;但实际上,效果貌似不错。
我的问题是,用线性回归就能搞到这样的准确率,合理吗?
期待大神的解答~~

import tensorflow.examples.tutorials.mnist.input_data as input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
Extracting MNIST_data/train-images-idx3-ubyte.gz
Extracting MNIST_data/train-labels-idx1-ubyte.gz
Extracting MNIST_data/t10k-images-idx3-ubyte.gz
Extracting MNIST_data/t10k-labels-idx1-ubyte.gz

上面,加载了著名的MNIST数据集,显示一下

import matplotlib.pyplot as plt 
plt.imshow(mnist.train.images[0].reshape(28, 28),cmap = 'binary')#黑白显示    
plt.show()
mnist.train.labels[0]
array([ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,  0.,  0.])

可以看到,图片是784的一个向量,标签是一个10向量

print(mnist.train.images[0].shape)
print(mnist.train.labels[0].shape)
(784,)
(10,)

现在,再次开始猜测吧

import numpy as np
W = np.zeros([10, 784])
B = np.zeros([10,])
pred = np.matmul(W, mnist.train.images[0]) + B
pred
array([ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.])

继续沿用之前更新参数的方法

error = 0
for i in range(len(mnist.train.images)):
    pred = np.matmul(W, mnist.train.images[i]) + B
    error += (np.argmax(pred) != np.argmax(mnist.train.labels[i]))
    for j in range(len(mnist.train.labels[0])):
        W[j,:] -= .0001 * 2 * mnist.train.images[i] * (pred[j] - mnist.train.labels[i, j])
        B[j] -= .0001 * 2 * (pred[j] - mnist.train.labels[i, j])
print(error / len(mnist.train.images))
0.163

让我们看看正确率怎么样

right = 0
for i in range(len(mnist.test.images)):
    right += (np.argmax(np.matmul(W, mnist.test.images[i]) + B) == np.argmax(mnist.test.labels[i]))
print (right / len(mnist.test.images))
0.8465

我的问题是,用线性回归就能搞到这样的准确率,合理吗?
期待大神的解答~~