小编blu*_*nox的帖子

冻结pytorch中的砝码以进行param_groups设置。

因此，如果您想在训练期间冻结体重：

for param in child.parameters():
    param.requires_grad = False

优化器也必须更新为不包括非梯度权重：

optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=opt.lr, amsgrad=True)

如果要weight_decay对偏倚和权重使用不同的/学习率/这也允许不同的学习率：

param_groups = [{'params': model.module.bias_parameters(), 'weight_decay': args.bias_decay},
                {'params': model.module.weight_parameters(), 'weight_decay': args.weight_decay}]

param_groups定义了一个dic 列表，并将其传递SGD如下：

optimizer = torch.optim.Adam(param_groups, args.lr,
                                 betas=(args.momentum, args.beta))

冻结单个砝码如何实现？在dic列表上运行filter或是否可以将张量单独添加到优化器？

这是我定义的模型，它是具有2个完全连接层的简单lstm。

import copy
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

class mylstm(nn.Module):
    def __init__(self,input_dim, output_dim, hidden_dim,linear_dim):
        super(mylstm, self).__init__()
        self.hidden_dim=hidden_dim
        self.lstm=nn.LSTMCell(input_dim,self.hidden_dim)
        self.linear1=nn.Linear(hidden_dim,linear_dim)
        self.linear2=nn.Linear(linear_dim,output_dim)
    def forward(self, input):
        out,_=self.lstm(input)
        out=nn.Dropout(p=0.3)(out)
        out=self.linear1(out)
        out=nn.Dropout(p=0.3)(out)
        out=self.linear2(out)
        return out

x_train和x_val是带有shape的float数据帧(4478,30)，而y_train和y_val是带有shape的float df(4478,10)

    x_train.head()
Out[271]: 
       0       1       2       3    ...        26      27      28      29
0  1.6110  1.6100  1.6293  1.6370   ...    1.6870  1.6925  1.6950  1.6905
1  1.6100  1.6293  1.6370  1.6530   ...    1.6925  1.6950 …

有人可以向我解释为什么自动编码器没有收敛？对我来说,下面两个网络的结果应该是相同的.但是,下面的自动编码器不会收敛,而下面的网络则是收敛的.

# autoencoder implementation, does not converge
autoencoder = Sequential()
encoder = containers.Sequential([Dense(32,16,activation='tanh')]) 
decoder = containers.Sequential([Dense(16,32)])
autoencoder.add(AutoEncoder(encoder=encoder, decoder=decoder, 
                        output_reconstruction=True))
rms = RMSprop()
autoencoder.compile(loss='mean_squared_error', optimizer=rms)

autoencoder.fit(trainData,trainData, nb_epoch=20, batch_size=64,
            validation_data=(testData, testData), show_accuracy=False)

 # non-autoencoder implementation, converges

model = Sequential()
model.add(Dense(32,16,activation='tanh')) 
model.add(Dense(16,32))
model.compile(loss='mean_squared_error', optimizer=rms)

model.fit(trainData,trainData, nb_epoch=numEpochs, batch_size=batch_size,
            validation_data=(testData, testData), show_accuracy=False)

在下面的代码中,l2令人惊讶地返回与l1相同的值,但由于在l2之前在列表中请求了优化器,我预计损失将是训练后的新损失.我可以不从图表中同时请求多个值并期望输出一致吗？

import tensorflow as tf
import numpy as np

x = tf.placeholder(tf.float32, shape=[None, 10])
y = tf.placeholder(tf.float32, shape=[None, 2])

weight = tf.Variable(tf.random_uniform((10, 2), dtype=tf.float32))

loss = tf.nn.sigmoid_cross_entropy_with_logits(tf.matmul(x, weight), y)

optimizer = tf.train.AdamOptimizer(0.1).minimize(loss)

with tf.Session() as sess:
    tf.initialize_all_variables().run()

    X = np.random.rand(1, 10)
    Y = np.array([[0, 1]])

    # Evaluate loss before running training step
    l1 = sess.run([loss], feed_dict={x: X, y: Y})[0][0][0]
    print(l1) # 3.32393

    # Running the training step
    _, l2 = sess.run([optimizer, loss], feed_dict={x: X, y: Y})
    print(l2[0][0]) # 3.32393 -- …

我正在尝试堆叠2层来tf.nn.conv2d_transpose()对张量进行上采样.它在前馈期间工作正常,但在向后传播时出现错误: ValueError: Incompatible shapes for broadcasting: (8, 256, 256, 24) and (8, 100, 100, 24).

基本上,我只是将第一个的输出设置conv2d_transpose为第二个的输入:

convt_1 = tf.nn.conv2d_transpose(...)
convt_2 = tf.nn.conv2d_transpose(conv_1)

只使用一个conv2d_transpose,一切正常.只有多个conv2d_transpose堆叠在一起时才会出现错误.

我不确定实现多层的正确方法conv2d_transpose.任何关于如何解决这个问题的建议都将非常感激.

这是一个复制错误的小代码:

import numpy as np
import tensorflow as tf

IMAGE_HEIGHT = 256
IMAGE_WIDTH = 256
CHANNELS = 1

batch_size = 8
num_labels = 2

in_data = tf.placeholder(tf.float32, shape=(batch_size, IMAGE_HEIGHT, IMAGE_WIDTH, CHANNELS))
labels = tf.placeholder(tf.int32, shape=(batch_size, IMAGE_HEIGHT, IMAGE_WIDTH, 1))

# Variables
w0 = tf.Variable(tf.truncated_normal([3, 3, CHANNELS, …

我正在尝试制作一个变分自动编码器来学习编码 DNA 序列，但遇到了意外错误。

我的数据是一组单热数组。

我遇到的问题是值错误。它告诉我我有一个四维输入，而我的输入显然是三维的 (100, 4008, 4)。

事实上，当我打印出seq图层时，它说它的形状是 (?, 100, 4008, 4)。

当我取出一个维度时，它会给我一个二维错误。

任何帮助将不胜感激！

代码是：

from keras.layers import Input 
from keras.layers.convolutional import Conv1D
from keras.layers.core import Dense, Activation, Flatten, RepeatVector, Lambda
from keras import backend as K
from keras.layers.wrappers import TimeDistributed
from keras.layers.recurrent import GRU
from keras.models import Model
from keras import objectives

from one_hot import dna_sequence_to_one_hot

from random import shuffle
import numpy as np

# take FASTA file and convert into array of vectors
seqs = …

我想允许 HyperLinkRelatedField 只接受一个 id 而不是需要一个超链接来创建一个对象的新实例，但是对于获取请求，我想返回的超链接不仅仅是一个 id 但它似乎是一个或其他。这可能吗？

class Blog(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Blog
        fields = ('url', 'id')

class Comment(serializers.HyperlinkedModelSerializer):
    blog = serializers.HyperlinkedRelatedField(view_name='blog-detail', queryset=Blog.objects.all())
    class Meta:
        model = Comment
        fields = ('url', 'text', 'blog')

GET请求评论返回（这是完美的）：

{'url': 'mysite.fake/comments/1', 'text': 'test text', 'blog': 'mysite.fake/blog/1'}

POST请求需要：

{'text': 'test text', 'blog': 'mysite.fake/blog/1'}

我也希望能够通过：

{'text': 'test text', 'blog': '1'}

我正在尝试使用以下代码从csv文件转置矩阵：

import csv
from itertools import izip
a = izip(*csv.reader(open("TDM.csv", "rb")))
csv.writer(open("output.csv", "wb")).writerows(a)

不幸的是，发生以下错误：

import csv
from itertools import izip
a = izip(*csv.reader(open("TDM.csv", "rb")))
csv.writer(open("output.csv", "wb")).writerows(a)

我已经浏览了各个论坛，但找不到适合我的正确答案。

我使用 savetxt 保存了一个 numpy 数组，并给了该数组一个标题。当我使用 loadtxt 读取文件时，标题将被忽略，只有数据保存在我的新数组中。我如何访问标题，因为它包含我想保存为字符串的重要信息。

编辑：

np.savetxt(file_name, array, delimiter=",", header='x,y,z, data from monte carlo simulation')
data = np.loadtxt('test', dtype=float, delimiter=',')

我想获取“来自蒙特卡洛模拟的数据”并将其保存为字符串。

我已经建立了一个注意力的RNN语言模型,我通过参加所有以前的隐藏状态(只有一个方向)为输入的每个元素创建上下文向量.

在我看来,最直接的解决方案是在RNN输出上使用for循环,这样每个上下文向量一个接一个地计算.

import torch
import torch.nn as nn
import torch.nn.functional as F

class RNN_LM(nn.Module):
    def __init__(self, hidden_size, vocab_size, embedding_dim=None, droprate=0.5):
        super().__init__()
        if not embedding_dim:
            embedding_dim = hidden_size
        self.embedding_matrix = nn.Embedding(vocab_size, embedding_dim)

        self.lstm = nn.LSTM(input_size=embedding_dim, hidden_size=hidden_size, batch_first=False)
        self.attn = nn.Linear(hidden_size, hidden_size)
        self.vocab_dist = nn.Linear(hidden_size, vocab_size)
        self.dropout = nn.Dropout(droprate)

    def forward(self, x):
        x = self.dropout(self.embedding_matrix(x.view(-1, 1)))
        x, states = self.lstm(x)
        #print(x.size())
        x = x.squeeze()
        content_vectors = [x[0].view(1, -1)]
        # for-loop over hidden states and attention
        for i in …