小编Ioa*_*ios的帖子

我一直在尝试使用 Keras 训练 CNN，并将数据增强应用于一系列图像及其分割掩码。在线示例说为了做到这一点，我应该使用 flow_from_directory() 创建两个单独的生成器，然后压缩它们。

但是，我可以只为图像和蒙版使用两个 numpy 数组，使用 flow() 函数，而是这样做：

# Create image generator
data_gen_args = dict(rotation_range=5,
                     width_shift_range=0.1,
                     height_shift_range=0.1,
                     validation_split=0.2)
image_datagen = ImageDataGenerator(**data_gen_args)

seed = 1

# Create training and validation generators including masks
train_generator = image_datagen.flow(images, masks, seed=seed, subset='training')
val_train_generator = image_datagen.flow(images, masks, seed=seed, subset='validation')   

# Train model
model.fit_generator(train_generator, steps_per_epoch=50,
                validation_data = val_train_generator,
                validation_steps = 10, shuffle=True, epochs=20)

如果没有，为什么不呢？似乎如果我运行生成器，我只能输出图像而不能输出蒙版，所以我担心它没有做我想要的。

我面临的问题是，当我向 cnn 提供灰度图像数据集时，它会将其读取为 3 通道图像，而不是单通道图像。

那么如何将3通道图像转换为单通道灰度图像呢？

我想以编程方式找出可用的 GPU 及其当前的内存使用情况，并根据其内存可用性使用其中一个 GPU。我想在 PyTorch 中做到这一点。

我在这篇文章中看到了以下解决方案：

import torch.cuda as cutorch

for i in range(cutorch.device_count()):
    if cutorch.getMemoryUsage(i) > MEM: 
        opts.gpuID = i
        break

但它在 PyTorch 0.3.1 中不起作用（没有调用函数，getMemoryUsage）。我对基于 PyTorch（使用库函数）的解决方案感兴趣。任何帮助，将不胜感激。

我有一个 PyTorch 计算图，它由一个执行一些计算的子图组成，然后这个计算的结果（我们称之为x）被分支到另外两个子图。这两个子图中的每一个都会产生一些标量结果（让我们称它们为y1和y2）。我想对这两个结果中的每一个都做一个反向传递（即我想累加两个子图的梯度。我不想执行实际的优化步骤）。

现在，由于内存是这里的一个问题，我想按以下顺序执行操作：首先，计算x。然后，计算y1，并执行y1.backward()while（这是关键点）保留通向 的图x，但将图从 释放x到y1。然后，计算y2，并执行y2.backward()。

换句话说，为了在不牺牲太多速度的情况下节省内存，我想保留x而不需要重新计算它，但是我想在我不再需要它们之后删除所有从x到 的计算y1。

问题是retain_graph函数的参数backward()将保留通向 的整个图y1，而我只需要保留通向 的图的一部分x。

这是我理想中想要的示例：

import torch

w = torch.tensor(1.0)
w.requires_grad_(True)

# sub-graph for calculating `x`
x = w+10

# sub-graph for calculating `y1`
x1 = x*x
y1 = x1*x1
y1.backward(retain_graph=x) # this would not work, …

嗨，有人知道keras吗？我无法理解问题是什么？我遇到了这个问题：

ValueError: You are passing a target array of shape (1000, 1) while 
using as loss `categorical_crossentropy`. `categorical_crossentropy` 
expects targets to be binary matrices (1s and 0s) of shape (samples, 
classes). If your targets are integer classes, you can convert them to 
the expected format via...
from keras.utils import to_categorical
y_binary = to_categorical(y_int)


Alternatively, you can use the loss function ` 
sparse_categorical_crossentropy` instead, which does expect integer targets.

Hieer是完整代码：https ://ideone.com/v9yojt

我有65668个文件的数据集。

我将Keras用于CNN，这些是我的图层：

embedding_layer = Embedding(len(word_index) + 1,
                        EMBEDDING_DIM,
                        weights=[embedding_matrix],
                        input_length=MAX_SEQUENCE_LENGTH,
                        trainable=True)
sequence_input = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32')
embedded_sequences = embedding_layer(sequence_input)
x = Conv1D(128, 5, activation='relu')(embedded_sequences)
x = MaxPooling1D(5)(x)
x = Conv1D(256, 5, activation='relu')(x)
x = MaxPooling1D(5)(x)
x = Flatten()(x)
x = Dense(128, activation='relu')(x)
preds = Dense(len(labels_index), activation='softmax')(x)

第一嵌入层在GloVE.6B.100d上训练。拟合数据：

# fitting the data
model.fit(x_train, y_train, validation_data=(x_val, y_val),
      epochs=20, batch_size=128)

该MAX_SEQUENCE_LENGTH是500，我在GPU的NVIDIA GeForce 940MX训练，我得到以下错误的堆栈的一部分：

资源耗尽：分配具有形状的张量[15318793,100]并在/ job：localhost / replica：0 / task：0 / device：GPU：0上通过分配器GPU_0_bfc输入float

我尝试将批处理大小减小到16，甚至8，但仍然出现相同的错误。问题可能是什么？

我正在尝试使用Tensorflow作为后端，在Keras LSTM中将Jaccard系数应用为自定义损失函数。

我知道我必须打以下电话：

model.compile(optimizer='rmsprop', loss=[jaccard_similarity])

其中jaccard_similarity函数应为以下的keras.backend实现：

def jaccard_similarity(doc1, doc2):
   intersection =set(doc1).intersection(set(doc2))
   union = set(doc1).union(set(doc2))
   return len(intersection)/len(union)

问题是我找不到使用tensorflow作为后端在张量上实现交集和并集函数的方法。

有什么建议吗？

run_meta = tf.RunMetadata()
enter codwith tf.Session(graph=tf.Graph()) as sess:
K.set_session(sess)


with tf.device('/cpu:0'):
    base_model = MobileNet(alpha=1, weights=None, input_tensor=tf.placeholder('float32', shape=(1,224,224,3)))




opts = tf.profiler.ProfileOptionBuilder.float_operation()    
flops = tf.profiler.profile(sess.graph, run_meta=run_meta, cmd='op', options=opts)

opts = tf.profiler.ProfileOptionBuilder.trainable_variables_parameter()    
params = tf.profiler.profile(sess.graph, run_meta=run_meta, cmd='op', options=opts)

print("{:,} --- {:,}".format(flops.total_float_ops, params.total_parameters))

当我运行上面的代码时，我得到了下面的结果

1,137,481,704 --- 4,253,864

这与本文所述的触发器不同。

移动网络：https ://arxiv.org/pdf/1704.04861.pdf

ShuffleNet：https：//arxiv.org/pdf/1707.01083.pdf

如何计算论文中所述的确切触发器？

我正在研究具有常规矩阵格式的风力涡轮机数据集：[ row:datetime , column:features]

但我想用卷积来捕捉每个特征的进展，就像在 LSTM 中完成的那样。因此，我生成了一个具有以下维度的新数据集：

[datetime, 15 timesteps,128 features] ：每个原始日期时间行现在有 15 个寄存器（t-0,t-1,...,t-14）用于每个特征。

我的计划是使用大小为 1x5 的内核和 5 的步长分别对每个特征（通道）的时间步长维度进行卷积。从 128 个特征中获取每个 DateTime(batch)、长度为 5 的 3 个过滤器，输出形状为（无，3,128）。

然后我将最大池化应用于前一个第二维 (3) 结果，以获得“最重要的复杂时间步长”，期望输出大小：(None,1,128)

最后我连接了一个用于二元分类的密集层。

目前的网络架构在 keras 中实现如下：

model.add( Conv1D(padding = 'valid',filters = nfeatures,strides = 5,kernel_size = 5, 
                  activation = 'relu',input_shape = (timesteps,nfeatures)) )
model.add( MaxPooling1D() )
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))

问题是当我检查第一层 (conv1d) 的权重时，权重具有以下维度：[5,128,128] 和偏差 [128]。

预期的权重格式是：[5,1,128] 为什么是 5x128x128？，我只需要每个功能/通道的 5 个权重（内核大小）。

谢谢！

A 为我自己的测试数据重新训练了 inception_v3 模型。（背景故事：在我尝试解决我的 130 级“问题”之前，我只是想了解整个过程是如何工作的）

现在我得到了.h5。我尝试导入它并预测一些图像。但我只收到以下错误消息。

ValueError: `decode_predictions` expects a batch of predictions (i.e. a 2D array of shape (samples, 1000)). Found array with shape: (1, 5)

有人可以告诉我我做错了什么吗？

我的想法：我读了一些我需要 1000 个概率向量（对于 1000 个类）的东西，但我没有。我如何创建这样的向量并将所有 1000-my_num_of_classes（在我的情况下为 5）设置为 0？我想我必须预成形一个大小为 1000 的二维数组。但它不明白“样本”或在我的情况下“1”代表什么。或者我是否必须为我的 [1.0592173e-07 8.3998479e-09 9.9305904e-01 4.8276172e-05 6.8924953e-03] 数组写一些匹配（在我的情况下）。我在哪里解释 3 (id 2) 类（受过训练）的概率最高？所以也许就像一个文件，我有所有受过训练的课程，就像受过训练的一样？将最高的与对应的行（标签）相匹配？

会很棒:)

那将是我的预测代码

# Testing Inceptionv3
#from keras.applications.imagenet_utils import decode_predictions
import numpy as np
from keras.applications.inception_v3 import decode_predictions
import matplotlib.pyplot as plt
import os
from keras.models import load_model
from PIL import Image …

我想在Keras中设置glorot_uniform内核初始化程序的种子值。

model.add(Dense(50, input_dim=self.state_size, activation='relu', kernel_initializer='glorot_uniform(seed=0)'))

当我使用以上代码时，错误消息如下。

ValueError: Unknown initializer: glorot_uniform(seed=0)

如果我删除“（seed = 0）”，如下所示

 model.add(Dense(50, input_dim=self.state_size, activation='relu', kernel_initializer='glorot_uniform'))

它无需设置种子值即可很好地工作。

如何设置种子值？

码

import numpy as np
from keras.preprocessing.image import ImageDataGenerator
from keras.models import Sequential,Model
from keras.layers import Dropout, Flatten, Dense,Input
from keras import applications
from keras.preprocessing import image
from keras import backend as K
K.set_image_dim_ordering('tf')


# dimensions of our images.
img_width, img_height = 150,150

top_model_weights_path = 'bottleneck_fc_model.h5'
train_data_dir = 'Cats and Dogs Dataset/train'
validation_data_dir = 'Cats and Dogs Dataset/validation'
nb_train_samples = 20000
nb_validation_samples = 5000
epochs = 50
batch_size = 16
input_tensor = Input(shape=(150,150,3))

base_model=applications.VGG16(include_top=False, weights='imagenet',input_tensor=input_tensor)
for layer in base_model.layers:
    layer.trainable …

x = torch.tensor([3])

我有张量对象

print(x)

它给 tensor([3])

x.data[0]给出tensor(3) 如何得到公正3？