标签: loss

我遇到了HTC Legend(Android 2.2)的烦人问题.没有在Xperia,Galaxy,Nexus等上看到这个问题.

当我在3G连接上启动我的应用程序,获取一些数据,然后进入手机设置并启用WIFI,手机自动获得一个比3G更受欢迎的WIFI连接.麻烦的是,一旦我切换回应用程序,它似乎已经失去了所有的网络连接,无法连接到任何东西.但是,其他应用程序(例如Web浏览器)使用新的Wifi连接没有问题.Ping可以通过手机外壳正常工作.

如果我等待足够长的时间(例如15分钟),网络堆栈似乎会自动修复,我的应用程序可以再次建立网络连接.当然,这种延迟是不可接受的.

有没有办法以编程方式重新启动网络堆栈？我每次都创建一个新的java.net.HttpURLConnection,但是一旦获得了WIFI,它仍然会超时.

谢谢

码:

byte[] response = null;
    HttpURLConnection connection = null;
    int responseCode = -1;

    // check the cache first
    String readyResponse = ResponseCache.getInstance().get(getUrl());
    if (readyResponse != null) {
        Log.d(LOG_TAG, "Returning CACHED server response for " + getUrl());
        return readyResponse.getBytes();
    }

    try {

        URL url = new URL(getUrl());
        Log.i(LOG_TAG, "Sending Request: " + url.toExternalForm());

        connection = (HttpURLConnection) url.openConnection();
        connection.setUseCaches(false);
        connection.setDoOutput(true); 
        connection.setDoInput(true);
        connection.setConnectTimeout(ApplicationConfiguration.HTTP_CONNECT_TIMEOUT);
        connection.setReadTimeout(ApplicationConfiguration.HTTP_READ_TIMEOUT);

        if (BuildType.getHTTPMethod() == BuildType.METHOD_GET)
        {
            connection.setRequestMethod("GET");
        }
        else
        {
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded"); …

我有反思的问题.我决定使用反射创建一个SQL查询生成器.我创建了自己的注释来确定可以使用哪些类,可以存储哪些属性等.代码按照我的意愿工作,但问题在于使用此项目作为其他人的依赖.

我有另一个使用OJDBC的项目,我试图使用我的库来生成基于类的查询.但是,当我从我的ojdbc项目传递一个类时,所有类信息都丢失了,该类显示为java.lang.Class,甚至注释信息也丢失了.有谁知道为什么会这样？

private static <T> void appendTableName(Class<T> cls) throws NotStorableException {
    Storable storable = cls.getAnnotation(Storable.class);
    String tableName = null;
    if (storable != null) {
        if ((tableName = storable.tableName()).isEmpty())
            tableName = cls.getSimpleName();
    } else {    
        throw new NotStorableException(
                "The class you are trying to persist must declare the Storable annotaion");
    }
    createStatement.append(tableName.toUpperCase());
}

在cls.getAnnotation(Storable.class)当下面的类传递给它正在失去信息

package com.fdm.ojdbc;

import com.fdm.QueryBuilder.annotations.PrimaryKey;
import com.fdm.QueryBuilder.annotations.Storable;

@Storable(tableName="ANIMALS")
public class Animal {

@PrimaryKey
private String name;

public String getName() {
    return name;
}

public void setName(String …

我已经建立了一个用于图像分割的Keras模型(U-Net).然而,在我的样本中,一些错误分类(区域)并不重要,而其他错误分类是至关重要的,所以我想为它们分配更高权重的损失函数.为了使事情进一步复杂化,我希望一些错误分类(1级而不是2级)具有非常高的惩罚,而反向(2级而不是1)不应该受到如此大的惩罚.

我看到它的方式,我需要使用(在所有像素)加权分类crossentropy的总和,但我能找到的最好是这样:

def w_categorical_crossentropy(y_true, y_pred, weights):
    nb_cl = len(weights)
    final_mask = K.zeros_like(y_pred[:, 0])
    y_pred_max = K.max(y_pred, axis=1)
    y_pred_max = K.reshape(y_pred_max, (K.shape(y_pred)[0], 1))
    y_pred_max_mat = K.cast(K.equal(y_pred, y_pred_max), K.floatx())
    for c_p, c_t in product(range(nb_cl), range(nb_cl)):
        final_mask += (weights[c_t, c_p] * y_pred_max_mat[:, c_p] * y_true[:, c_t])
    return K.categorical_crossentropy(y_pred, y_true) * final_mask

然而,这个代码只适用于单个预测,而我对Keras内部工作的知识缺乏(并且它的数学方面并没有好多少).任何人都知道如何适应它,甚至更好,是否有适合我的情况的现成的损失功能？

我会很感激一些指点.

编辑:我的问题类似于如何在Keras中逐点分类的交叉熵损失？,除了我想使用加权分类交叉熵.

是否可以model.loss在回调中进行设置而无需model.compile(...)在之后进行重新编译（因为自此优化器状态被重置），而只是重新编译model.loss，例如：

class NewCallback(Callback):

        def __init__(self):
            super(NewCallback,self).__init__()

        def on_epoch_end(self, epoch, logs={}):
            self.model.loss=[loss_wrapper(t_change, current_epoch=epoch)]
            self.model.compile_only_loss() # is there a version or hack of 
                                           # model.compile(...) like this?

要使用关于stackoverflow的先前示例进行更多扩展：

要实现取决于历元数的损失函数，例如（如在这个stackoverflow问题中）：

def loss_wrapper(t_change, current_epoch):
    def custom_loss(y_true, y_pred):
        c_epoch = K.get_value(current_epoch)
        if c_epoch < t_change:
            # compute loss_1
        else:
            # compute loss_2
    return custom_loss

其中“ current_epoch”是使用回调更新的Keras变量：

current_epoch = K.variable(0.)
model.compile(optimizer=opt, loss=loss_wrapper(5, current_epoch), 
metrics=...)

class NewCallback(Callback):
    def __init__(self, current_epoch):
        self.current_epoch = current_epoch

    def on_epoch_end(self, epoch, logs={}):
        K.set_value(self.current_epoch, epoch) …

我可以使用此代码计算每个时期后的准确性。但是，我想最后计算每个班级的准确性。我怎样才能做到这一点？我有两个文件夹 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
            # …

我需要在张量流中最小化KL损失.

我尝试这个函数tf.contrib.distributions.kl(dist_a,dist_b,allow_nan = False,name = None)但未实现.

我尝试手动实现它:

def kl_divergence(p,q):
    return p* tf.log(p/q)+(1-p)*tf.log((1-p)/(1-q))

是正确的？

我有不平衡的training数据集,这就是为什么我建立自定义 weighted categorical cross entropy loss功能.但问题是我的validation设置是平衡的,我想使用常规的分类交叉熵损失.那么我可以为Keras中的验证集传递不同的损失函数吗？我指的是用于培训的受损者和用于验证集的常规用品？

def weighted_loss(y_pred, y_ture):
 '
 '
 '


return loss

model.compile(loss= weighted_loss, metric='accuracy')

我想使用自定义损失函数训练模型，为此，我需要在以下方法中将张量转换为 numpy 数组：

def median_loss_estimation(y_true, y_predicted):
    a = y_predicted.numpy()

但我有这个错误：

AttributeError: 'Tensor' object has no attribute 'numpy'

为什么？如何将张量转换为 numpy 数组？

我有以下问题：

我在 Keras 中有一个自动编码器，并对其进行了几个时期的训练。训练概览显示验证 MAE 为 0.0422，MSE 为 0.0024。但是，如果我随后调用 network.predict 并手动计算验证错误，我会得到 0.035 和 0.0024。

人们会认为我对 MAE 的手动计算完全不正确，但奇怪的是，如果我使用恒等模型（仅输出您输入的内容）并使用它来评估预测值，则会返回与我的手工计算。代码如下：

input = Input(shape=(X_train.shape[1], ))
encoded = Dense(50, activation='relu', activity_regularizer=regularizers.l1(10e-5))(input)
encoded = Dense(50, activation='relu', activity_regularizer=regularizers.l1(10e-5))(encoded)
encoded = Dense(50, activation='relu', activity_regularizer=regularizers.l1(10e-5))(encoded)
decoded = Dense(50, activation='relu', activity_regularizer=regularizers.l1(10e-5))(encoded)
decoded = Dense(50, activation='relu', activity_regularizer=regularizers.l1(10e-5))(decoded)
decoded = Dense(X_train.shape[1], activation='sigmoid')(decoded)
network = Model(input, decoded)

# sgd = SGD(lr=8, decay=1e-6)
# network.compile(loss='mean_squared_error', optimizer='adam')
network.compile(loss='mean_absolute_error', optimizer='adam', metrics=['mse'])

# Fitting the data
network.fit(X_train, X_train, epochs=2, batch_size=1, shuffle=True, validation_data=(X_valid, X_valid),
            callbacks=[EarlyStopping(monitor='val_loss', min_delta=0.00001, patience=20, verbose=0, …

我正在尝试学习结合 VGG 和Adrian Ung Triplet Loss的 Paris6k 图像的嵌入。问题是，经过少量迭代后，在第一个 epoch 中，损失变为 nan，然后准确率和验证准确率增长到 1。

我已经尝试过降低学习率、增加批量大小（由于内存的原因仅增加到 16）、更改优化器（Adam 和 RMSprop）、检查数据集上是否有 None 值、将数据格式从“float32”更改为“ float64'，为它们添加一点偏差并简化模型。

这是我的代码：

base_model = VGG16(include_top = False, input_shape = (512, 384, 3))
input_images = base_model.input
input_labels = Input(shape=(1,), name='input_label')

embeddings = Flatten()(base_model.output)
labels_plus_embeddings = concatenate([input_labels, embeddings])

model = Model(inputs=[input_images, input_labels], outputs=labels_plus_embeddings)

batch_size = 16
epochs = 2
embedding_size = 64

opt = Adam(lr=0.0001)

model.compile(loss=tl.triplet_loss_adapted_from_tf, optimizer=opt, metrics=['accuracy'])

label_list = np.vstack(label_list)

x_train = image_list[:2500]
x_val = image_list[2500:]

y_train = label_list[:2500]
y_val = label_list[2500:] …