1. TiledTexture

Subreport: To Run Again On EC2

TiledTexture

Subreport: Logs for com.simiacryptus.ref.lang.ReferenceCountingBase

TiledTexture.scala:72 executed in 0.00 seconds (0.000 gc):

    () => {
      implicit val implicitLog = log
      // First, basic configuration so we publish to our s3 site
      if (Option(s3bucket).filter(!_.isEmpty).isDefined)
        log.setArchiveHome(URI.create(s"s3://$s3bucket/$className/${log.getId}/"))
      log.onComplete(() => upload(log): Unit)
      // Fetch image (user upload prompt) and display a rescaled copy
      loadImages(log, styleUrl, (maxResolution * Math.sqrt(magnification)).toInt).foreach(img => log.p(log.jpg(img, "Input Style")))
      val canvas = new RefAtomicReference[Tensor](null)
  
      // Generates a pretiled image (e.g. 3x3) to display
      def tiledCanvas = {
        val input = canvas.get()
        if (null == input) input else {
          val layer = new ImgTileAssemblyLayer(rowsAndCols, rowsAndCols)
          val result = layer.eval((1 to (rowsAndCols * rowsAndCols)).map(_ => input.addRef()): _*)
          input.freeRef()
          layer.freeRef()
          val tensorList = result.getData
          result.freeRef()
          val tensor = tensorList.get(0)
          tensorList.freeRef()
          tensor
        }
      }
  
      // Tiling layer used by the optimization engine.
      // Expands the canvas by a small amount, using tile wrap to draw in the expanded boundary.
      def viewLayer(dims: Seq[Int]): ImgViewLayer = {
        val paddingX = Math.min(max_padding, Math.max(min_padding, dims(0) * border_factor)).toInt
        val paddingY = Math.min(max_padding, Math.max(min_padding, dims(1) * border_factor)).toInt
        val layer = new ImgViewLayer(dims(0) + paddingX, dims(1) + paddingY, true)
        layer.setOffsetX(-paddingX / 2)
        layer.setOffsetY(-paddingY / 2)
        layer
      }
  
      // Execute the main process while registered with the site index
      val registration = registerWithIndexJPG(() => tiledCanvas)
      try {
        // Display a pre-tiled image inside the report itself
        withMonitoredJpg(() => {
          val tensor = tiledCanvas
          val image = tensor.toImage
          tensor.freeRef()
          image
        }) {
          withMonitoredJpg(() => Option(canvas.get()).map(tensor => {
            val imgViewLayer = viewLayer(tensor.getDimensions)
            val result = imgViewLayer.eval(tensor)
            imgViewLayer.freeRef()
            val tensorList = result.getData
            result.freeRef()
            val data = tensorList.get(0)
            tensorList.freeRef()
            val image = data.toRgbImage
            data.freeRef()
            image
          }).orNull) {
            // Display an additional, non-tiled image of the canvas
            withMonitoredJpg(() => Option(canvas.get()).map(tensor => {
              val image = tensor.toRgbImage
              tensor.freeRef()
              image
            }).orNull) {
              log.subreport("Painting", (sub: NotebookOutput) => {
                paint(
                  contentUrl = initUrl,
                  initUrl = initUrl,
                  canvas = canvas.addRef(),
                  network = new VisualStyleNetwork(
                    styleLayers = List(
                      // We select all the lower-level layers to achieve a good balance between speed and accuracy.
                      VGG19.VGG19_0b,
                      VGG19.VGG19_1a,
                      VGG19.VGG19_1b1,
                      VGG19.VGG19_1b2,
                      VGG19.VGG19_1c1,
                      VGG19.VGG19_1c2,
                      VGG19.VGG19_1c3,
                      VGG19.VGG19_1c4,
                      VGG19.VGG19_1d1,
                      VGG19.VGG19_1d2,
                      VGG19.VGG19_1d3,
                      VGG19.VGG19_1d4
                    ),
                    styleModifiers = List(
                      // These two operators are a good combination for a vivid yet accurate style
                      new GramMatrixEnhancer(),
                      new MomentMatcher()
                    ),
                    styleUrls = Seq(styleUrl),
                    magnification = magnification,
                    viewLayer = viewLayer
                  ),
                  optimizer = new BasicOptimizer {
                    override val trainingMinutes: Int = 60
                    override val trainingIterations: Int = 15
                    override val maxRate = 1e9
                  },
                  aspect = Option(aspectRatio),
                  resolutions = new GeometricSequence {
                    override val min: Double = minResolution
                    override val max: Double = maxResolution
                    override val steps = TiledTexture.this.steps
                  }.toStream.map(_.round.toDouble)
                )(sub)
                null
              })
            }(log)
          }
        }
        null
      } finally {
        canvas.freeRef()
        registration.foreach(_.stop()(s3client, ec2client))
      }
      null
    }

Returns

    { }

Subreport: Painting