标签: conv-neural-network

我是 Keras 新手，我正在尝试获取 Keras 中的权重。我知道如何在 Python 中的 Tensorflow 中执行此操作。

代码：

data = np.array(attributes, 'int64')
target = np.array(labels, 'int64')

feature_columns = [tf.contrib.layers.real_valued_column("", dimension=2, dtype=tf.float32)]
learningRate = 0.1
epoch = 10000

# https://www.tensorflow.org/api_docs/python/tf/metrics
validation_metrics = {
"accuracy": tf.contrib.learn.MetricSpec(metric_fn = tf.contrib.metrics.streaming_accuracy ,
prediction_key = tf.contrib.learn.PredictionKey.CLASSES),
"precision": tf.contrib.learn.MetricSpec(metric_fn = tf.contrib.metrics.streaming_precision ,
prediction_key = tf.contrib.learn.PredictionKey.CLASSES),
"recall": tf.contrib.learn.MetricSpec(metric_fn = tf.contrib.metrics.streaming_recall ,
prediction_key = tf.contrib.learn.PredictionKey.CLASSES),
"mean_absolute_error": tf.contrib.learn.MetricSpec(metric_fn = tf.contrib.metrics.streaming_mean_absolute_error ,
prediction_key = tf.contrib.learn.PredictionKey.CLASSES),
"false_negatives": tf.contrib.learn.MetricSpec(metric_fn = tf.contrib.metrics.streaming_false_negatives ,
prediction_key = tf.contrib.learn.PredictionKey.CLASSES),
"false_positives": tf.contrib.learn.MetricSpec(metric_fn = tf.contrib.metrics.streaming_false_positives ,
prediction_key …

我正在使用骰子损失来实现涉及超网络的全卷积网络（FCN）。该模型有两个输入和一个输出，即二进制分割图。模型正在更新权重，但损失是恒定的。它甚至没有过度拟合仅三个训练示例

我也使用了其他损失函数，如骰子+二元交叉熵损失、jacard 损失和 MSE 损失，但损失几乎是恒定的。我还尝试了几乎所有激活函数，例如 ReLU、LeakyReLU、Tanh。此外，我必须在输出处使用 sigmoid，因为我需要输出在 [0,1] 范围内，学习率为 0.01。此外，我还尝试了不同的学习率，例如 0.0001、0.001、0.1。无论训练开始时的损失是多少，它总是以这个值出现

这显示了三个训练示例的梯度。以及整体损失

tensor(0.0010, device='cuda:0')
tensor(0.1377, device='cuda:0')
tensor(0.1582, device='cuda:0')
Epoch 9, Overall loss = 0.9604763123724196, mIOU=0.019766070265581623
tensor(0.0014, device='cuda:0')
tensor(0.0898, device='cuda:0')
tensor(0.0455, device='cuda:0')
Epoch 10, Overall loss = 0.9616242945194244, mIOU=0.01919178702228237
tensor(0.0886, device='cuda:0')
tensor(0.2561, device='cuda:0')
tensor(0.0108, device='cuda:0')
Epoch 11, Overall loss = 0.960331304506822, mIOU=0.01983801422510155

我预计损失会在几个时期内收敛。我应该怎么办？

我在 Keras 中训练了一个用于图像分类的模型。训练是通过使用枕头加载图像来进行的。在部署过程中，图像会加载到 opencv 中，这会大大降低模型的准确性。我发现pillow和opencv加载的图像在显示时是不同的。

im = Image.open("cat.jpg")
plt.imshow(im)
plt.show()

img = cv2.imread('cat.jpg')
plt.imshow(img)
plt.show()

为了解决这个问题，我尝试在 opencv 中加载图像并将其写入临时文件并将其加载到枕头中。

cv2.imwrite('cat2.jpg',img)
im1 = Image.open("cat2.jpg")
im == im1

输出

错误的

im1我尝试将和打印im为数组，并且值完全不同。我必须在部署中使用opencv。无论如何，我可以保持模型的准确性吗？

我正在为图像分类问题训练 2 个不同的 CNN（自定义学习和迁移学习）。我对两种型号使用相同的发电机。该数据集包含 5 个类别的 5000 个样本，但不平衡。

这是我正在使用的自定义模型。

def __init__(self, transfer_learning = False, lambda_reg = 0.001, drop_out_rate = 0.1):
    if(transfer_learning == False):
        self.model = Sequential();
        self.model.add(Conv2D(32, (3,3), input_shape = (224,224,3), activation = "relu"))
        self.model.add(MaxPooling2D(pool_size = (2,2)))

        self.model.add(Conv2D(64, (1,1), activation = "relu"))
        self.model.add(MaxPooling2D(pool_size = (2,2)))

        self.model.add(Conv2D(128, (3,3), activation = "relu"))
        self.model.add(MaxPooling2D(pool_size = (2,2)))

        self.model.add(Conv2D(128, (1,1), activation = "relu"))
        self.model.add(MaxPooling2D(pool_size = (2,2)))

        self.model.add(Flatten())

        self.model.add(Dense(512))
        self.model.add(Dropout(drop_out_rate))
        self.model.add(Dense(256))
        self.model.add(Dropout(drop_out_rate))

        self.model.add(Dense(5, activation = "softmax"))

steps_per_epoch所以我无法理解和之间的关系batch_size。 batch_size是生成器发送的样本数。但完成一个训练 epochsteps_per_epoch的数量是多少呢？batch_size …

我正在使用 pytorch 中开箱即用的 VGG-16 网络来预测一些图像索引。我发现对于同一个输入文件，如果我预测多次，我会得到不同的结果。这对我来说似乎违反直觉。一旦预测了权重（因为我使用的是预训练模型），任何步骤都不应该有任何随机性，因此使用相同输入文件的多次运行将返回相同的预测。

这是我的代码：

import torch
import torchvision.models as models
VGG16 = models.vgg16(pretrained=True)
def VGG16_predict(img_path):
  transformer = transforms.Compose([transforms.CenterCrop(224),transforms.ToTensor()])
  data = transformer(Image.open(img_path))
  output = softmax(VGG16(data.unsqueeze(0)), dim=1).argmax().item()
  return output # predicted class index
VGG16_predict(image) 

这是图像

我正在开发能够预测 10 秒音频文件中有趣时刻的应用程序。我将音频分成 50 毫秒的块并提取音符，因此每个示例有 200 个音符。当我添加卷积层时，它返回一个错误：

ValueError：层 conv1d_1 的输入 0 与该层不兼容：预期 ndim=3，发现 ndim=2。收到完整形状：[无，200]

这是我的代码：

def get_dataset(file_path):
  dataset = tf.data.experimental.make_csv_dataset(
      file_path,
      batch_size=12,
      label_name='label',
      na_value='?',
      num_epochs=1,
      ignore_errors=False)
  return dataset

train = get_dataset('/content/gdrive/My Drive/MyProject/train.csv')
test = get_dataset('/content/gdrive/My Drive/MyProject/TestData/manual.csv')
feature_columns = []

for number in range(200):
  feature_columns.append(tf.feature_column.numeric_column('note' + str(number + 1) ))

preprocessing_layer = tf.keras.layers.DenseFeatures(feature_columns)

model = tf.keras.Sequential([
    preprocessing_layer,
    tf.keras.layers.Conv1D(32, 3, padding='same', activation=tf.nn.relu, input_shape=[None, 200]),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(50, activation=tf.nn.relu),
    tf.keras.layers.Dense(1, activation=tf.nn.sigmoid)
])
model.compile(
    loss='binary_crossentropy',
    optimizer='adam',
    metrics=['accuracy'])
model.fit(train, epochs=20)

是什么原因导致此问题以及如何解决？

我正在使用对象检测 API 并调整 SSD 任务的参数。我的问题是指https://github.com/tensorflow/models/blob/master/research/object_detection/box_coders/faster_rcnn_box_coder.py上的框编码器。为什么将这些比例因子设置为 [10,10,5,5]？原论文没有对此进行解释。我怀疑它必须为位置误差的 4 个分量（tx、ty、tw、th）分配不同的权重，或者解决一些数值稳定性问题，但我想得到确认。谢谢

尝试在 MNIST 数据集上运行 CNN 示例，批量大小 = 64，通道 = 1，n_h = 28，n_w = 28，n_iters = 1000。程序运行前 500 次交互，然后给出上述错误。论坛上已经讨论了相同的主题，例如：主题 1 和主题 2，但它们都不能帮助我识别以下代码中的错误：

class CNN_MNIST(nn.Module):
def __init__(self):
    super(CNN_MNIST,self).__init__()

    # convolution layer 1
    self.cnn1 = nn.Conv2d(in_channels=1, out_channels= 32, kernel_size=5,
                          stride=1,padding=2)

    # ReLU activation 
    self.relu1 = nn.ReLU()

    # maxpool 1
    self.maxpool1 = nn.MaxPool2d(kernel_size=2,stride=2)

    # convolution 2
    self.cnn2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=5,
                          stride=1,padding=2)

    # ReLU activation 
    self.relu2 = nn.ReLU()

    # maxpool 2
    self.maxpool2 = nn.MaxPool2d(kernel_size=2,stride=2)

    # fully connected 1
    self.fc1 = nn.Linear(7*7*64,1000)
    # …

我正在尝试训练 cnn-lstm 模型，我的样本图像大小是 640x640。

我有 GTX 1080 ti 11GB。

我正在使用带有张量流后端的 Keras。

这是模型。

img_input_1 = Input(shape=(1, n_width, n_height, n_channels))

conv_1 = TimeDistributed(Conv2D(96, (11,11), activation='relu', padding='same'))(img_input_1)

pool_1 = TimeDistributed(MaxPooling2D((3,3)))(conv_1)

conv_2 = TimeDistributed(Conv2D(128, (11,11), activation='relu', padding='same'))(pool_1)

flat_1 = TimeDistributed(Flatten())(conv_2)

dense_1 = TimeDistributed(Dense(4096, activation='relu'))(flat_1)

drop_1 = TimeDistributed(Dropout(0.5))(dense_1)

lstm_1 = LSTM(17, activation='linear')(drop_1)

dense_2 = Dense(4096, activation='relu')(lstm_1)

dense_output_2 = Dense(1, activation='sigmoid')(dense_2)

model = Model(inputs=img_input_1, outputs=dense_output_2)

op = optimizers.Adam(lr=0.00001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.001)

model.compile(loss='mean_absolute_error', optimizer=op, metrics=['accuracy'])

model.fit(X, Y, epochs=3, batch_size=1)

现在使用这个模型，我只能在图像大小调整为 60x60 时使用训练数据，任何更大的尺寸都会耗尽 GPU 内存。

我想使用尽可能大的尺寸，因为我想保留尽可能多的歧视性信息。（y 标签将是 …

我正在为 Food-101 数据集（包含 101 个类别和每个类别 1k 个图像的图像数据集）构建一个分类器。我的方法是使用 Keras 并通过 ResNet50（来自 imagenet 的权重）进行迁移学习。

训练模型时，训练精度在几个 epoch 中得到了适度的提高（30%-->45%），但验证精度基本上保持在 0.9-1.0%。我尝试过简化、交换优化器、减少和增加隐藏层中的单元、删除所有图像增强以及在flow_from_directory().

当我查看模型在验证集上做出的预测时，它始终是同一类。

我的感觉是，该模型并没有严重过度拟合，无法解释验证准确性的变化。

任何提高验证准确性的建议将不胜感激。

作为参考，以下是相关代码片段：

datagen = ImageDataGenerator(rescale=1./255, validation_split=0.2)

train_datagen = datagen.flow_from_directory('data/train/', seed=42, class_mode='categorical', subset='training', target_size=(256,256))
# prints "60603 images belonging to 101 classes"
val_datagen = datagen.flow_from_directory('data/train/', seed=42, class_mode='categorical', subset='validation', target_size=(256,256)) 
# prints "15150 images belonging to 101 classes"

train_steps = len(train_datagen) #1894
val_steps = len(val_datagen) #474
classes = len(list(train_datagen.class_indices.keys())) #101

conv_base = ResNet50(weights='imagenet', include_top=False, pooling='avg', input_shape=(256, 256, 3))

from keras.layers import GlobalAveragePooling2D …