小编mdo*_*fe1的帖子

我正在尝试使用gridspec在matplotlib中制作一个图像网格.问题是,我似乎无法摆脱行之间的填充.

这是我对解决方案的尝试.

import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import ImageGrid
import numpy as np
from os import listdir
from os import chdir
from PIL import Image
import matplotlib.gridspec as gridspec

chdir('/home/matthew/Dropbox/Work/writing/'+
    'paper_preperation/jump_figs')
files = listdir('/home/matthew/Dropbox/Work/writing/'+
    'paper_preperation/jump_figs')

images = [Image.open(f) for f in files]


"""
fig = plt.figure()

grid = ImageGrid(fig, 111, # similar to subplot(111)
                nrows_ncols = (2, 5), # creates 2x2 grid of axes
                axes_pad=0.1, # pad between axes in inch.
                )
"""

num_rows = 2
num_cols = 5 …

如果我在 2 个 pod 中运行进程，这些进程通过 tcp 相互通信（通过 Kubernetes 服务相互寻址），并且 pod 被调度到同一节点，通信将通过网络进行，或者 Kubernetes 是否知道使用环回设备？

假设我有一个长时间运行的 Web 服务器来调用 aws api？长时间运行的客户端对象是否安全，或者该对象是否可能会损坏并弄乱我的 Web 服务器？对于具体来说，这样做更好吗？

import boto3

client = boto3.client('elb')

def function():
    do stuff with client

或这个

import boto3

def function():
    client = boto3.client('elb')
    do stuff with client

前一个选项更好，因为我可以在多个函数中重用相同的客户端对象。如果我的上述安全考虑是有效的，后一种选择会更好。

我正在尝试使用 SignalRef 中断 fs2 流。我使用以下命令设置并运行流。流应在switch包含时运行，并在包含false时中断switchtrue

  import cats.effect.IO
  import fs2.Stream
  import fs2.concurrent.SignallingRef

  import scala.concurrent.ExecutionContext
  import scala.concurrent.duration.DurationInt

  implicit val contextShift = IO.contextShift(ExecutionContext.global)
  implicit val timer = IO.timer(ExecutionContext.global)

  val switch: IO[SignallingRef[IO, Boolean]] = SignallingRef[IO, Boolean](false)

  val program: Stream[IO, Unit] = {

      val program: Stream[IO, Unit] =
        Stream
          .repeatEval(IO{
            println(java.time.LocalTime.now)
            println(switch.map(_.get).unsafeRunSync.unsafeRunSync)
          })
          .metered(1.second)

      program
        .interruptWhen(Stream.repeatEval(switch.map(_.get).unsafeRunSync))
    }
  
  program.compile.drain.unsafeRunAsync(() => _)

然后我尝试中断流

switch.map(_.set(true).unsafeRunSync)

然而，这股潮流仍在继续。在标准输出中我看到

15:58:33.048504
false
15:58:34.048760
false
15:58:35.049063
false
15:58:36.049356
false
15:58:37.049615
false

那么显然它没有切换到 true 吗？

我知道Python dicts是无序的,但如果你调用iteritems(),它会返回一个有序的列表.如何确定该列表的顺序？

Keras在训练卷积自动编码器时抛出ResourceExhaustedError.我正在运行Tensorflow后端.这台电脑既有Nvidia Tesla,内存为11 Gbs,Nvidia Quadro也有6 Gbs的内存.似乎Tensorflow正在使用两个GPU？但我对此并不太清楚.这是我正在使用的代码的最小示例.在我的示例中,数据是一个numpy数组维度=(100,1080,1920,1).

from keras.layers import Convolution2D, MaxPooling2D, UpSampling2D, Activation
from keras.models import Sequential
model = Sequential()
model.add(Convolution2D(16, 3, 3, border_mode='same', input_shape=(1080, 1920, 1)))
model.add(Activation('relu'))
model.add(MaxPooling2D((2, 2), border_mode='same'))
model.add(Convolution2D(16, 3, 3, border_mode='same'))
model.add(Activation('relu'))
model.add(UpSampling2D((2, 2)))
model.add(Convolution2D(1, 3, 3, border_mode='same'))
model.add(Activation('relu'))
model.compile(optimizer='adadelta', loss='binary_crossentropy')
model.fit(data, data)

看起来GPU的内存不足.自动编码器有2625个变量.所以这似乎不足以填满视频内存.阵列数据的大小为1600 MB.所以这也不应该填满视频公羊.我猜这个问题与nb_epoch和batch_size有关,但我不清楚这些参数是做什么的.有没有办法改变这些参数来解决我的问题？

我正在寻找像scipy.optimize中存在的l_bfgs_b或tnc方法.有没有人见过这些的实现？

我正在研究 Cats 以完成上述任务。我试着写下面的例子

1. 运行一个不阻塞主线程的IO操作
2. 如果失败则在主线程中抛出异常

import cats.effect.{IO, Async}

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future

val apiCall = Future.successful("I come from the Future!")

val ioa: IO[String] =
  Async[IO].async { cb =>
    import scala.util.{Failure, Success}
    Thread.sleep(1000)
    throw new RuntimeException

    apiCall.onComplete {
      case Success(value) => cb(Right(value))
      case Failure(error) => cb(Left(error))
    }
 }

ioa.unsafeRunAsync(result => result match {
    case Left(result) => throw result
    case Right(_) =>
})

然而，它似乎在这两件事上都失败了。它阻塞主线程，只在子线程中抛出异常。我正在尝试做的可能吗？

因此，我使用 Tensorflow 后端在 Keras 中定义了这个自定义损失函数，以最小化背景提取自动编码器。它应该确保预测 x_hat 不会偏离批次 B0 的预测中值太远。

def ben_loss(x, x_hat):

    B0 = tf_median(tf.transpose(x_hat))
    sigma = tf.reduce_mean(tf.sqrt(tf.abs(x_hat - B0) / 0.4), axis=0)
    # I divide by sigma in the next step. So I add a small float32 to sigma
    # so as to prevent background_term from becoming a nan.
    sigma += 1e-22 
    background_term = tf.reduce_mean(tf.abs(x_hat - B0) / sigma, axis=-1)
    bce = binary_crossentropy(x, x_hat)
    loss = bce + background_term

    return loss

当我尝试使用此损失函数最小化网络时，损失几乎立即变为 NaN。有谁知道为什么会发生这种情况？您可以通过克隆我的存储库并运行此脚本来重现该错误。