breeze:Numerical Processing Library for Scala

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

本帖隐藏的内容

https://github.com/scalanlp/breeze

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏0 回帖

关键词：Processing Numerical processI Process Library

1. package breeze.linalg
   
2. package examples
   
3. 
   
4. import breeze.numerics._
   
5. import breeze.stats.distributions._
   
6. import breeze.benchmark.{MyRunner, BreezeBenchmark}
   
7. import breeze.linalg.DenseVector
   
8. 
   
9. /**
   
10. * Created by dlwh on 8/20/15.
    
11. *
    
12. * Based on code from Ivan Nikolaev
    
13. */
    
14. class GaussMixtureBenchmark extends BreezeBenchmark {
    
15. 
    
16.   val x = DenseVector(5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0)
    
17.   val c = DenseVector(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0)
    
18.   val gamma = 5.0
    
19.   private val n: Int = 1000
    
20. 
    
21.   def timeGMMVectors(reps:Int) = {
    
22.     val denseVectors = IndexedSeq.fill(n)(x)
    
23.     (0 until reps).foreach { i =>
    
24.       GaussMixtureTransform.samplesTransform(denseVectors, c, gamma)
    
25.     }
    
26.   }
    
27. 
    
28.   def timeGMMMat(reps:Int) = {
    
29.     val matrix = DenseMatrix.fill(n, 10)(5.0)
    
30.     (0 until reps).foreach { i =>
    
31.       GaussMixtureTransform.samplesTransform(matrix, c, gamma)
    
32.     }
    
33.   }
    
34. 
    
35.   def timeGMMMatColMajor(reps:Int) = {
    
36.     val matrix = DenseMatrix.fill(10, n)(5.0)
    
37.     (0 until reps).foreach { i =>
    
38.       GaussMixtureTransform.samplesTransformColMajor(matrix, c, gamma)
    
39.     }
    
40.   }
    
41. 
    
42.   def timeCenterMat(reps:Int) = {
    
43.     val matrix = DenseMatrix.fill(n, 10)(5.0)
    
44.     (0 until reps).foreach { i =>
    
45.       matrix(*, ::) - c
    
46.     }
    
47.   }
    
48. 
    
49.   def timeCenterMatColMajor(reps:Int) = {
    
50.     val matrix = DenseMatrix.fill(10, n)(5.0)
    
51.     (0 until reps).foreach { i =>
    
52.       matrix(::, *) - c
    
53.     }
    
54.   }
    
55. 
    
56.   def timeCenterVector(reps:Int) = {
    
57.     val denseVectors = IndexedSeq.fill(n)(x)
    
58.     (0 until reps).foreach { i =>
    
59.       denseVectors.foreach(_ - c)
    
60.     }
    
61.   }
    
62. 
    
63. }
    
64. 
    
65. object GaussMixtureTransform {
    
66.   def sampleTransform(sample: DenseVector[Double], centers: DenseVector[Double], gamma: Double): Double = {
    
67.     val diff: DenseVector[Double] = sample - centers
    
68.     exp(-gamma * (diff dot diff))
    
69.   }
    
70. 
    
71.   def samplesTransform(samples: Iterable[DenseVector[Double]], centers: DenseVector[Double], gamma: Double): Double = {
    
72.     samples.map((sample: DenseVector[Double]) => sampleTransform(sample, centers, gamma)).sum
    
73.   }
    
74. 
    
75.   def samplesTransform(samples: DenseMatrix[Double], centers: DenseVector[Double], gamma: Double): Double = {
    
76.     val diff: DenseMatrix[Double] = samples(*, ::) - centers
    
77.     val prod = diff :*= diff
    
78.     val sum1:DenseVector[Double] = sum(prod, Axis._1) *= (-gamma)
    
79.     val exped = exp(sum1)
    
80.     val sum2 = sum(exped)
    
81.     sum2
    
82. 
    
83. 
    
84. //    sum(exp(sum(diff :*= diff, Axis._1) *= (-gamma)))
    
85.   }
    
86. 
    
87.   def samplesTransformColMajor(samples: DenseMatrix[Double], centers: DenseVector[Double], gamma: Double): Double = {
    
88.     val diff: DenseMatrix[Double] = samples(::, *) - centers
    
89.     val prod = diff :*= diff
    
90.     val sum1 = sum(prod, Axis._0) *= (-gamma)
    
91.     val exped = exp(sum1)
    
92.     val sum2 = sum(exped)
    
93.     sum2
    
94. 
    
95. 
    
96.     //    sum(exp(sum(diff :*= diff, Axis._1) *= (-gamma)))
    
97.   }
    
98. }
    
99. 
    
100. 
     
101. object GaussMixtureBenchmark extends MyRunner(classOf[GaussMixtureBenchmark])

复制代码

1. package breeze.numerics
   
2. 
   
3. import breeze.benchmark.{MyRunner, BreezeBenchmark}
   
4. import breeze.linalg.{softmax, DenseVector}
   
5. import breeze.stats.distributions.Rand
   
6. import spire.syntax.cfor._
   
7. 
   
8. /**
   
9. * Created by dlwh on 10/3/15.
   
10. */
    
11. class SoftmaxBenchmark extends BreezeBenchmark {
    
12.   val dv = DenseVector.rand(5000, Rand.uniform.map(_.toFloat))
    
13. 
    
14.   def timeSoftmaxFloat(reps: Int) = {
    
15.     var sum = 0.0
    
16.     cforRange(0 until reps) { _ =>
    
17.       sum += softmax(dv)
    
18.     }
    
19. 
    
20.     sum
    
21.   }
    
22. 
    
23. }
    
24. 
    
25. object SoftmaxBenchmark extends MyRunner(classOf[SoftmaxBenchmark])

复制代码

1. package breeze.polynomial
   
2. 
   
3. import breeze.benchmark._
   
4. import breeze.linalg.BuildsRandomVectors
   
5. import breeze.stats.distributions._
   
6. 
   
7. import spire.math._
   
8. import spire.math.poly._
   
9. import spire.implicits._
   
10. 
    
11. object DensePolynomialBenchmark extends MyRunner(classOf[DensePolynomialBenchmark])
    
12. 
    
13. class DensePolynomialBenchmark extends BreezeBenchmark with BuildsRandomVectors {
    
14. 
    
15.   def randomPoly(order: Int) = {
    
16.     val uniform = Uniform(0,1)
    
17.     val array = new Array[Double](order)
    
18.     var i=0
    
19.     while (i < order) {
    
20.       array(i) = uniform.draw()
    
21.       i += 1
    
22.     }
    
23.     Polynomial.dense(array)
    
24.   }
    
25. 
    
26.   def timePolyOnDenseVector(reps: Int) = runWith2(reps, { randomPoly(10) }, {randomArray(1024*4) })( (poly, arr) => {
    
27.     poly(arr)
    
28.   })
    
29. 
    
30.   def timePolyOnDenseMatrix(reps: Int) = runWith2(reps, { randomPoly(10) }, {randomMatrix(256,256) })( (poly, arr) => {
    
31.     poly(arr)
    
32.   })
    
33. 
    
34. }

复制代码

1. package breeze.stats.mcmc
   
2. 
   
3. import breeze.benchmark._
   
4. import breeze.stats.distributions._
   
5. import breeze.stats.mcmc._
   
6. 
   
7. import spire.implicits.cfor
   
8. 
   
9. object MetropolisHastingsRunner extends MyRunner(classOf[MetropolisHastingsBenchmark])
   
10. 
    
11. class MetropolisHastingsBenchmark extends BreezeBenchmark {
    
12. 
    
13.   val burnIn = 1024*1024
    
14.   val dropCount = 25
    
15.   val numSamples = 1024*1024
    
16.   val bufferSize = 1024*32
    
17. 
    
18.   val epsilon = 1e-8
    
19.   def likelihood(x: Double) = 2*math.log1p(1+epsilon-x) + 3*math.log1p(x*x*x+epsilon) //Epsilon is present to avoid throwing exceptions in the unlikely event either 0 or 1 is sampled
    
20. 
    
21.   def gaussianJump(x: Double) = Gaussian(x, 1)
    
22.   def gaussianJumpLogProb(start: Double, end: Double) = 0.0 // It would actually be this, but due to symmetry why bother? -math.pow(start-end,2)/2.0
    
23. 
    
24.   def pullAllSamples(m: Rand[Double]) = {
    
25.     var result = 0.0
    
26.     cfor(0)(i => i<numSamples, i => i+1)(i => {
    
27.       result = m.draw()
    
28.     })
    
29.     result
    
30.   }
    
31. 
    
32.   def pullAllSamplesWithWork(m: Rand[Double]) = {
    
33.     var result = 0.0
    
34.     cfor(0)(i => i<numSamples/4, i => i+1)(i => {
    
35.       val x = m.draw()
    
36.       cfor(0)(j => j < 400, j => j+1)(j => {
    
37.         result += math.log(math.exp(x)) / (1+x*x)
    
38.       })
    
39.     })
    
40.     result
    
41.   }
    
42. 
    
43.   def timeMarkovChain(reps: Int) = run(reps) {
    
44.     val m = MarkovChain.metropolisHastings(0.5, gaussianJump _)(likelihood _)
    
45.     pullAllSamples(m)
    
46.   }
    
47. 
    
48.   def timeMarkovChainEquiv(reps: Int) = run(reps) {
    
49.     val m = ArbitraryMetropolisHastings(likelihood _, gaussianJump _, gaussianJumpLogProb _, 0.5, burnIn=0, dropCount=0)
    
50.     pullAllSamples(m)
    
51.   }
    
52. 
    
53.   def timeMetropolisHastings(reps: Int) = run(reps) {
    
54.     val m = ArbitraryMetropolisHastings(likelihood _, (_:Double) =>  Uniform(0,1), gaussianJumpLogProb _, 0.5, burnIn=burnIn, dropCount=dropCount)
    
55.     pullAllSamples(m)
    
56.   }
    
57. 
    
58.   def timeMetropolisHastingsWithWork(reps: Int) = run(reps) {
    
59.     val m = ArbitraryMetropolisHastings(likelihood _, (_:Double) =>  Uniform(0,1), gaussianJumpLogProb _, 0.5, burnIn=0, dropCount=dropCount)
    
60.     pullAllSamplesWithWork(m)
    
61.   }
    
62. 
    
63.   def timeThreadedBufferedWithWork(reps: Int) = run(reps) {
    
64.     val wrapped = ArbitraryMetropolisHastings(likelihood _, (_:Double) =>  Uniform(0,1), gaussianJumpLogProb _, 0.5, burnIn=0, dropCount=dropCount)
    
65.     val m = ThreadedBufferedRand(wrapped, bufferSize=bufferSize)
    
66.     val result = pullAllSamplesWithWork(m)
    
67.     m.stop()
    
68.     result
    
69.   }
    
70. }

复制代码