小编Ioa*_*ios的帖子

在Keras中,您可以像这样指定一个dropout图层:

model.add(Dropout(0.5))

但是使用GRU单元格,您可以将dropout指定为构造函数中的参数:

model.add(GRU(units=512,
        return_sequences=True,
        dropout=0.5,
        input_shape=(None, features_size,)))

有什么不同？一个比另一个好吗？

在Keras的文档中, 它将其添加为单独的丢失层(请参阅"使用LSTM进行序列分类")

我用参数创建了自定义损失函数。

def w_categorical_crossentropy(weights):
  def loss(y_true, y_pred):
  print(weights)
  print("----")
  print(weights.shape)
  final_mask = K.zeros_like(y_pred[:, 0])
  y_pred_max = K.max(y_pred, axis=1)
  y_pred_max = K.reshape(y_pred_max, (K.shape(y_pred)[0], 1))
  y_pred_max_mat = K.cast(K.equal(y_pred, y_pred_max), K.floatx())
  return K.categorical_crossentropy(y_pred, y_true)
return loss

现在，我需要控制权重参数值，但打印功能无法正常工作。有没有办法打印权重值？

我使用的是ubuntu 16,python 3,tf-GPU和keras.

由于这里解释的cuda错误,我降级到了1.4

但现在我收到了这个错误

TypeError:softmax()得到一个意外的关键字参数'axis'

似乎这是张量流中的API变化,而新的keras不适合旧的tf.

我找不到与tf 1.4 gpu一起使用的正确keras版本.什么是正确的？

我有一个 tf.keras.Model 的子类模型，代码如下

import tensorflow as tf


class Mymodel(tf.keras.Model):

    def __init__(self, classes, backbone_model, *args, **kwargs):
        super(Mymodel, self).__init__(self, args, kwargs)
        self.backbone = backbone_model
        self.classify_layer = tf.keras.layers.Dense(classes,activation='sigmoid')

    def call(self, inputs):
        x = self.backbone(inputs)
        x = self.classify_layer(x)
        return x

inputs = tf.keras.Input(shape=(224, 224, 3))
model = Mymodel(inputs=inputs, classes=61, 
                backbone_model=tf.keras.applications.MobileNet())
model.build(input_shape=(20, 224, 224, 3))
model.summary()

结果是：

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
mobilenet_1.00_224 (Model)   (None, 1000)              4253864   
_________________________________________________________________
dense (Dense)                multiple                  61061     
=================================================================
Total params: 4,314,925
Trainable params: 4,293,037
Non-trainable params: 21,888 …

我在 ubuntu 16.04 上有 tensorflow-gpu 1.2.1 和 keras。

我无法执行：

from kears.utils import multi_gpu_model 

有没有人像他们文档的常见问题部分中描述的那样使用 multi_gpu_model 取得了成功？

我有一台带有 4 个 GeForce GTX 1080 Ti 卡的 4 GPU 机器，并且想使用所有这些卡。

这是我得到的错误：

import keras.utils.multi_gpu_model

---------------------------------------------------------------------------
ModuleNotFoundError                       Traceback (most recent call last)
<ipython-input-7-0174878249b1> in <module>()
----> 1 import keras.utils.multi_gpu_model
      2 

ModuleNotFoundError: No module named 'keras.utils.multi_gpu_model'

我可以成功导入 keras 和 keras.utils。

我正在尝试使用 Keras 函数式 API 训练 seq2seq 翻译器。以下代码工作正常：

encoder_inputs = Input(shape=(None, num_encoder_tokens))
encoder = LSTM(latent_dim, return_state=True)
encoder_outputs, state_h, state_c = encoder(encoder_inputs)

我现在想尝试双向 LSTM。我的尝试：

encoder_inputs = Input(shape=(None, num_encoder_tokens))
encoder = Bidirectional(LSTM(latent_dim, return_state=True))
encoder_outputs, state_h, state_c = encoder(encoder_inputs)

这将返回一个错误：

ValueError                                Traceback (most recent call last)
<ipython-input-25-6ae24c1319f3> in <module>()
  6 encoder = Bidirectional(LSTM(latent_dim, return_state=True))
  7 print(len(encoder(encoder_inputs)))
----> 8 encoder_outputs, state_h, state_c = encoder(encoder_inputs)
  9 
 10 # We discard `encoder_outputs` and only keep the states.

ValueError: too many values to unpack (expected 3)

如何从双向 LSTM …

我刚刚在keras中实现了广义骰子损失（骰子损失的多类版本），如ref中所述：

（我的目标定义为：（batch_size，image_dim1，image_dim2，image_dim3，nb_of_classes））

def generalized_dice_loss_w(y_true, y_pred): 
    # Compute weights: "the contribution of each label is corrected by the inverse of its volume"
    Ncl = y_pred.shape[-1]
    w = np.zeros((Ncl,))
    for l in range(0,Ncl): w[l] = np.sum( np.asarray(y_true[:,:,:,:,l]==1,np.int8) )
    w = 1/(w**2+0.00001)

    # Compute gen dice coef:
    numerator = y_true*y_pred
    numerator = w*K.sum(numerator,(0,1,2,3))
    numerator = K.sum(numerator)

    denominator = y_true+y_pred
    denominator = w*K.sum(denominator,(0,1,2,3))
    denominator = K.sum(denominator)

    gen_dice_coef = numerator/denominator

    return 1-2*gen_dice_coef

但是一定有问题。我正在处理3D图像，必须将其细分为4类（1个背景类和3个对象类，我有一个不平衡的数据集）。首先奇怪的事情：当我的火车损失和准确性训练中提高（和收敛非常快），我确认损失/精度是恒定的低谷时期（见图片）。其次，在对测试数据进行预测时，仅预测了背景类：我得到了恒定的体积。

我使用了完全相同的数据和脚本，但存在分类交叉熵损失，并得到了合理的结果（对象类别已细分）。这意味着我的实现存在问题。知道会是什么吗？

另外，我认为具有通用的骰子丢失实现对keras社区很有用，因为它似乎已用于大多数最近的语义分割任务中（至少在医学图像社区中）。

PS：对我来说，如何定义权重似乎很奇怪；我得到大约10 ^ -10的值。还有其他人尝试实现吗？我也测试了我的功能，但没有权重，但是遇到了同样的问题。

开始学习 pytorch 并尝试做一些非常简单的事情，尝试将大小为 5 的随机初始化向量移动到值 [1,2,3,4,5] 的目标向量。

但我的距离并没有减少！！而我的矢量x只是发疯了。不知道我错过了什么。

import torch
import numpy as np
from torch.autograd import Variable

# regress a vector to the goal vector [1,2,3,4,5]

dtype = torch.cuda.FloatTensor # Uncomment this to run on GPU

x = Variable(torch.rand(5).type(dtype), requires_grad=True)
target = Variable(torch.FloatTensor([1,2,3,4,5]).type(dtype), 
requires_grad=False)
distance = torch.mean(torch.pow((x - target), 2))

for i in range(100):
  distance.backward(retain_graph=True)
  x_grad = x.grad
  x.data.sub_(x_grad.data * 0.01)

我第一次使用 dask 并尝试从训练有素的 keras 模型运行 predict()。

如果我不使用 dask，该函数可以正常工作（即 pd.DataFrame() 与 dd.DataFrame () ）。使用 Dask，错误如下。这不是一个常见的用例吗（除了给 groupby 打分）

def calc_HR_ind_dsk(grp):
    model=keras.models.load_model('/home/embedding_model.h5')
    topk=10

    x=[grp['user'].values,grp['item'].values]
    pred_act=list(zip(model.predict(x)[:,0],grp['respond'].values))
    top=sorted(pred_act, key=lambda x: -x[0])[0:topk]
    hit=sum([x[1] for x in top])
    return(hit)



import dask.dataframe as dd

#step 1 - read in data as a dask df. We could reference more than 1 files using '*' wildcard
df = dd.read_csv('/home/test_coded_final.csv',dtype='int64')
results=df.groupby('user').apply(calc_HR_ind_dsk).compute()

类型错误：无法将 feed_dict 键解释为张量：Tensor Tensor("Placeholder_30:0", shape=(55188, 32), dtype=float32) 不是此图的元素。

我正在尝试使用 keras 在图像数据生成器中裁剪图像的中心。我有大小的图像，192x192我想裁剪它们的中心，以便输出批次150x150或类似的东西。

我可以在 Keras 中立即执行此操作ImageDataGenerator吗？我想不会，因为我看到target_sizedatagenerator 中的参数破坏了图像。

我找到了这个随机裁剪的链接：https : //jkjung-avt.github.io/keras-image-cropping/

我已经修改了作物如下：

def my_crop(img, random_crop_size):
  if K.image_data_format() == 'channels_last':
    # Note: image_data_format is 'channel_last'
    assert img.shape[2] == 3
    height, width = img.shape[0], img.shape[1]
    dy, dx = random_crop_size #input desired output size
    start_y = (height-dy)//2
    start_x = (width-dx)//2
    return img[start_y:start_y+dy, start_x:(dx+start_x), :]
  else:
      assert img.shape[0] == 3
      height, width = img.shape[1], img.shape[2]
      dy, dx = random_crop_size  # input desired output size
      start_y = …