标签: loss

当文件类型不是flv/mp4/webm时,我需要将所有视频转换为我的视频播放器(在网站中).

当我使用ffmpeg -i filename.mkv -sameq -ar 22050 filename.mp4::

解码MB 22 1,字节流(8786)时出现[h264 @ 0x645ee0]错误

我的观点是,当我需要将文件类型:.mkv和其他(jwplayer不支持)转换为flv/mp4时,我应该做什么,而不会丢失质量.

我只是将sklearn中的日志丢失应用于逻辑回归:http://scikit-learn.org/stable/modules/generated/sklearn.metrics.log_loss.html

我的代码看起来像这样:

def perform_cv(clf, X, Y, scoring):
    kf = KFold(X.shape[0], n_folds=5, shuffle=True)
    kf_scores = []
    for train, _ in kf:
        X_sub = X[train,:]
        Y_sub = Y[train]
        #Apply 'log_loss' as a loss function
        scores = cross_validation.cross_val_score(clf, X_sub, Y_sub, cv=5, scoring='log_loss')
        kf_scores.append(scores.mean())
    return kf_scores

但是,我想知道为什么由此产生的对数损失是负的.我希望它们是正面的,因为在文档中(参见上面的链接),日志丢失乘以-1,以便将其变为正数.

我在这里做错了吗？

保存或恢复时没有错误.权重似乎已正确恢复.

我试图通过遵循karpathy/min-char-rnn.py,sherjilozair/char-rnn-tensorflow和Tensorflow RNN教程来构建我自己的最小字符级RNN .我的脚本似乎按预期工作,除非我尝试恢复/恢复培训.

如果我重新启动脚本并从检查点恢复然后恢复训练,则丢失将始终恢复,就像没有检查点一样(尽管权重已正确恢复).但是,在脚本执行期间,如果我重置图形,启动新会话并恢复,那么我可以按预期继续最小化损失.

我试图在我的桌面(使用GPU)和笔记本电脑(仅限CPU)上运行此操作,两者都在Windows上使用Tensorflow 0.12.

下面是我的代码,我在这里上传了代码+数据+控制台输出:https: //gist.github.com/dk1027/777c3da7ba1ff7739b5f5e89491bef73

import numpy as np
import tensorflow as tf
from tensorflow.python.ops import rnn_cell

class model_input:

    def __init__(self,data_path, batch_size, steps):
        self.batch_idx = 0
        self.data_path = data_path
        self.steps = steps
        self.batch_size = batch_size
        data = open(self.data_path).read()
        data_size = len(data)
        self.vocab = set(data)
        self.vocab_size = len(self.vocab)
        self.vocab_to_idx = {v:i for i,v in enumerate(self.vocab)}
        self.idx_to_vocab = {i:v for i,v in enumerate(self.vocab)}
        c = self.batch_size * self.steps
        #Offset by …

我想在pytorch中编写一个简单的autoencoder并使用BCELoss,但是我得到了NaN,因为它期望目标在0和1之间.有人可以发布一个简单的BCELoss用例吗？

我正在学习神经网络,我在Keras中为UCI机器学习库中的虹膜数据集分类构建了一个简单的网络.我使用了一个带有8个隐藏节点的隐藏层网络.使用Adam优化器的学习率为0.0005,并且运行200个时期.Softmax用于输出,损失为catogorical-crossentropy.我得到以下学习曲线.

正如您所看到的,准确性的学习曲线有很多平坦的区域,我不明白为什么.错误似乎在不断减少,但准确性似乎并没有以同样的方式增加.精确度学习曲线中的平坦区域意味着什么？为什么即使错误似乎在减少,这些区域的准确度也不会增加？

这在培训中是正常的还是我更有可能在这里做错了什么？

dataframe = pd.read_csv("iris.csv", header=None)
dataset = dataframe.values
X = dataset[:,0:4].astype(float)
y = dataset[:,4]

scalar = StandardScaler()
X = scalar.fit_transform(X)

label_encoder = LabelEncoder()
y = label_encoder.fit_transform(y)

encoder = OneHotEncoder()
y = encoder.fit_transform(y.reshape(-1,1)).toarray()

# create model
model = Sequential()
model.add(Dense(8, input_dim=4, activation='relu'))
model.add(Dense(3, activation='softmax'))

# Compile model
adam = optimizers.Adam(lr=0.0005, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
model.compile(loss='categorical_crossentropy',
              optimizer=adam, 
              metrics=['accuracy'])

# Fit the model
log = model.fit(X, y, epochs=200, batch_size=5, validation_split=0.2)

fig = plt.figure()
fig.suptitle("Adam, lr=0.0006, one hidden layer")

ax = fig.add_subplot(1,2,1) …

在keras中,我想自定义我的损失函数,它不仅需要(y_true,y_pred)作为输入,还需要使用网络内层的输出作为输出图层的标签.这张图片显示了网络布局

这里,内部输出是xn,它是一维特征向量.在右上角,输出是xn',这是xn的预测.换句话说,xn是xn'的标签.

虽然[Ax,Ay]传统上称为y_true,而[Ax',Ay']是y_pred.

我想将这两个损失组件合二为一,共同培训网络.

任何想法或想法都非常感谢!

我正在尝试使用tensorflow使用深度卷积神经网络实现简单的性别分类器.我找到了这个模型并实现了它.

def create_model_v2(data):

    cl1_desc = {'weights':weight_variable([7,7,3,96]), 'biases':bias_variable([96])}
    cl2_desc = {'weights':weight_variable([5,5,96,256]), 'biases':bias_variable([256])}
    cl3_desc = {'weights':weight_variable([3,3,256,384]), 'biases':bias_variable([384])}

    fc1_desc = {'weights':weight_variable([240000, 128]), 'biases':bias_variable([128])}
    fc2_desc = {'weights':weight_variable([128,128]), 'biases':bias_variable([128])}
    fc3_desc = {'weights':weight_variable([128,2]), 'biases':bias_variable([2])}

    cl1 = conv2d(data,cl1_desc['weights'] + cl1_desc['biases'])
    cl1 = tf.nn.relu(cl1)
    pl1 = max_pool_nxn(cl1,3,[1,2,2,1])
    lrm1 = tf.nn.local_response_normalization(pl1)

    cl2 = conv2d(lrm1, cl2_desc['weights'] + cl2_desc['biases'])
    cl2 = tf.nn.relu(cl2)
    pl2 = max_pool_nxn(cl2,3,[1,2,2,1])
    lrm2 = tf.nn.local_response_normalization(pl2)

    cl3 = conv2d(lrm2, cl3_desc['weights'] + cl3_desc['biases'])
    cl3 = tf.nn.relu(cl3)
    pl3 = max_pool_nxn(cl3,3,[1,2,2,1])

    fl = tf.contrib.layers.flatten(cl3)

    fc1 = tf.add(tf.matmul(fl, fc1_desc['weights']), fc1_desc['biases'])
    drp1 …

我想要一个具有 3 个回归输出的模型，例如下面的虚拟示例：

import torch

class MultiOutputRegression(torch.nn.Module):

    def __init__(self):
        super(MultiOutputRegression, self).__init__()
        self.linear1 = torch.nn.Linear(1, 10)
        self.linear2 = torch.nn.Linear(10, 10)
        self.linear3 = torch.nn.Linear(3, 3)

    def forward(self, x):
        x = self.linear1(x)
        x = self.linear2(x)
        x = self.linear3(x)
        return x

假设我想训练它执行虚拟任务，例如，给定输入x返回[x, 2x, 3x].

定义标准和损失后，我们可以使用以下数据对其进行训练：

for i in range(1, 100, 2):
    x_train = torch.tensor([i, i + 1]).reshape(2, 1).float()
    y_train = torch.tensor([[j, 2 * j] for j in x_train]).float()
    y_pred = model(x_train)
    # todo: perform training iteration 

第一次迭代的样本数据为：

x_train
tensor([[1.],
        [2.]]) …

我想在Python中实现自定义丢失函数,它应该像这个伪代码一样工作:

aux = | Real - Prediction | / Prediction
errors = []
if aux <= 0.1:
 errors.append(0)
elif aux > 0.1 & <= 0.15:
 errors.append(5/3)
elif aux > 0.15 & <= 0.2:
 errors.append(5)
else:
 errors.append(2000)
return sum(errors)

我开始像这样定义指标:

def custom_metric(y_true,y_pred):
    # y_true:
    res = K.abs((y_true-y_pred) / y_pred, axis = 1)
    ....

但我不知道如何获得if和else的res值.另外我想知道什么必须返回功能.

谢谢

我正在构建一个深度回归网络（CNN）来从图像（7,11）预测（1000,1）目标向量。目标通常由大约90% 的零和仅10%的非零值组成。目标中（非）零值的分布因样本而异（即不存在全局类别不平衡）。

使用均方误差损失，这导致网络仅预测零，我对此并不感到惊讶。

我最好的猜测是编写一个自定义损失函数，它对非零值的错误的惩罚比对零值的预测的惩罚更多。

我尝试了这个损失函数，目的是实现我猜想的可以在上面工作的功能。它是一种均方误差损失，其中非零目标的预测受到的惩罚较小（w=0.1）。

def my_loss(y_true, y_pred):
    # weights true zero predictions less than true nonzero predictions
    w = 0.1
    y_pred_of_nonzeros = tf.where(tf.equal(y_true, 0), y_pred-y_pred, y_pred)
    return K.mean(K.square(y_true-y_pred_of_nonzeros)) + K.mean(K.square(y_true-y_pred))*w

网络能够学习而不会陷入只有零的预测。然而，这个解决方案似乎很不干净。有没有更好的方法来处理此类问题？关于改进自定义损失函数有什么建议吗？欢迎任何建议，先谢谢您！

最好的，卢卡斯