accelerate-kullback-liebler 0.1.1.0 → 0.1.2.0

raw patch · 6 files changed

+51/−6 lines, 6 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• CHANGELOG.md +4/−0
• README.md +2/−1
• accelerate-kullback-liebler.cabal +1/−1
• bench/Bench.cpphs +8/−0
• src/Data/Array/Accelerate/KullbackLiebler.hs +26/−0
• test/Spec.cpphs +10/−4

@@ -1,5 +1,9 @@ # accelerate-kullback-liebler +## 0.1.2.0++  * Add `f`-divergence, `alpha`-divergence, Hellinger distance+ ## 0.1.1.0    * Add `scale` function

@@ -1,3 +1,4 @@ # accelerate-kullback-liebler -Kullback-Liebler divergence on arrays.+Kullback-Liebler divergence, Hellinger distance, alpha-divergence, and+f-divergence on arrays.

@@ -1,6 +1,6 @@ cabal-version:   2.0 name:            accelerate-kullback-liebler-version:         0.1.1.0+version:         0.1.2.0 license:         BSD3 license-file:    LICENSE copyright:       Copyright: (c) 2019-2020 Vanessa McHale

@@ -26,13 +26,17 @@                   bgroup "GPU"                       [ bench "K-L (1e7)" $ nf (kullbackLieblerGPU ps) qs                       , bench "entropy (1e7)" $ nf entropyGPU ps+                      , bench "K-L (1e7) (scaled)" $ nf (kullbackLieblerGPUScaled ps) qs+                      , bench "entropy (1e7) (scaled)" $ nf entropyGPUScaled ps                       ]                 , bgroup "CPU" #else                   bgroup "CPU" #endif                       [ bench "K-L (1e7)" $ nf (kullbackLieblerCPU ps) qs+                      , bench "K-L (1e7) (scaled)" $ nf (kullbackLieblerCPUScaled ps) qs                       , bench "entropy (1e7)" $ nf entropyCPU ps+                      , bench "entropy (1e7) (scaled)" $ nf entropyCPUScaled ps                       ]                 ] @@ -40,8 +44,12 @@           distEnv = randDist (A.Z A.:. 10000000) #ifdef ACCELERATE_GPU           kullbackLieblerGPU ps qs = the $ GPU.run $ kullbackLiebler ps qs+          kullbackLieblerGPUScaled ps qs = the $ GPU.run $ kullbackLiebler (scale ps) (scale qs)           entropyGPU = the . GPU.run . entropy+          entropyGPUScaled = the . GPU.run . entropy . scale #endif           -- TODO: runQ           kullbackLieblerCPU ps qs = the $ CPU.run $ kullbackLiebler ps qs+          kullbackLieblerCPUScaled ps qs = the $ CPU.run $ kullbackLiebler (scale ps) (scale qs)           entropyCPU = the . CPU.run . entropy+          entropyCPUScaled = the . CPU.run . entropy . scale

@@ -5,9 +5,35 @@                                              , entropy                                              , dropZeroes                                              , scale+                                             , hellinger+                                             , fDivergence+                                             , alphaDivergence                                              ) where  import qualified Data.Array.Accelerate as A++-- | \( D_f(p \| q) = \displaystyle\int p(x) f\left(\frac{p(x)}{q(x)}\right) dx \)+--+-- @since 0.1.2.0+fDivergence :: (A.Floating e) => (A.Exp e -> A.Exp e) -- ^ \(f\)+            -> A.Acc (A.Vector e)+            -> A.Acc (A.Vector e)+            -> A.Acc (A.Scalar e)+fDivergence f ps qs = A.sum (A.zipWith (\p q -> p * f (p / q)) ps qs)++-- | \( D^{(\alpha)}(p\| q) = \frac{4}{1 - \alpha^2}\left(1 - \displaystyle\int p(x)^{\frac{1-\alpha}{2}} q(x)^{\frac{1+\alpha}{2}} dx\right)\)+-- for \( \alpha \neq \pm 1\)+--+-- @since 0.1.2.0+alphaDivergence :: A.Floating e => A.Exp e -> A.Acc (A.Vector e) -> A.Acc (A.Vector e) -> A.Acc (A.Scalar e)+alphaDivergence α ps qs = A.map (\x -> (4 / (1 - α ** 2)) * (1 - x)) integrand+    where integrand = A.sum (A.zipWith (\p q -> p ** ((1 - α)/2) * q ** ((1 + α)/2)) ps qs)++-- | Hellinger distance+--+-- @since 0.1.2.0+hellinger :: (A.Floating e) => A.Acc (A.Vector e) -> A.Acc (A.Vector e) -> A.Acc (A.Scalar e)+hellinger ps qs = A.map (A.sqrt . (2*)) $ A.sum (A.zipWith (\p q -> (A.sqrt p - A.sqrt q) ** 2) ps qs)  -- | Assumes input is nonzero kullbackLiebler :: (A.Floating e) => A.Acc (A.Vector e) -> A.Acc (A.Vector e) -> A.Acc (A.Scalar e)

@@ -5,7 +5,7 @@  import           Control.Composition                   ((.$)) import qualified Data.Array.Accelerate                 as A-import           Data.Array.Accelerate.KullbackLiebler (kullbackLiebler, scale)+import           Data.Array.Accelerate.KullbackLiebler (hellinger, kullbackLiebler, scale) import qualified Data.Array.Accelerate.LLVM.Native     as CPU #ifdef ACCELERATE_GPU import qualified Data.Array.Accelerate.LLVM.PTX        as GPU@@ -30,18 +30,24 @@         assertBool "simple unit test" =<< selfCPU     ] ---TODO: random gen/normalization? commonData :: IO (A.Acc (A.Scalar Double)) commonData = do     datums <- randDist (A.Z A.:. 1000000)-    pure $ kullbackLiebler .$ (scale datums)+    pure $ kullbackLiebler .$ scale datums +hellingerData :: IO (A.Acc (A.Scalar Double))+hellingerData = do+    datums <- randDist (A.Z A.:. 1000000)+    pure $ hellinger .$ scale datums+ #ifdef ACCELERATE_GPU selfGPU :: IO Bool selfGPU = do     datums <- commonData+    datums' <- hellingerData     let res = the $ GPU.run datums-    pure $ res == 0+        res' = the $ GPU.run datums'+    pure $ res == 0 && res' == 0 #endif  selfCPU :: IO Bool