标签: training-data

我正在通过推文训练分类器以进行情绪分析.

代码如下:

df = pd.read_csv('Trainded Dataset Sentiment.csv', error_bad_lines=False)
df.head(5)

#TWEET
X = df[['SentimentText']].loc[2:50000]
#SENTIMENT LABEL
y = df[['Sentiment']].loc[2:50000]

#Apply Normalizer function over the tweets
X['Normalized Text'] = X.SentimentText.apply(text_normalization_sentiment)
X = X['Normalized Text']

规范化后,数据框如下所示:

X_train, X_test, y_train, y_test =
sklearn.cross_validation.train_test_split(X, y, 
test_size=0.2, random_state=42)

#Classifier
vec = TfidfVectorizer(min_df=5, max_df=0.95, sublinear_tf=True,
                      use_idf=True, ngram_range=(1,2))
svm_clf = svm.LinearSVC(C=0.1)
vec_clf = Pipeline([('vectorizer', vec), ('pac', svm_clf)])
vec_clf.fit(X_train, y_train) #Problem
joblib.dump(vec_clf, 'svmClassifier.pk1', compress=3)

它失败并出现以下错误:

AttributeError: 'list' object has no attribute 'lower'

Full Traceback:
--------------------------------------------------------------------------- AttributeError                            Traceback (most recent …

我正在使用 pytorch 来训练我的 CNN 网络。我想绘制训练和验证损失曲线以可视化模型性能。如何绘制两条曲线？

我有下面的代码

# create a function (this my favorite choice)
def RMSELoss(predicted,target):
    return torch.sqrt(torch.mean((predicted-target)**2))

criterion = RMSELoss

# loss = torch.sqrt(criterion(x, y))
optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)
epochs = 300

n_total_steps = len(train_dataset)

trainingEpoch_loss = []
validationEpoch_loss = []

for epoch in range(epochs):
    step_loss = []
    model.train()
    for i, data in enumerate(train_dataset):
        feature,target = data['data'].type(torch.FloatTensor),torch.tensor(data['target']).type(torch.FloatTensor)
         
        # Clear the gradients
        optimizer.zero_grad()
        # Forward Pass
        outputs = model(feature)
        # Find the Loss
        training_loss = criterion(outputs, target)
        # Calculate gradients …

在开发神经网络时，通常将训练数据划分为训练数据集、测试数据集和保留数据集（许多人分别将这些数据集称为训练数据集、验证数据集和测试数据集。相同的东西，不同的名称）。许多人建议根据测试数据集中的性能选择超参数。我的问题是：为什么？为什么不最大化训练数据集中超参数的性能，并在我们通过测试数据集中的性能下降检测到过度拟合时停止训练超参数？由于训练通常大于测试，与测试数据集上的训练超参数相比，这不会产生更好的结果吗？

2016 年 7 月 6 日更新

术语发生变化，以匹配下面的评论。在本文中，数据集现在被称为“训练”、“验证”和“测试” 。我不使用测试数据集进行训练。我正在使用 GA 来优化超参数。在外部 GA 训练过程的每次迭代中，GA 都会选择一个新的超参数集，在训练数据集上进行训练，并在验证和测试数据集上进行评估。GA 调整超参数以最大限度地提高训练数据集中的准确性。当检测到网络过拟合（在验证数据集中）时，迭代内的网络训练将停止，而当检测到超参数过拟合时（再次在验证中），外部 GA 训练过程将停止。结果是针对训练数据集进行了伪优化的超参数。问题是：为什么许多来源（例如https://www.cs.toronto.edu/~hinton/absps/JMLRdropout.pdf，第 B.1 节）建议优化验证集上的超参数，而不是训练集上的超参数？引用 Srivasta、Hinton 等人（上面的链接）：“在验证集上调整超参数，以便产生最佳验证错误...... ”

我正在训练一个具有多重损失的网络，并且使用生成器创建数据并将数据馈送到我的网络中。

我已经检查了数据的结构，它总体上看起来不错，并且在大多数情况下也几乎按照预期进行了训练，但是在几乎每次随机时期，每个预测的训练损失突然从

# End of epoch 3
loss: 2.8845 

到

# Beginning of epoch 4
loss: 1.1921e-07

我认为这可能是数据，但是，据我所知，数据通常很好，而且更加可疑，因为这将发生在随机时期（可能是因为在 SGD 期间选择了随机数据点？）但会持续存在在剩下的训练中。就像在 epoch 3 时，训练损失减少到1.1921e-07那么它将在 epoch 4、epoch 5 等中继续这样。

但是，有时它到达 epoch 5 并且还没有这样做，然后可能会在 epoch 6 或 7 进行。

在数据之外是否有任何可行的原因可能导致这种情况？一些模糊的数据点会导致如此快吗？

谢谢

编辑：

结果：

300/300 [==============================] - 339s - loss: 3.2912 - loss_1: 1.8683 - loss_2: 9.1352 - loss_3: 5.9845 - 
val_loss: 1.1921e-07 - val_loss_1: 1.1921e-07 - val_loss_2: 1.1921e-07 - val_loss_3: 1.1921e-07

此后的下一个时期都有训练损失 1.1921e-07

我使用张量流 api (2.0) 加载图像，如下所示：

def load(image_file):
  image = tf.io.read_file(image_file)
  image = tf.image.decode_jpeg(image)

现在我有了这个对象，我想显示这个图像，我可以简单地使用 matplotlib.pyplot，这很有效。

plt.figure()
plt.imshow(re/255.0)
plt.show()

然而，从一开始就用 OpenCV2 尝试这个是有问题的，大多数示例来自 1.0，基于 .eval() 会话的 numpy 转换建议。一种方法是首先将张量流对象转换为 numpy，这是 API 文档中执行此操作的函数：

TensorFlow
API r2.0
TensorFlow Core 2.0a
Python
tf.make_ndarray
Create a numpy ndarray from a tensor.

我不明白为什么这不起作用，我得到了许多错误，而我只想做一些简单的事情，然后使用一些开放的 cv2 函数，如重新映射、调整大小等：

文件“C:\Python\Python37\lib\site-packages\tensorflow\python\eager\def_function.py”，第 426 行，调用中 self._initialize(args, kwds, add_initializers_to=initializer_map) 文件“C:\Python\Python37\lib\site-packages\tensorflow\python\eager\def_function.py”，第 370 行，在 _initialize *args, **kwds 中） ) 文件“C:\Python\Python37\lib\site-packages\tensorflow\python\eager\function.py”，第 1313 行，在 _get_concrete_function_internal_garbage_collected graph_function, _, _ = self._maybe_define_function(args, kwargs) 文件“C: \Python\Python37\lib\site-packages\tensorflow\python\eager\function.py”，第 1580 行，在 _maybe_define_function graph_function = self._create_graph_function(args, kwargs) …

我有一个非常不平衡的数据集，我需要在此基础上构建一个模型来解决分类问题。该数据集有大约 30000 个样本，其中大约 1000 个样本被标记为\xe2\x80\x941\xe2\x80\x94，其余为 0。我通过以下几行构建模型：

X_train=training_set\ny_train=target_value\nmy_classifier=GradientBoostingClassifier(loss=\'deviance\',learning_rate=0.005)\nmy_model = my_classifier.fit(X_train, y_train)\n

由于这是一个不平衡的数据，因此像上面的代码一样简单地构建模型是不正确的，所以我尝试使用类权重，如下所示：

class_weights = compute_class_weight(\'balanced\',np.unique(y_train), y_train)\n

现在，我不知道如何使用 class_weights（基本上包括 0.5 和 9.10 值）来训练和构建模型GradientBoostingClassifier。

任何想法？我如何使用加权类或其他技术处理这些不平衡的数据？

我正在尝试使用 tensorflow==1.13.1 在多个 GPU 上训练Grover 的鉴别器模型。该模型的默认配置假设在多个 TPU 上进行训练，并被证明适用于具有多个 TPU 的系统。然而，由于 TPU 不可用，我试图通过使用 tensorflow 分布策略更改模型的运行配置来将训练分布在多个 GPU 上，如下所示：

dist_strategy = tf.contrib.distribute.MirroredStrategy(
        num_gpus=8,
        cross_device_ops=AllReduceCrossDeviceOps('nccl', num_packs=8),
        # cross_device_ops=AllReduceCrossDeviceOps('hierarchical_copy')
)

然后我尝试更改 GPU 的运行配置，如下所示：

 run_config = RunConfig(
        train_distribute=dist_strategy,
        eval_distribute=dist_strategy,
        log_step_count_steps=log_every_n_steps,
        model_dir=FLAGS.output_dir,
        save_checkpoints_steps=FLAGS.iterations_per_loop)

它似乎正确分配数据（我可以通过 GPU 使用情况和其他指标来判断），但是在收集梯度时它失败并出现以下错误：

ValueError: You must specify an aggregation method to update a MirroredVariable in Replica Context.

但是，我在分发策略中提供了跨设备操作。对我来说，最终的解决方案似乎是使用分布策略代码修改损失函数，但我认为它应该可以与 TPU 一起使用。任何帮助表示高度赞赏！

我按照本教程使用fit_generator()Keras 方法即时生成数据，以训练我的神经网络模型。

我使用keras.utils.Sequence类创建了一个生成器。调用fit_generator()是：

history = model.fit_generator(generator=EVDSSequence(images_train, TRAIN_BATCH_SIZE, INPUT_IMG_DIR, INPUT_JSON_DIR, SPLIT_CHAR, sizeArray, NCHW, shuffle=True),
                              steps_per_epoch=None, epochs=EPOCHS,
                              validation_data=EVDSSequence(images_valid, VALID_BATCH_SIZE, INPUT_IMG_DIR, INPUT_JSON_DIR, SPLIT_CHAR, sizeArray, NCHW, shuffle=True),
                              validation_steps=None,
                              callbacks=callbacksList, verbose=1,
                              workers=0, max_queue_size=1, use_multiprocessing=False)

steps_per_epoch是None，因此每个 epoch 的步数由 Keras__len()__方法计算。

正如上面的链接所说：

在这里，该方法on_epoch_end在每个 epoch 的开始和结束时触发一次。如果shuffle参数设置为True，我们将在每次通过时获得一个新的探索顺序（否则只保留线性探索方案）。

我的问题是该on_epoch_end()方法仅在最开始时被调用，而不会在每个时代结束时被调用。因此，在每个时期，批次顺序始终相同。

我尝试使用np.ceil而不是np.floorin__len__()方法，但没有成功。

你知道为什么on_epoch_end不在每个纪元结束时调用吗？您能告诉我在每个时代结束时（或开始时）调整批次顺序的任何解决方法吗？

非常感谢！

我可以使用此代码计算每个时期后的准确性。但是，我想最后计算每个班级的准确性。我怎样才能做到这一点？我有两个文件夹 train 和 val 。每个文件夹有 7 个不同类别的 7 个文件夹。train 文件夹用于训练。否则 val 文件夹用于测试

  def train_model(model, criterion, optimizer, lr_scheduler, num_epochs=25):
    since = time.time()

    best_model = model
    best_acc = 0.0

    for epoch in range(num_epochs):
        print('Epoch {}/{}'.format(epoch, num_epochs - 1))
        print('-' * 10)

        # Each epoch has a training and validation phase
        for phase in ['train', 'val']:
            if phase == 'train':
                mode='train'
                optimizer = lr_scheduler(optimizer, epoch)
                model.train()  # Set model to training mode
            else:
                model.eval()
                mode='val'

            running_loss = 0.0
            running_corrects = 0

            counter=0
            # …

我试图开发某种方法来在格式之间转换注释，并且很难找到信息，但在这里我有：

这是PASCAL VOC

<width>800</width>
<height>450</height>
<depth>3</depth>
<bndbox>
    <xmin>474</xmin>
    <ymin>2</ymin>
    <xmax>726</xmax> <!-- shape_width = 252  -->
    <ymax>449</ymax> <!-- shape_height = 447 -->
</bndbox>

转换为YOLO 暗网

2 0.750000 0.501111 0.315000 0.993333

注意开头2它是一个类别