//设置package包名称以及导入依赖的类
package fastml4j.classification

import org.nd4s.Implicits._
import org.nd4j.linalg.api.ndarray.INDArray
import org.nd4j.linalg.factory.Nd4j
import fastml4j.optimizer._
import fastml4j.losses._
import org.nd4j.linalg.dataset.DataSet

class SVM(val lambdaL2: Double,
  val alpha: Double = 0.01,
  val maxIterations: Int = 1000,
  val stohasticBatchSize: Int = 100,
  val optimizerType: String = "PegasosSGD",
  val eps: Double = 1e-6) extends ClassificationModel {

  var weights: INDArray = Nd4j.zeros(1)
  var losses: Seq[Double] = Seq[Double]()


  def fit(dataSet: DataSet, initWeights: Option[INDArray] = None) = {

    val optimizer: Optimizer = optimizerType match {
      case "GradientDescent" => new GradientDescent(maxIterations, alpha, eps)
    //  case "GradientDescentDecreasingLearningRate" => new GradientDescentDecreasingLearningRate(maxIterations, alpha, eps)
      case "PegasosSGD" => new PegasosSGD(maxIterations, alpha, eps)
      case _ => throw new Exception("Optimizer %s is not supported".format(optimizerType))
    }

    val (weightsOut, lossesOut) = optimizer.optimize(
      new HingeLoss(lambdaL2),
      initWeights = initWeights.getOrElse(Nd4j.zeros(dataSet.numInputs)),
      dataSet)

    weights = weightsOut
    losses = lossesOut
  }

  def predictClass(inputVector: INDArray): Double = {
    val sign = math.signum((inputVector dot weights.T).sumT[Double])
    if( sign != 0 ) sign else 1.0
  }

  def predict(inputVector:  INDArray): Double = {
    (inputVector dot weights).sumT[Double]
  }


} 

//设置package包名称以及导入依赖的类
package org.dl4scala.examples.misc.embedding

import org.deeplearning4j.nn.conf.NeuralNetConfiguration
import org.deeplearning4j.nn.conf.layers.{EmbeddingLayer, GravesLSTM, RnnOutputLayer}
import org.deeplearning4j.nn.conf.preprocessor.{FeedForwardToRnnPreProcessor, RnnToFeedForwardPreProcessor}
import org.deeplearning4j.nn.multilayer.MultiLayerNetwork
import org.nd4j.linalg.activations.Activation
import org.nd4j.linalg.factory.Nd4j
import org.nd4j.linalg.lossfunctions.LossFunctions

import scala.util.Random


object RNNEmbedding {
  def main(args: Array[String]): Unit = {
    val nClassesIn = 10
    val batchSize = 3
    val timeSeriesLength = 8
    val inEmbedding = Nd4j.create(batchSize, 1, timeSeriesLength)
    val outLabels = Nd4j.create(batchSize, 4, timeSeriesLength)

    val r = new Random(12345)
    (0 until batchSize).foreach{i =>
      (0 until timeSeriesLength).foreach{j =>
        val classIdx = r.nextInt(nClassesIn)
        inEmbedding.putScalar(Array[Int](i, 0, j), classIdx)
        val labelIdx = r.nextInt(4)
        outLabels.putScalar(Array[Int](i, labelIdx, j), 1.0)
      }
    }

    val conf = new NeuralNetConfiguration.Builder()
      .activation(Activation.RELU)
      .list()
      .layer(0, new EmbeddingLayer.Builder().nIn(nClassesIn).nOut(5).build())
      .layer(1, new GravesLSTM.Builder().nIn(5).nOut(7).activation(Activation.SOFTSIGN).build())
      .layer(2, new RnnOutputLayer.Builder(LossFunctions.LossFunction.MCXENT).nIn(7).nOut(4).activation(Activation.SOFTMAX).build())
      .inputPreProcessor(0, new RnnToFeedForwardPreProcessor())
      .inputPreProcessor(1, new FeedForwardToRnnPreProcessor())
      .build()

    val net = new MultiLayerNetwork(conf)
    net.init()

    net.setInput(inEmbedding)
    net.setLabels(outLabels)

    net.computeGradientAndScore()
    System.out.println(net.score())
  }
} 

//设置package包名称以及导入依赖的类
package org.dl4scala.examples.misc.externalerrors

import org.deeplearning4j.nn.conf.layers.DenseLayer
import org.deeplearning4j.nn.conf.{NeuralNetConfiguration, Updater}
import org.deeplearning4j.nn.multilayer.MultiLayerNetwork
import org.deeplearning4j.nn.weights.WeightInit
import org.nd4j.linalg.activations.Activation
import org.nd4j.linalg.factory.Nd4j


object MultiLayerNetworkExternalErrors {
  def main(array: Array[String]): Unit = {
    //Create the model
    val nIn = 4
    val nOut = 3
    Nd4j.getRandom.setSeed(12345)

    val conf = new NeuralNetConfiguration.Builder()
      .seed(12345)
      .activation(Activation.TANH)
      .weightInit(WeightInit.XAVIER)
      .updater(Updater.NESTEROVS)
      .learningRate(0.1)
      .list()
      .layer(0, new DenseLayer.Builder().nIn(nIn).nOut(3).build())
      .layer(1, new DenseLayer.Builder().nIn(3).nOut(3).build())
      .backprop(true).pretrain(false)
      .build()

    val model = new MultiLayerNetwork(conf)
    model.init()

    //Calculate gradient with respect to an external error//Calculate gradient with respect to an external error

    val minibatch = 32
    val input = Nd4j.rand(minibatch, nIn)
    val output = model.output(input) //Do forward pass. Normally: calculate the error based on this

    val externalError = Nd4j.rand(minibatch, nOut)
    val p = model.backpropGradient(externalError) //Calculate backprop gradient based on error array

    //Update the gradient: apply learning rate, momentum, etc
    //This modifies the Gradient object in-place
    val gradient = p.getFirst
    val iteration = 0
    model.getUpdater.update(model, gradient, iteration, minibatch)

    //Get a row vector gradient array, and apply it to the parameters to update the model
    val updateVector = gradient.gradient
    model.params.subi(updateVector)
  }
} 

//设置package包名称以及导入依赖的类
package org.dl4scala.examples.misc

import org.deeplearning4j.nn.conf.NeuralNetConfiguration
import org.deeplearning4j.nn.conf.layers.{DenseLayer, OutputLayer}
import org.deeplearning4j.nn.multilayer.MultiLayerNetwork
import org.deeplearning4j.nn.weights.WeightInit
import org.nd4j.linalg.activations.Activation
import org.nd4j.linalg.factory.Nd4j
import org.nd4j.linalg.lossfunctions.impl.LossMCXENT


object WeightedLossFunctionExample {
  def main(args: Array[String]): Unit = {
    val numInputs = 4
    val numClasses = 3 //3 classes for classification

    // Create the weights array. Note that we have 3 output classes, therefore we have 3 weights
    val weightsArray = Nd4j.create(Array[Double](0.5, 0.5, 1.0))

    val conf = new NeuralNetConfiguration.Builder()
      .activation(Activation.RELU)
      .weightInit(WeightInit.XAVIER)
      .learningRate(0.1)
      .list()
      .layer(0, new DenseLayer.Builder().nIn(numInputs).nOut(5)
        .build())
      .layer(1, new DenseLayer.Builder().nIn(5).nOut(5)
        .build())
      .layer(2, new OutputLayer.Builder()
        .lossFunction(new LossMCXENT(weightsArray))     // *** Weighted loss function configured here ***
        .activation(Activation.SOFTMAX)
        .nIn(5).nOut(numClasses).build())
      .backprop(true).pretrain(false)
      .build()

    //Initialize and use the model as before
    val model = new MultiLayerNetwork(conf)
    model.init()
  }
} 

//设置package包名称以及导入依赖的类
package org.dl4scala.examples.nlp.paragraphvectors.tools

import java.util.concurrent.atomic.AtomicInteger

import lombok.NonNull
import org.deeplearning4j.models.embeddings.inmemory.InMemoryLookupTable
import org.deeplearning4j.models.word2vec.VocabWord
import org.deeplearning4j.text.documentiterator.LabelledDocument
import org.deeplearning4j.text.tokenization.tokenizerfactory.TokenizerFactory
import org.nd4j.linalg.api.ndarray.INDArray
import org.nd4j.linalg.factory.Nd4j
import scala.collection.JavaConverters._


  def documentAsVector(@NonNull document: LabelledDocument): INDArray = {
    val documentAsTokens = tokenizerFactory.create(document.getContent).getTokens.asScala
    val cnt = new AtomicInteger(0)

    for (word <- documentAsTokens) {
      if (vocabCache.containsWord(word)) cnt.incrementAndGet
    }

    val allWords = Nd4j.create(cnt.get, lookupTable.layerSize)
    cnt.set(0)

    for (word <- documentAsTokens) {
      if (vocabCache.containsWord(word)) allWords.putRow(cnt.getAndIncrement, lookupTable.vector(word))
    }

    val mean = allWords.mean(0)

    mean
  }
} 

//设置package包名称以及导入依赖的类
// import scala.math.Fractional
import org.bytedeco.javacpp.caffe.FloatBlob
import org.nd4s.Implicits._
import org.nd4j.linalg.api.ndarray.INDArray
import org.nd4j.linalg.factory.Nd4j

class FloatNDArray(val data: INDArray) extends java.io.Serializable {

    def scalarDivide(v: Float) {
        data /= v
    }

    def plus(other: FloatNDArray) {
        data += other.data
    }

    def shape: Array[Int] = data.shape()

    def asFloat: Array[Float] = data.data().asFloat()
}

object FloatNDArray {
    def apply(shape: Array[Int]) = {
        new FloatNDArray(Nd4j.zeros(shape : _*))
    }

    def apply(data: Array[Float], shape: Array[Int]) = {
        new FloatNDArray(Nd4j.create(data, shape))
    }

    def plus(a: FloatNDArray, b: FloatNDArray) = {
        new FloatNDArray(a.data + b.data)
    }

    def getFloatBlobShape(blob: FloatBlob): Array[Int] = {
        val numAxes = blob.num_axes()
        numAxes match {
            case 0 => Array(1)
            case 1 => Array(1, blob.shape.get(0))
            case n => {
                val shape = new Array[Int](numAxes)
                for (k <- 0 to numAxes - 1) {
                    shape(k) = blob.shape.get(k)
                }
                shape                
            }
        }
    }

    def floatBlobToNDArray(blob: FloatBlob): FloatNDArray = {
        val shape = getFloatBlobShape(blob)
        val data = new Array[Float](shape.product)
        blob.cpu_data.get(data)
        FloatNDArray(data, shape)
    }
} 

//设置package包名称以及导入依赖的类
package fastml4j.regression

import fastml4j.losses.OLSLoss
import fastml4j.optimizer.GradientDescent
import org.nd4j.linalg.api.ndarray.INDArray
import org.nd4j.linalg.dataset.DataSet
import org.nd4j.linalg.factory.Nd4j
import org.nd4s.Implicits._


class LinearRegression(val lambdaL2: Double,
  val alpha: Double = 0.01,
  val maxIterations: Int = 1000,
  val stohasticBatchSize: Int = 100,
  val optimizerType: String = "GradientDescent",
  val eps: Double = 1e-6) {

  var weights: INDArray = Nd4j.zeros(1)
  var losses: Seq[Double] = Seq[Double]()

  def fit(dataSet: DataSet, initWeights: Option[INDArray] = None): Unit = {

    val optimizer = optimizerType match {
      case "GradientDescent" => new GradientDescent(maxIterations, alpha, eps)
      case _ => throw new Exception("Optimizer %s is not supported".format(optimizerType))
    }

    val (weightsOut, lossesOut) = optimizer.optimize(new OLSLoss(lambdaL2),
      initWeights.getOrElse(Nd4j.zeros(dataSet.numExamples)),
      dataSet)
    weights = weightsOut
    losses = lossesOut
  }

  def predict(inputVector: INDArray): Double = {
    (inputVector dot weights).sumT[Double]
  }


} 

//设置package包名称以及导入依赖的类
package fastml4j.regression

import org.scalatest._
import org.nd4s.Implicits._
import org.nd4j.linalg.api.ndarray.INDArray
import org.nd4j.linalg.dataset.DataSet
import org.scalatest.Matchers._
import org.nd4j.linalg.factory.Nd4j


class LinearRegressionSuite extends FunSuite with BeforeAndAfter {

  test("Simple test") {
    val coef1 = 1.0
    val coef2 = 0.5

    val x = (0 to   500).map { x => Array(x.toDouble,1.0) }.toArray
    val y = x.map {case Array(x1, x2) => x1 * coef1 + x2 * coef2 + math.random/10 }

    val lr = new LinearRegression(lambdaL2 = 0.0, alpha = 0.000001, eps = 1e-4, maxIterations = 2000)
    lr.fit(new DataSet(x.toNDArray, y.toNDArray), Option(Nd4j.zeros(2)) )

    val weights = lr.weights
    assert(weights.getDouble(0,0) === coef1 +- 1)
    assert(weights.getDouble(0,1) === coef2 +- 1)
  }

} 

//设置package包名称以及导入依赖的类
package scalarank.ranker

import org.nd4j.linalg.api.ndarray.INDArray
import org.nd4j.linalg.factory.Nd4j
import org.nd4s.Implicits._


  def gradientLimits(gradient: INDArray, x: INDArray, function: INDArray => INDArray): Array[Double] = {
    val rand = Nd4j.randn(x.rows, x.columns)
    Array(1e1, 1, 1e-1, 1e-2).map { ? =>
      (0 until x.columns).map { i =>
        val e = Nd4j.zeros(x.columns)
        e(i) = 1.0
        val approximateGradient = (function(x + e * ?) - function(x - e * ?)) / (2*?)
        Math.abs(approximateGradient(i) - gradient(i))
      }.sum
    }
  }

} 

//设置package包名称以及导入依赖的类
package edu.uchicago.cs.ndnn

import org.junit.Assert._
import org.junit.Test
import org.nd4j.linalg.factory.Nd4j


class IndexerTest {

  @Test
  def testGet: Unit = {
    val a = Nd4j.create(Array(Array(3d, 4d, 5d), Array(1d, 6d, 7d)))
    val b = Nd4j.create(Array(2d, 1d)).reshape(2, 1)

    val fetched = Index.get(a, b)
    assertArrayEquals(Array(2, 1), fetched.shape)
    assertEquals(5d, fetched.getDouble(0, 0), 0.001)
    assertEquals(6d, fetched.getDouble(1, 0), 0.001)
  }

  @Test
  def testPut: Unit = {
    val a = Nd4j.createUninitialized(Array(2, 3)).assign(0)
    val b = Nd4j.create(Array(2d, 1d)).reshape(2, 1)
    val value = Nd4j.create(Array(3d, 5d)).reshape(2, 1)

    Index.put(a, b, value)

    assertEquals(3d, a.getDouble(0, 2), 0.001)
    assertEquals(5d, a.getDouble(1, 1), 0.001)
  }
} 

//设置package包名称以及导入依赖的类
package edu.uchicago.cs.ndnn

import org.junit.Assert._
import org.junit.Test
import org.nd4j.linalg.factory.Nd4j

class GraphTest {

  @Test
  def testTrain: Unit = {
    val graph = new Graph(Xavier, new SGD(0.02, 1), new SquareLoss())

    // Setup
    val x = graph.input("x")
    val w = graph.param("W", Array(3, 2))
    val b = graph.param("b", Array(1, 2))(Zero)

    val wx = new DotMul(x, w)
    val add = new Add(wx, b)
    graph.output(add)

    x.set(Nd4j.create(Array(Array(3d, 2d, 1d), Array(5d, 7d, 6d), Array(8d, 2d, 9d), Array(6d, 4d, 1d))))
    graph.expect(Nd4j.create(Array(Array(25d, 31d), Array(79d, 112d), Array(43d, 110d), Array(49d, 54d))))
    var loss = Double.MaxValue
    for (_ <- 0 to 100) {
      loss = graph.train
    }
    
    assertEquals(0, loss, 0.1)
  }

  @Test
  def testTest: Unit = {

    val graph = new Graph(Xavier, new SGD(0.01), new SoftMaxLogLoss())
    val x = graph.input("x")
    val w = graph.param("W", Array(3, 6))

    val wx = new DotMul(x, w)
    val softmax = new SoftMax(wx)
    graph.output(softmax)

    x.set(Nd4j.create(Array(Array(1d, 2d, 3d), Array(2d, 1d, 9d), Array(5d, 2d, 7d))))
    w.set(Nd4j.create(Array(Array(0.1, 0.5, 2.7, 3.1, 0.2, 0.7), Array(1.1, 2.2, 1.3, 4.2, 5.2, 1.9), Array(3.8, 4.7, 2.2, 0.6, 1.9, 1.3))))

    graph.expect(Nd4j.create(Array(2d, 1d, 4d)).reshape(3, -1))

    assertEquals(22.27 / 3, graph.test._1, 0.01)
  }
} 

//设置package包名称以及导入依赖的类
package com.yumusoft.lstmrecommender

import org.scalatest._
import org.nd4j.linalg.factory.Nd4j

class AppSpec extends FlatSpec with Matchers {

  "This project" should "have some tests" in {
    (2 + 2) should be (4)
  }

  it should "Be able to create NDArrays on the CPU or GPU" in {
    val a = Nd4j.ones(2, 2)
    val b = Nd4j.ones(2, 2)

    (a add b).getDouble(0, 0) should be (2.0)
  }
} 

//设置package包名称以及导入依赖的类
package com.cloudera.datascience.dl4j.cnn.examples.caltech256

import java.io.File

import com.cloudera.datascience.dl4j.cnn.Utils
import org.apache.spark.sql.{Row, SparkSession}
import org.deeplearning4j.util.ModelSerializer
import org.nd4j.linalg.dataset.DataSet
import org.nd4j.linalg.factory.Nd4j
import scopt.OptionParser

object ScoreSparkModel {

  private[this] case class Params (modelPath: String = null, dataPath: String = null)

  private[this] object Params {
    def parseArgs(args: Array[String]): Params = {
      val params = new OptionParser[Params]("train an existing model") {
        opt[String]("test")
          .text("the path of the test data")
          .action((x, c) => c.copy(dataPath = x))
        opt[String]("model")
          .text("location of the model")
          .action((x, c) => c.copy(modelPath = x))
      }.parse(args, Params()).get
      require(params.modelPath != null && params.dataPath != null,
        "You must supply the data path and a model path.")
      params
    }
  }

  def main(args: Array[String]): Unit = {
    val param = Params.parseArgs(args)
    val spark = SparkSession.builder().appName("score a model").getOrCreate()
    try {
      val sc = spark.sparkContext
      sc.hadoopConfiguration.set("mapreduce.input.fileinputformat.input.dir.recursive", "true")
      val restorePath = new File(param.modelPath)
      val restored = ModelSerializer.restoreComputationGraph(restorePath)
      val testRDD = spark.read.parquet(param.dataPath)
        .rdd
        .map { case Row(f: Array[Byte], l: Array[Byte]) =>
          new DataSet(Nd4j.fromByteArray(f), Nd4j.fromByteArray(l))
        }
      val eval = Utils.evaluate(restored, testRDD, 16)
      println(Utils.prettyPrintEvaluationStats(eval))

    } finally {
      spark.stop()
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.rikima.dnn

import org.junit.Test
import org.junit.Assert._
import org.nd4j.linalg.factory.Nd4j


class RegressionTestJUnit {
  @Test
  def testND4J(): Unit = {
    val nd = Nd4j.create(Array(1,2,3,4),Array(2,2,2,3));

    val seed = 1256
    Nd4j.getRandom.setSeed(seed)
  }


  @Test
  def testTest() {
    assertEquals(1, 1)
  }
}