标签: loss

我的问题是,PySerial似乎丢失了一些数据包,我不知道为什么.

我有两个python脚本,第一个从文本文件中读取数据并将其写入微控制器,在那里操作数据.然后,微控制器通过不同的串行端口将修改后的数据发送回PC.(澄清一下:我需要两个串口,因为在最终的应用程序中,脚本将在不同的PC上运行.但是,出于测试目的,在一台PC上运行这两个脚本更容易)

所以基本上,我的硬件设置如下:

PC ----(serial port 1)----> microcontroller
   <---(serial port 2)----- 

在将数据写入微控制器后,我希望能够获得一定数量的数据字节.如果我使用终端程序(如HyperTerminal)来监控收到的数据,一切看起来都很好.但是,如果我尝试使用Python脚本读取数据,我只获得预期数据字节的一小部分.

例如:

+--------------------+--------------------+
| with HyperTerminal | with Python script |
+--------------------+--------------------+
| 1:W:00522          | 1:W:00522          |
| 1:W:00532          | 1:W:00532          |
| 1:W:00518          | 1:W:00522          |
| 1:W:00522          | 1:W:00526          |
| 1:W:00522          | 1:W:00514          |
| 1:W:00526          | 1:W:00520          |
| 1:W:00514          | 1:W:00514          |
| 1:W:00520          | 1:W:00522          |
| 1:W:00520          | 1:W:00526          |
| 1:W:00514          | 1:W:00520          |
| 1:W:00516          | 1:W:00526          |
| 1:W:00522 …

当我使用 tensorflow 时，损失突然变成了 nan，就像：

Epoch:  00001 || cost= 0.675003929
Epoch:  00002 || cost= 0.237375346
Epoch:  00003 || cost= 0.204962473
Epoch:  00004 || cost= 0.191322120
Epoch:  00005 || cost= 0.181427178
Epoch:  00006 || cost= 0.172107664
Epoch:  00007 || cost= 0.171604740
Epoch:  00008 || cost= 0.160334495
Epoch:  00009 || cost= 0.151639721
Epoch:  00010 || cost= 0.149983061
Epoch:  00011 || cost= 0.145890004
Epoch:  00012 || cost= 0.141182279
Epoch:  00013 || cost= 0.140914166
Epoch:  00014 || cost= 0.136189088
Epoch:  00015 || cost= 0.133215346
Epoch: …

我正在尝试在 Keras 中创建图像去噪 ConvNet，并且我想创建自己的损失函数。我希望它将噪声图像作为输入并将噪声作为输出。这个损失函数非常类似于 MSE 损失，但这将使我的网络学会去除干净的图像，而不是从输入的噪声图像中去除噪声。

我想用 y 噪声图像、x 干净图像和 R(y) 预测图像来实现损失函数：

我尝试自己制作它，但我不知道如何让丢失的图像访问我的嘈杂图像，因为它一直在变化。

def residual_loss(noisy_img):
  def loss(y_true, y_pred):
    return np.mean(np.square(y_pred - (noisy_img - y_true), axis=-1)
return loss

基本上，我需要做的是这样的：

input_img = Input(shape=(None,None,3))

c1 = Convolution2D(64, (3, 3))(input_img)
a1 = Activation('relu')(c1)

c2 = Convolution2D(64, (3, 3))(a1)
a2 = Activation('relu')(c2)

c3 = Convolution2D(64, (3, 3))(a2)
a3 = Activation('relu')(c3)

c4 = Convolution2D(64, (3, 3))(a3)
a4 = Activation('relu')(c4)

c5 = Convolution2D(3, (3, 3))(a4)
out = Activation('relu')(c5)

model = Model(input_img, out)
model.compile(optimizer='adam', loss=residual_loss(input_img))

但如果我尝试这个，我会得到：

 IndexError: tuple …

我试图通过特征预测价格。我选择了一个非常简单的模型，但它的工作原理很奇怪。损失函数非常高，我看不出问题出在哪里。

这是我的模型：

# define base model
def baseline_model():
    # create model
    model = Sequential()
    model.add(Dense(62, input_dim = 62, kernel_initializer='normal', activation='relu'))
    model.add(Dense(31, kernel_initializer='normal', activation='relu'))
    model.add(Dense(15, kernel_initializer='normal', activation='relu'))
    model.add(Dense(1, kernel_initializer='normal'))
    # Compile model
    model.compile(loss='mean_squared_error', optimizer='adam')
    return model

这就是我准备数据的方式：（一次热，我拆分了所有数据以进行训练和测试）

df = encode_onehot(dataframe, cols=['Shape', 'Cut', 'Color', 'Clarity', 'Polish', 'Symmetry', 'Culet', '\tFluorescence'])

dataset = df.values
X = dataset[1:,4:66]
Y = dataset[1:,2]

X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.25, random_state=42)

最后，培训：

baseline_model().fit(X_train, y_train, epochs=10, batch_size=64)
scores = baseline_model().evaluate(X_test, y_test, verbose=0)
print(baseline_model().summary())

结果非常可悲：

Epoch 1/10
149767/149767 …

我想将欧几里得距离设置为LSTM或RNN的损失函数。

该函数应具有什么输出：float，（batch_size）或（batch_size，时间步长）？

模型输入X_train是（n_samples，时间步长，data_dim）。Y_train具有相同的尺寸。

示例代码：

def euc_dist_keras(x, y):
    return K.sqrt(K.sum(K.square(x - y), axis=-1, keepdims=True))


model = Sequential()
model.add(SimpleRNN(n_units, activation='relu', input_shape=(timesteps, data_dim), return_sequences=True))
model.add(Dense(n_output, activation='linear'))

model.compile(loss=euc_dist_keras, optimizer='adagrad')

model.fit(y_train, y_train, batch_size=512, epochs=10)

因此，我应该在时间步长维度和/或batch_size中平均损失吗？

我知道，从理论上讲，一批网络的损失只是所有单个损失的总和。这反映在用于计算总损耗的Keras代码中。相关的：

            for i in range(len(self.outputs)):
            if i in skip_target_indices:
                continue
            y_true = self.targets[i]
            y_pred = self.outputs[i]
            weighted_loss = weighted_losses[i]
            sample_weight = sample_weights[i]
            mask = masks[i]
            loss_weight = loss_weights_list[i]
            with K.name_scope(self.output_names[i] + '_loss'):
                output_loss = weighted_loss(y_true, y_pred,
                                            sample_weight, mask)
            if len(self.outputs) > 1:
                self.metrics_tensors.append(output_loss)
                self.metrics_names.append(self.output_names[i] + '_loss')
            if total_loss is None:
                total_loss = loss_weight * output_loss
            else:
                total_loss += loss_weight * output_loss

但是，我注意到，当我使用a batch_size=32和a 训练网络时batch_size=64，每个时期的损失值仍然或多或少地相同，只有a~0.05%有所不同。但是，两个网络的准确性都完全相同。因此，从本质上讲，批量大小对网络没有太大影响。

我的问题是，如果我将批处理量加倍，并假设损失确实在被累加，那么损失实际上不应该是以前的两倍，或者至少更大吗？精度保持不变的事实否定了网络可能以更大的批量学习得更好的借口。

无论批次大小如何，损失都大致相同，这一事实使我认为这是平均水平。

我正在尝试将二进制日志损失应用于我创建的朴素贝叶斯 ML 模型。我生成了一个分类预测数据集（yNew）和一个概率数据集（probabilityYes），但无法在对数损失函数中成功运行它们。

简单的 sklearn.metrics 函数给出单个对数损失结果 - 不知道如何解释这个

from sklearn.metrics import log_loss
ll = log_loss(yNew, probabilityYes, eps=1e-15)
print(ll)
.0819....

更复杂的函数为每个“否”返回 2.55，为每个“是”返回 2.50（总共 90 列）-同样，不知道如何解释它

def logloss(yNew,probabilityYes):
epsilon = 1e-15
probabilityYes = sp.maximum(epsilon, probabilityYes)
probabilityYes = sp.minimum(1-epsilon, probabilityYes)

#compute logloss function (vectorised)
ll = sum(yNew*sp.log(probabilityYes) +
            sp.subtract(1,yNew)*sp.log(sp.subtract(1,probabilityYes)))
ll = ll * -1.0/len(yNew)
return ll

print(logloss(yNew,probabilityYes))
2.55352047 2.55352047 2.50358354 2.55352047 2.50358354 2.55352047 .....

我知道问题不可能出在数据集上，因为我见过其他项目使用相同的数据集。这是我的数据预处理代码：

import pandas as pd
dataset = pd.read_csv('political_tweets.csv')
dataset.head()
dataset = pd.read_csv('political_tweets.csv')["tweet"].values
y_train = pd.read_csv('political_tweets.csv')["dem_or_rep"].values

from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(dataset, y_train, test_size=0.1)

max_words = 10000
print(max_words)
max_len = 25

tokenizer = Tokenizer(num_words = max_words, filters='!"#$%&()*+,-./:;<=>?@[\\]^_`{|}~\t\n1234567890', lower=False,oov_token="<OOV>")

tokenizer.fit_on_texts(x_train)
x_train = tokenizer.texts_to_sequences(x_train)
x_train = pad_sequences(x_train, max_len, padding='post', truncating='post')

tokenizer.fit_on_texts(x_test)
x_test = tokenizer.texts_to_sequences(x_test)
x_test = pad_sequences(x_test, max_len, padding='post', truncating='post')

还有我的模型：

model = Sequential([
    Embedding(max_words+1,64,input_length=max_len),
    Bidirectional(GRU(64, return_sequences = True), merge_mode='concat'),
    GlobalMaxPooling1D(),
    Dense(64,kernel_regularizer=regularizers.l2(0.02)),
    Dropout(0.5),
    Dense(1, activation='sigmoid'),

])
model.summary()

model.compile(loss='binary_crossentropy', optimizer=RMSprop(learning_rate=0.0001), …

我是张量流编程的新手。我想在下面的程序中绘制训练准确性、训练损失、验证准确性和验证损失。我在google colab中使用tensorflow版本1.x。代码片段如下。

# hyperparameters
n_neurons = 128  
learning_rate = 0.001  
batch_size = 128
n_epochs = 5
# parameters
n_steps = 32   
n_inputs = 32  
n_outputs = 10   
# build a rnn model
X = tf.placeholder(tf.float32, [None, n_steps, n_inputs])  
y = tf.placeholder(tf.int32, [None])  
cell = tf.nn.rnn_cell.BasicRNNCell(num_units=n_neurons)  
output, state = tf.nn.dynamic_rnn(cell, X, dtype=tf.float32)  
logits = tf.layers.dense(state, n_outputs)  
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=logits)  
loss = tf.reduce_mean(cross_entropy)  
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(loss)  
prediction = tf.nn.in_top_k(logits, y, 1)  
accuracy = tf.reduce_mean(tf.cast(prediction, tf.float32))  
# input data
x_test = x_test.reshape([-1, …

从 YOLOv8 文档中，我不清楚 YOLOv8 训练器类使用哪个损失指标来确定训练运行中保存的最佳损失模型。是基于验证还是训练损失？

具体来说，当我查看 YOLOv8 训练运行的输出时，我没有看到任何元数据表明哪个纪元导致保存在 running/train/weights/best.pt 的最佳损失模型