{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE Strict #-}
{-# LANGUAGE TypeFamilies #-}

module RiskWeaver.Metric where

import Control.Parallel.Strategies
import Data.List (maximumBy, sortBy)
import Data.Map (Map)
import Data.Map qualified as Map
import Data.Maybe (fromMaybe)
import GHC.Generics
import RiskWeaver.Format.Coco

newtype IOU = IOU Double deriving (Int -> IOU -> ShowS
[IOU] -> ShowS
IOU -> String
(Int -> IOU -> ShowS)
-> (IOU -> String) -> ([IOU] -> ShowS) -> Show IOU
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IOU -> ShowS
showsPrec :: Int -> IOU -> ShowS
$cshow :: IOU -> String
show :: IOU -> String
$cshowList :: [IOU] -> ShowS
showList :: [IOU] -> ShowS
Show, IOU -> IOU -> Bool
(IOU -> IOU -> Bool) -> (IOU -> IOU -> Bool) -> Eq IOU
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IOU -> IOU -> Bool
== :: IOU -> IOU -> Bool
$c/= :: IOU -> IOU -> Bool
/= :: IOU -> IOU -> Bool
Eq, Eq IOU
Eq IOU =>
(IOU -> IOU -> Ordering)
-> (IOU -> IOU -> Bool)
-> (IOU -> IOU -> Bool)
-> (IOU -> IOU -> Bool)
-> (IOU -> IOU -> Bool)
-> (IOU -> IOU -> IOU)
-> (IOU -> IOU -> IOU)
-> Ord IOU
IOU -> IOU -> Bool
IOU -> IOU -> Ordering
IOU -> IOU -> IOU
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IOU -> IOU -> Ordering
compare :: IOU -> IOU -> Ordering
$c< :: IOU -> IOU -> Bool
< :: IOU -> IOU -> Bool
$c<= :: IOU -> IOU -> Bool
<= :: IOU -> IOU -> Bool
$c> :: IOU -> IOU -> Bool
> :: IOU -> IOU -> Bool
$c>= :: IOU -> IOU -> Bool
>= :: IOU -> IOU -> Bool
$cmax :: IOU -> IOU -> IOU
max :: IOU -> IOU -> IOU
$cmin :: IOU -> IOU -> IOU
min :: IOU -> IOU -> IOU
Ord, Integer -> IOU
IOU -> IOU
IOU -> IOU -> IOU
(IOU -> IOU -> IOU)
-> (IOU -> IOU -> IOU)
-> (IOU -> IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (Integer -> IOU)
-> Num IOU
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: IOU -> IOU -> IOU
+ :: IOU -> IOU -> IOU
$c- :: IOU -> IOU -> IOU
- :: IOU -> IOU -> IOU
$c* :: IOU -> IOU -> IOU
* :: IOU -> IOU -> IOU
$cnegate :: IOU -> IOU
negate :: IOU -> IOU
$cabs :: IOU -> IOU
abs :: IOU -> IOU
$csignum :: IOU -> IOU
signum :: IOU -> IOU
$cfromInteger :: Integer -> IOU
fromInteger :: Integer -> IOU
Num, Num IOU
Num IOU =>
(IOU -> IOU -> IOU)
-> (IOU -> IOU) -> (Rational -> IOU) -> Fractional IOU
Rational -> IOU
IOU -> IOU
IOU -> IOU -> IOU
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
$c/ :: IOU -> IOU -> IOU
/ :: IOU -> IOU -> IOU
$crecip :: IOU -> IOU
recip :: IOU -> IOU
$cfromRational :: Rational -> IOU
fromRational :: Rational -> IOU
Fractional, Fractional IOU
IOU
Fractional IOU =>
IOU
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU -> IOU)
-> (IOU -> IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> (IOU -> IOU)
-> Floating IOU
IOU -> IOU
IOU -> IOU -> IOU
forall a.
Fractional a =>
a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
$cpi :: IOU
pi :: IOU
$cexp :: IOU -> IOU
exp :: IOU -> IOU
$clog :: IOU -> IOU
log :: IOU -> IOU
$csqrt :: IOU -> IOU
sqrt :: IOU -> IOU
$c** :: IOU -> IOU -> IOU
** :: IOU -> IOU -> IOU
$clogBase :: IOU -> IOU -> IOU
logBase :: IOU -> IOU -> IOU
$csin :: IOU -> IOU
sin :: IOU -> IOU
$ccos :: IOU -> IOU
cos :: IOU -> IOU
$ctan :: IOU -> IOU
tan :: IOU -> IOU
$casin :: IOU -> IOU
asin :: IOU -> IOU
$cacos :: IOU -> IOU
acos :: IOU -> IOU
$catan :: IOU -> IOU
atan :: IOU -> IOU
$csinh :: IOU -> IOU
sinh :: IOU -> IOU
$ccosh :: IOU -> IOU
cosh :: IOU -> IOU
$ctanh :: IOU -> IOU
tanh :: IOU -> IOU
$casinh :: IOU -> IOU
asinh :: IOU -> IOU
$cacosh :: IOU -> IOU
acosh :: IOU -> IOU
$catanh :: IOU -> IOU
atanh :: IOU -> IOU
$clog1p :: IOU -> IOU
log1p :: IOU -> IOU
$cexpm1 :: IOU -> IOU
expm1 :: IOU -> IOU
$clog1pexp :: IOU -> IOU
log1pexp :: IOU -> IOU
$clog1mexp :: IOU -> IOU
log1mexp :: IOU -> IOU
Floating, Num IOU
Ord IOU
(Num IOU, Ord IOU) => (IOU -> Rational) -> Real IOU
IOU -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: IOU -> Rational
toRational :: IOU -> Rational
Real, Fractional IOU
Real IOU
(Real IOU, Fractional IOU) =>
(forall b. Integral b => IOU -> (b, IOU))
-> (forall b. Integral b => IOU -> b)
-> (forall b. Integral b => IOU -> b)
-> (forall b. Integral b => IOU -> b)
-> (forall b. Integral b => IOU -> b)
-> RealFrac IOU
forall b. Integral b => IOU -> b
forall b. Integral b => IOU -> (b, IOU)
forall a.
(Real a, Fractional a) =>
(forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
$cproperFraction :: forall b. Integral b => IOU -> (b, IOU)
properFraction :: forall b. Integral b => IOU -> (b, IOU)
$ctruncate :: forall b. Integral b => IOU -> b
truncate :: forall b. Integral b => IOU -> b
$cround :: forall b. Integral b => IOU -> b
round :: forall b. Integral b => IOU -> b
$cceiling :: forall b. Integral b => IOU -> b
ceiling :: forall b. Integral b => IOU -> b
$cfloor :: forall b. Integral b => IOU -> b
floor :: forall b. Integral b => IOU -> b
RealFrac, Floating IOU
RealFrac IOU
(RealFrac IOU, Floating IOU) =>
(IOU -> Integer)
-> (IOU -> Int)
-> (IOU -> (Int, Int))
-> (IOU -> (Integer, Int))
-> (Integer -> Int -> IOU)
-> (IOU -> Int)
-> (IOU -> IOU)
-> (Int -> IOU -> IOU)
-> (IOU -> Bool)
-> (IOU -> Bool)
-> (IOU -> Bool)
-> (IOU -> Bool)
-> (IOU -> Bool)
-> (IOU -> IOU -> IOU)
-> RealFloat IOU
Int -> IOU -> IOU
Integer -> Int -> IOU
IOU -> Bool
IOU -> Int
IOU -> Integer
IOU -> (Int, Int)
IOU -> (Integer, Int)
IOU -> IOU
IOU -> IOU -> IOU
forall a.
(RealFrac a, Floating a) =>
(a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
$cfloatRadix :: IOU -> Integer
floatRadix :: IOU -> Integer
$cfloatDigits :: IOU -> Int
floatDigits :: IOU -> Int
$cfloatRange :: IOU -> (Int, Int)
floatRange :: IOU -> (Int, Int)
$cdecodeFloat :: IOU -> (Integer, Int)
decodeFloat :: IOU -> (Integer, Int)
$cencodeFloat :: Integer -> Int -> IOU
encodeFloat :: Integer -> Int -> IOU
$cexponent :: IOU -> Int
exponent :: IOU -> Int
$csignificand :: IOU -> IOU
significand :: IOU -> IOU
$cscaleFloat :: Int -> IOU -> IOU
scaleFloat :: Int -> IOU -> IOU
$cisNaN :: IOU -> Bool
isNaN :: IOU -> Bool
$cisInfinite :: IOU -> Bool
isInfinite :: IOU -> Bool
$cisDenormalized :: IOU -> Bool
isDenormalized :: IOU -> Bool
$cisNegativeZero :: IOU -> Bool
isNegativeZero :: IOU -> Bool
$cisIEEE :: IOU -> Bool
isIEEE :: IOU -> Bool
$catan2 :: IOU -> IOU -> IOU
atan2 :: IOU -> IOU -> IOU
RealFloat, (forall x. IOU -> Rep IOU x)
-> (forall x. Rep IOU x -> IOU) -> Generic IOU
forall x. Rep IOU x -> IOU
forall x. IOU -> Rep IOU x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IOU -> Rep IOU x
from :: forall x. IOU -> Rep IOU x
$cto :: forall x. Rep IOU x -> IOU
to :: forall x. Rep IOU x -> IOU
Generic)

newtype IOG = IOG Double deriving (Int -> IOG -> ShowS
[IOG] -> ShowS
IOG -> String
(Int -> IOG -> ShowS)
-> (IOG -> String) -> ([IOG] -> ShowS) -> Show IOG
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IOG -> ShowS
showsPrec :: Int -> IOG -> ShowS
$cshow :: IOG -> String
show :: IOG -> String
$cshowList :: [IOG] -> ShowS
showList :: [IOG] -> ShowS
Show, IOG -> IOG -> Bool
(IOG -> IOG -> Bool) -> (IOG -> IOG -> Bool) -> Eq IOG
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IOG -> IOG -> Bool
== :: IOG -> IOG -> Bool
$c/= :: IOG -> IOG -> Bool
/= :: IOG -> IOG -> Bool
Eq, Eq IOG
Eq IOG =>
(IOG -> IOG -> Ordering)
-> (IOG -> IOG -> Bool)
-> (IOG -> IOG -> Bool)
-> (IOG -> IOG -> Bool)
-> (IOG -> IOG -> Bool)
-> (IOG -> IOG -> IOG)
-> (IOG -> IOG -> IOG)
-> Ord IOG
IOG -> IOG -> Bool
IOG -> IOG -> Ordering
IOG -> IOG -> IOG
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IOG -> IOG -> Ordering
compare :: IOG -> IOG -> Ordering
$c< :: IOG -> IOG -> Bool
< :: IOG -> IOG -> Bool
$c<= :: IOG -> IOG -> Bool
<= :: IOG -> IOG -> Bool
$c> :: IOG -> IOG -> Bool
> :: IOG -> IOG -> Bool
$c>= :: IOG -> IOG -> Bool
>= :: IOG -> IOG -> Bool
$cmax :: IOG -> IOG -> IOG
max :: IOG -> IOG -> IOG
$cmin :: IOG -> IOG -> IOG
min :: IOG -> IOG -> IOG
Ord, Integer -> IOG
IOG -> IOG
IOG -> IOG -> IOG
(IOG -> IOG -> IOG)
-> (IOG -> IOG -> IOG)
-> (IOG -> IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (Integer -> IOG)
-> Num IOG
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: IOG -> IOG -> IOG
+ :: IOG -> IOG -> IOG
$c- :: IOG -> IOG -> IOG
- :: IOG -> IOG -> IOG
$c* :: IOG -> IOG -> IOG
* :: IOG -> IOG -> IOG
$cnegate :: IOG -> IOG
negate :: IOG -> IOG
$cabs :: IOG -> IOG
abs :: IOG -> IOG
$csignum :: IOG -> IOG
signum :: IOG -> IOG
$cfromInteger :: Integer -> IOG
fromInteger :: Integer -> IOG
Num, Num IOG
Num IOG =>
(IOG -> IOG -> IOG)
-> (IOG -> IOG) -> (Rational -> IOG) -> Fractional IOG
Rational -> IOG
IOG -> IOG
IOG -> IOG -> IOG
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
$c/ :: IOG -> IOG -> IOG
/ :: IOG -> IOG -> IOG
$crecip :: IOG -> IOG
recip :: IOG -> IOG
$cfromRational :: Rational -> IOG
fromRational :: Rational -> IOG
Fractional, Fractional IOG
IOG
Fractional IOG =>
IOG
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG -> IOG)
-> (IOG -> IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> (IOG -> IOG)
-> Floating IOG
IOG -> IOG
IOG -> IOG -> IOG
forall a.
Fractional a =>
a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
$cpi :: IOG
pi :: IOG
$cexp :: IOG -> IOG
exp :: IOG -> IOG
$clog :: IOG -> IOG
log :: IOG -> IOG
$csqrt :: IOG -> IOG
sqrt :: IOG -> IOG
$c** :: IOG -> IOG -> IOG
** :: IOG -> IOG -> IOG
$clogBase :: IOG -> IOG -> IOG
logBase :: IOG -> IOG -> IOG
$csin :: IOG -> IOG
sin :: IOG -> IOG
$ccos :: IOG -> IOG
cos :: IOG -> IOG
$ctan :: IOG -> IOG
tan :: IOG -> IOG
$casin :: IOG -> IOG
asin :: IOG -> IOG
$cacos :: IOG -> IOG
acos :: IOG -> IOG
$catan :: IOG -> IOG
atan :: IOG -> IOG
$csinh :: IOG -> IOG
sinh :: IOG -> IOG
$ccosh :: IOG -> IOG
cosh :: IOG -> IOG
$ctanh :: IOG -> IOG
tanh :: IOG -> IOG
$casinh :: IOG -> IOG
asinh :: IOG -> IOG
$cacosh :: IOG -> IOG
acosh :: IOG -> IOG
$catanh :: IOG -> IOG
atanh :: IOG -> IOG
$clog1p :: IOG -> IOG
log1p :: IOG -> IOG
$cexpm1 :: IOG -> IOG
expm1 :: IOG -> IOG
$clog1pexp :: IOG -> IOG
log1pexp :: IOG -> IOG
$clog1mexp :: IOG -> IOG
log1mexp :: IOG -> IOG
Floating, Num IOG
Ord IOG
(Num IOG, Ord IOG) => (IOG -> Rational) -> Real IOG
IOG -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: IOG -> Rational
toRational :: IOG -> Rational
Real, Fractional IOG
Real IOG
(Real IOG, Fractional IOG) =>
(forall b. Integral b => IOG -> (b, IOG))
-> (forall b. Integral b => IOG -> b)
-> (forall b. Integral b => IOG -> b)
-> (forall b. Integral b => IOG -> b)
-> (forall b. Integral b => IOG -> b)
-> RealFrac IOG
forall b. Integral b => IOG -> b
forall b. Integral b => IOG -> (b, IOG)
forall a.
(Real a, Fractional a) =>
(forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
$cproperFraction :: forall b. Integral b => IOG -> (b, IOG)
properFraction :: forall b. Integral b => IOG -> (b, IOG)
$ctruncate :: forall b. Integral b => IOG -> b
truncate :: forall b. Integral b => IOG -> b
$cround :: forall b. Integral b => IOG -> b
round :: forall b. Integral b => IOG -> b
$cceiling :: forall b. Integral b => IOG -> b
ceiling :: forall b. Integral b => IOG -> b
$cfloor :: forall b. Integral b => IOG -> b
floor :: forall b. Integral b => IOG -> b
RealFrac, Floating IOG
RealFrac IOG
(RealFrac IOG, Floating IOG) =>
(IOG -> Integer)
-> (IOG -> Int)
-> (IOG -> (Int, Int))
-> (IOG -> (Integer, Int))
-> (Integer -> Int -> IOG)
-> (IOG -> Int)
-> (IOG -> IOG)
-> (Int -> IOG -> IOG)
-> (IOG -> Bool)
-> (IOG -> Bool)
-> (IOG -> Bool)
-> (IOG -> Bool)
-> (IOG -> Bool)
-> (IOG -> IOG -> IOG)
-> RealFloat IOG
Int -> IOG -> IOG
Integer -> Int -> IOG
IOG -> Bool
IOG -> Int
IOG -> Integer
IOG -> (Int, Int)
IOG -> (Integer, Int)
IOG -> IOG
IOG -> IOG -> IOG
forall a.
(RealFrac a, Floating a) =>
(a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
$cfloatRadix :: IOG -> Integer
floatRadix :: IOG -> Integer
$cfloatDigits :: IOG -> Int
floatDigits :: IOG -> Int
$cfloatRange :: IOG -> (Int, Int)
floatRange :: IOG -> (Int, Int)
$cdecodeFloat :: IOG -> (Integer, Int)
decodeFloat :: IOG -> (Integer, Int)
$cencodeFloat :: Integer -> Int -> IOG
encodeFloat :: Integer -> Int -> IOG
$cexponent :: IOG -> Int
exponent :: IOG -> Int
$csignificand :: IOG -> IOG
significand :: IOG -> IOG
$cscaleFloat :: Int -> IOG -> IOG
scaleFloat :: Int -> IOG -> IOG
$cisNaN :: IOG -> Bool
isNaN :: IOG -> Bool
$cisInfinite :: IOG -> Bool
isInfinite :: IOG -> Bool
$cisDenormalized :: IOG -> Bool
isDenormalized :: IOG -> Bool
$cisNegativeZero :: IOG -> Bool
isNegativeZero :: IOG -> Bool
$cisIEEE :: IOG -> Bool
isIEEE :: IOG -> Bool
$catan2 :: IOG -> IOG -> IOG
atan2 :: IOG -> IOG -> IOG
RealFloat, (forall x. IOG -> Rep IOG x)
-> (forall x. Rep IOG x -> IOG) -> Generic IOG
forall x. Rep IOG x -> IOG
forall x. IOG -> Rep IOG x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IOG -> Rep IOG x
from :: forall x. IOG -> Rep IOG x
$cto :: forall x. Rep IOG x -> IOG
to :: forall x. Rep IOG x -> IOG
Generic)

data Dt a
  = Dt a
  | DtBackground
  deriving (Int -> Dt a -> ShowS
[Dt a] -> ShowS
Dt a -> String
(Int -> Dt a -> ShowS)
-> (Dt a -> String) -> ([Dt a] -> ShowS) -> Show (Dt a)
forall a. Show a => Int -> Dt a -> ShowS
forall a. Show a => [Dt a] -> ShowS
forall a. Show a => Dt a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Dt a -> ShowS
showsPrec :: Int -> Dt a -> ShowS
$cshow :: forall a. Show a => Dt a -> String
show :: Dt a -> String
$cshowList :: forall a. Show a => [Dt a] -> ShowS
showList :: [Dt a] -> ShowS
Show, Dt a -> Dt a -> Bool
(Dt a -> Dt a -> Bool) -> (Dt a -> Dt a -> Bool) -> Eq (Dt a)
forall a. Eq a => Dt a -> Dt a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Dt a -> Dt a -> Bool
== :: Dt a -> Dt a -> Bool
$c/= :: forall a. Eq a => Dt a -> Dt a -> Bool
/= :: Dt a -> Dt a -> Bool
Eq, Eq (Dt a)
Eq (Dt a) =>
(Dt a -> Dt a -> Ordering)
-> (Dt a -> Dt a -> Bool)
-> (Dt a -> Dt a -> Bool)
-> (Dt a -> Dt a -> Bool)
-> (Dt a -> Dt a -> Bool)
-> (Dt a -> Dt a -> Dt a)
-> (Dt a -> Dt a -> Dt a)
-> Ord (Dt a)
Dt a -> Dt a -> Bool
Dt a -> Dt a -> Ordering
Dt a -> Dt a -> Dt a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Dt a)
forall a. Ord a => Dt a -> Dt a -> Bool
forall a. Ord a => Dt a -> Dt a -> Ordering
forall a. Ord a => Dt a -> Dt a -> Dt a
$ccompare :: forall a. Ord a => Dt a -> Dt a -> Ordering
compare :: Dt a -> Dt a -> Ordering
$c< :: forall a. Ord a => Dt a -> Dt a -> Bool
< :: Dt a -> Dt a -> Bool
$c<= :: forall a. Ord a => Dt a -> Dt a -> Bool
<= :: Dt a -> Dt a -> Bool
$c> :: forall a. Ord a => Dt a -> Dt a -> Bool
> :: Dt a -> Dt a -> Bool
$c>= :: forall a. Ord a => Dt a -> Dt a -> Bool
>= :: Dt a -> Dt a -> Bool
$cmax :: forall a. Ord a => Dt a -> Dt a -> Dt a
max :: Dt a -> Dt a -> Dt a
$cmin :: forall a. Ord a => Dt a -> Dt a -> Dt a
min :: Dt a -> Dt a -> Dt a
Ord)

data Gt a
  = Gt a
  | GtBackground
  deriving (Int -> Gt a -> ShowS
[Gt a] -> ShowS
Gt a -> String
(Int -> Gt a -> ShowS)
-> (Gt a -> String) -> ([Gt a] -> ShowS) -> Show (Gt a)
forall a. Show a => Int -> Gt a -> ShowS
forall a. Show a => [Gt a] -> ShowS
forall a. Show a => Gt a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Gt a -> ShowS
showsPrec :: Int -> Gt a -> ShowS
$cshow :: forall a. Show a => Gt a -> String
show :: Gt a -> String
$cshowList :: forall a. Show a => [Gt a] -> ShowS
showList :: [Gt a] -> ShowS
Show, Gt a -> Gt a -> Bool
(Gt a -> Gt a -> Bool) -> (Gt a -> Gt a -> Bool) -> Eq (Gt a)
forall a. Eq a => Gt a -> Gt a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Gt a -> Gt a -> Bool
== :: Gt a -> Gt a -> Bool
$c/= :: forall a. Eq a => Gt a -> Gt a -> Bool
/= :: Gt a -> Gt a -> Bool
Eq, Eq (Gt a)
Eq (Gt a) =>
(Gt a -> Gt a -> Ordering)
-> (Gt a -> Gt a -> Bool)
-> (Gt a -> Gt a -> Bool)
-> (Gt a -> Gt a -> Bool)
-> (Gt a -> Gt a -> Bool)
-> (Gt a -> Gt a -> Gt a)
-> (Gt a -> Gt a -> Gt a)
-> Ord (Gt a)
Gt a -> Gt a -> Bool
Gt a -> Gt a -> Ordering
Gt a -> Gt a -> Gt a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Gt a)
forall a. Ord a => Gt a -> Gt a -> Bool
forall a. Ord a => Gt a -> Gt a -> Ordering
forall a. Ord a => Gt a -> Gt a -> Gt a
$ccompare :: forall a. Ord a => Gt a -> Gt a -> Ordering
compare :: Gt a -> Gt a -> Ordering
$c< :: forall a. Ord a => Gt a -> Gt a -> Bool
< :: Gt a -> Gt a -> Bool
$c<= :: forall a. Ord a => Gt a -> Gt a -> Bool
<= :: Gt a -> Gt a -> Bool
$c> :: forall a. Ord a => Gt a -> Gt a -> Bool
> :: Gt a -> Gt a -> Bool
$c>= :: forall a. Ord a => Gt a -> Gt a -> Bool
>= :: Gt a -> Gt a -> Bool
$cmax :: forall a. Ord a => Gt a -> Gt a -> Gt a
max :: Gt a -> Gt a -> Gt a
$cmin :: forall a. Ord a => Gt a -> Gt a -> Gt a
min :: Gt a -> Gt a -> Gt a
Ord)

iou :: CoCoBoundingBox -> CoCoBoundingBox -> IOU
iou :: CoCoBoundingBox -> CoCoBoundingBox -> IOU
iou (CoCoBoundingBox (Double
x1, Double
y1, Double
w1, Double
h1)) (CoCoBoundingBox (Double
x2, Double
y2, Double
w2, Double
h2)) =
  let x1' :: Double
x1' = Double
x1 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w1
      y1' :: Double
y1' = Double
y1 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
h1
      x2' :: Double
x2' = Double
x2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w2
      y2' :: Double
y2' = Double
y2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
h2
      x :: Double
x = Double -> Double -> Double
forall a. Ord a => a -> a -> a
max Double
x1 Double
x2
      y :: Double
y = Double -> Double -> Double
forall a. Ord a => a -> a -> a
max Double
y1 Double
y2
      x' :: Double
x' = Double -> Double -> Double
forall a. Ord a => a -> a -> a
min Double
x1' Double
x2'
      y' :: Double
y' = Double -> Double -> Double
forall a. Ord a => a -> a -> a
min Double
y1' Double
y2'
      intersection :: Double
intersection = Double -> Double -> Double
forall a. Ord a => a -> a -> a
max Double
0 (Double
x' Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
x) Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double -> Double
forall a. Ord a => a -> a -> a
max Double
0 (Double
y' Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
y)
      union :: Double
union = Double
w1 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
h1 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
h2 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
intersection
   in Double -> IOU
IOU (Double -> IOU) -> Double -> IOU
forall a b. (a -> b) -> a -> b
$ Double
intersection Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
union
{-# INLINEABLE iou #-}

iog :: CoCoBoundingBox -> CoCoBoundingBox -> IOG
iog :: CoCoBoundingBox -> CoCoBoundingBox -> IOG
iog (CoCoBoundingBox (Double
x1, Double
y1, Double
w1, Double
h1)) (CoCoBoundingBox (Double
x2, Double
y2, Double
w2, Double
h2)) =
  let x1' :: Double
x1' = Double
x1 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w1
      y1' :: Double
y1' = Double
y1 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
h1
      x2' :: Double
x2' = Double
x2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
w2
      y2' :: Double
y2' = Double
y2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
h2
      x :: Double
x = Double -> Double -> Double
forall a. Ord a => a -> a -> a
max Double
x1 Double
x2
      y :: Double
y = Double -> Double -> Double
forall a. Ord a => a -> a -> a
max Double
y1 Double
y2
      x' :: Double
x' = Double -> Double -> Double
forall a. Ord a => a -> a -> a
min Double
x1' Double
x2'
      y' :: Double
y' = Double -> Double -> Double
forall a. Ord a => a -> a -> a
min Double
y1' Double
y2'
      intersection :: Double
intersection = Double -> Double -> Double
forall a. Ord a => a -> a -> a
max Double
0 (Double
x' Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
x) Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double -> Double
forall a. Ord a => a -> a -> a
max Double
0 (Double
y' Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
y)
      groundTruth :: Double
groundTruth = Double
w1 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
h1
   in Double -> IOG
IOG (Double -> IOG) -> Double -> IOG
forall a b. (a -> b) -> a -> b
$ Double
intersection Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
groundTruth
{-# INLINEABLE iog #-}

-- | Calculate TP or FP
-- | TP = true positive
-- | FP = false positive
-- | When the value is True, TP is calculated.
-- | When the value is False, FP is calculated.
toTPorFP :: CocoMap -> ImageId -> CategoryId -> IOU -> ([(CocoResult, Bool)], Int)
toTPorFP :: CocoMap
-> ImageId -> CategoryId -> IOU -> ([(CocoResult, Bool)], Int)
toTPorFP CocoMap {String
[CategoryId]
[ImageId]
Map String [ImageId]
Map CategoryId CocoCategory
Map ImageId String
Map ImageId [CocoResult]
Map ImageId [CocoAnnotation]
Map ImageId CocoImage
Coco
cocoMapImageId :: Map String [ImageId]
cocoMapCocoImage :: Map ImageId CocoImage
cocoMapCocoAnnotation :: Map ImageId [CocoAnnotation]
cocoMapCocoCategory :: Map CategoryId CocoCategory
cocoMapCocoResult :: Map ImageId [CocoResult]
cocoMapFilepath :: Map ImageId String
cocoMapImageIds :: [ImageId]
cocoMapCategoryIds :: [CategoryId]
cocoMapCoco :: Coco
cocoMapCocoFile :: String
cocoMapCocoResultFile :: String
cocoMapImageId :: CocoMap -> Map String [ImageId]
cocoMapCocoImage :: CocoMap -> Map ImageId CocoImage
cocoMapCocoAnnotation :: CocoMap -> Map ImageId [CocoAnnotation]
cocoMapCocoCategory :: CocoMap -> Map CategoryId CocoCategory
cocoMapCocoResult :: CocoMap -> Map ImageId [CocoResult]
cocoMapFilepath :: CocoMap -> Map ImageId String
cocoMapImageIds :: CocoMap -> [ImageId]
cocoMapCategoryIds :: CocoMap -> [CategoryId]
cocoMapCoco :: CocoMap -> Coco
cocoMapCocoFile :: CocoMap -> String
cocoMapCocoResultFile :: CocoMap -> String
..} ImageId
imageId CategoryId
categoryId IOU
iouThresh =
  let -- detections is sorted by score in descending order.
      [CocoResult]
detections :: [CocoResult] =
        case ImageId -> Map ImageId [CocoResult] -> Maybe [CocoResult]
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup ImageId
imageId Map ImageId [CocoResult]
cocoMapCocoResult of
          Maybe [CocoResult]
Nothing -> []
          Just [CocoResult]
results ->
            (CocoResult -> CocoResult -> Ordering)
-> [CocoResult] -> [CocoResult]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy (\CocoResult
cocoResult1 CocoResult
cocoResult2 -> Score -> Score -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (CocoResult -> Score
cocoResultScore CocoResult
cocoResult2) (CocoResult -> Score
cocoResultScore CocoResult
cocoResult1)) ([CocoResult] -> [CocoResult]) -> [CocoResult] -> [CocoResult]
forall a b. (a -> b) -> a -> b
$
              (CocoResult -> Bool) -> [CocoResult] -> [CocoResult]
forall a. (a -> Bool) -> [a] -> [a]
filter (\CocoResult
result -> CocoResult -> CategoryId
cocoResultCategory CocoResult
result CategoryId -> CategoryId -> Bool
forall a. Eq a => a -> a -> Bool
== CategoryId
categoryId) [CocoResult]
results
      [CocoAnnotation]
groundTruthsList :: [CocoAnnotation] =
        (CocoAnnotation -> Bool) -> [CocoAnnotation] -> [CocoAnnotation]
forall a. (a -> Bool) -> [a] -> [a]
filter (\CocoAnnotation
annotation -> CocoAnnotation -> CategoryId
cocoAnnotationCategory CocoAnnotation
annotation CategoryId -> CategoryId -> Bool
forall a. Eq a => a -> a -> Bool
== CategoryId
categoryId) ([CocoAnnotation] -> [CocoAnnotation])
-> [CocoAnnotation] -> [CocoAnnotation]
forall a b. (a -> b) -> a -> b
$
          [CocoAnnotation] -> Maybe [CocoAnnotation] -> [CocoAnnotation]
forall a. a -> Maybe a -> a
fromMaybe [] (Maybe [CocoAnnotation] -> [CocoAnnotation])
-> Maybe [CocoAnnotation] -> [CocoAnnotation]
forall a b. (a -> b) -> a -> b
$
            ImageId -> Map ImageId [CocoAnnotation] -> Maybe [CocoAnnotation]
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup ImageId
imageId Map ImageId [CocoAnnotation]
cocoMapCocoAnnotation
      Map Int CocoAnnotation
groundTruths :: Map.Map Int CocoAnnotation =
        [(Int, CocoAnnotation)] -> Map Int CocoAnnotation
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(Int, CocoAnnotation)] -> Map Int CocoAnnotation)
-> [(Int, CocoAnnotation)] -> Map Int CocoAnnotation
forall a b. (a -> b) -> a -> b
$ [Int] -> [CocoAnnotation] -> [(Int, CocoAnnotation)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0 ..] [CocoAnnotation]
groundTruthsList
      numOfGroundTruths :: Int
numOfGroundTruths = Map Int CocoAnnotation -> Int
forall k a. Map k a -> Int
Map.size Map Int CocoAnnotation
groundTruths
      getGTWithMaxScore :: CocoResult -> Map.Map Int CocoAnnotation -> Maybe (Int, CocoAnnotation, IOU)
      getGTWithMaxScore :: CocoResult
-> Map Int CocoAnnotation -> Maybe (Int, CocoAnnotation, IOU)
getGTWithMaxScore CocoResult
cocoResult Map Int CocoAnnotation
gts =
        if Map Int CocoAnnotation -> Int
forall k a. Map k a -> Int
Map.size Map Int CocoAnnotation
gts Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0
          then Maybe (Int, CocoAnnotation, IOU)
forall a. Maybe a
Nothing
          else
            let ious :: [(Int, CocoAnnotation, IOU)]
ious = ((Int, CocoAnnotation) -> (Int, CocoAnnotation, IOU))
-> [(Int, CocoAnnotation)] -> [(Int, CocoAnnotation, IOU)]
forall a b. (a -> b) -> [a] -> [b]
map (\(Int
i', CocoAnnotation
gt') -> (Int
i', CocoAnnotation
gt', CoCoBoundingBox -> CoCoBoundingBox -> IOU
iou (CocoAnnotation -> CoCoBoundingBox
cocoAnnotationBbox CocoAnnotation
gt') (CocoResult -> CoCoBoundingBox
cocoResultBbox CocoResult
cocoResult))) ([(Int, CocoAnnotation)] -> [(Int, CocoAnnotation, IOU)])
-> [(Int, CocoAnnotation)] -> [(Int, CocoAnnotation, IOU)]
forall a b. (a -> b) -> a -> b
$ Map Int CocoAnnotation -> [(Int, CocoAnnotation)]
forall k a. Map k a -> [(k, a)]
Map.toList Map Int CocoAnnotation
gts
                (Int
i, CocoAnnotation
gt, IOU
iou') = ((Int, CocoAnnotation, IOU)
 -> (Int, CocoAnnotation, IOU) -> Ordering)
-> [(Int, CocoAnnotation, IOU)] -> (Int, CocoAnnotation, IOU)
forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
maximumBy (\(Int
_, CocoAnnotation
_, IOU
iou1) (Int
_, CocoAnnotation
_, IOU
iou2) -> IOU -> IOU -> Ordering
forall a. Ord a => a -> a -> Ordering
compare IOU
iou1 IOU
iou2) [(Int, CocoAnnotation, IOU)]
ious
             in if IOU
iou' IOU -> IOU -> Bool
forall a. Ord a => a -> a -> Bool
>= IOU
iouThresh
                  then (Int, CocoAnnotation, IOU) -> Maybe (Int, CocoAnnotation, IOU)
forall a. a -> Maybe a
Just (Int
i, CocoAnnotation
gt, IOU
iou')
                  else Maybe (Int, CocoAnnotation, IOU)
forall a. Maybe a
Nothing
      loop :: [CocoResult] -> Map.Map Int CocoAnnotation -> [(CocoResult, Bool)]
      loop :: [CocoResult] -> Map Int CocoAnnotation -> [(CocoResult, Bool)]
loop [] Map Int CocoAnnotation
_ = []
      loop (CocoResult
result : [CocoResult]
results) Map Int CocoAnnotation
groundTruths' =
        case CocoResult
-> Map Int CocoAnnotation -> Maybe (Int, CocoAnnotation, IOU)
getGTWithMaxScore CocoResult
result Map Int CocoAnnotation
groundTruths' of
          Maybe (Int, CocoAnnotation, IOU)
Nothing -> (CocoResult
result, Bool
False) (CocoResult, Bool) -> [(CocoResult, Bool)] -> [(CocoResult, Bool)]
forall a. a -> [a] -> [a]
: [CocoResult] -> Map Int CocoAnnotation -> [(CocoResult, Bool)]
loop [CocoResult]
results Map Int CocoAnnotation
groundTruths'
          Just (Int
i, CocoAnnotation
_, IOU
_) ->
            let groundTruths'' :: Map Int CocoAnnotation
groundTruths'' = Int -> Map Int CocoAnnotation -> Map Int CocoAnnotation
forall k a. Ord k => k -> Map k a -> Map k a
Map.delete Int
i Map Int CocoAnnotation
groundTruths'
             in (CocoResult
result, Bool
True) (CocoResult, Bool) -> [(CocoResult, Bool)] -> [(CocoResult, Bool)]
forall a. a -> [a] -> [a]
: [CocoResult] -> Map Int CocoAnnotation -> [(CocoResult, Bool)]
loop [CocoResult]
results Map Int CocoAnnotation
groundTruths''
   in ([CocoResult] -> Map Int CocoAnnotation -> [(CocoResult, Bool)]
loop [CocoResult]
detections Map Int CocoAnnotation
groundTruths, Int
numOfGroundTruths)

apForCategory :: CocoMap -> CategoryId -> IOU -> Double
apForCategory :: CocoMap -> CategoryId -> IOU -> Double
apForCategory cocoMap :: CocoMap
cocoMap@CocoMap {String
[CategoryId]
[ImageId]
Map String [ImageId]
Map CategoryId CocoCategory
Map ImageId String
Map ImageId [CocoResult]
Map ImageId [CocoAnnotation]
Map ImageId CocoImage
Coco
cocoMapImageId :: CocoMap -> Map String [ImageId]
cocoMapCocoImage :: CocoMap -> Map ImageId CocoImage
cocoMapCocoAnnotation :: CocoMap -> Map ImageId [CocoAnnotation]
cocoMapCocoCategory :: CocoMap -> Map CategoryId CocoCategory
cocoMapCocoResult :: CocoMap -> Map ImageId [CocoResult]
cocoMapFilepath :: CocoMap -> Map ImageId String
cocoMapImageIds :: CocoMap -> [ImageId]
cocoMapCategoryIds :: CocoMap -> [CategoryId]
cocoMapCoco :: CocoMap -> Coco
cocoMapCocoFile :: CocoMap -> String
cocoMapCocoResultFile :: CocoMap -> String
cocoMapImageId :: Map String [ImageId]
cocoMapCocoImage :: Map ImageId CocoImage
cocoMapCocoAnnotation :: Map ImageId [CocoAnnotation]
cocoMapCocoCategory :: Map CategoryId CocoCategory
cocoMapCocoResult :: Map ImageId [CocoResult]
cocoMapFilepath :: Map ImageId String
cocoMapImageIds :: [ImageId]
cocoMapCategoryIds :: [CategoryId]
cocoMapCoco :: Coco
cocoMapCocoFile :: String
cocoMapCocoResultFile :: String
..} CategoryId
categoryId IOU
iouThresh =
  let imageIds :: [ImageId]
imageIds = [ImageId]
cocoMapImageIds
      tpAndFps' :: [([(CocoResult, Bool)], Int)]
tpAndFps' =
        (ImageId -> ([(CocoResult, Bool)], Int))
-> [ImageId] -> [([(CocoResult, Bool)], Int)]
forall a b. (a -> b) -> [a] -> [b]
map (\ImageId
imageId -> CocoMap
-> ImageId -> CategoryId -> IOU -> ([(CocoResult, Bool)], Int)
toTPorFP CocoMap
cocoMap ImageId
imageId CategoryId
categoryId IOU
iouThresh) [ImageId]
imageIds
          [([(CocoResult, Bool)], Int)]
-> Strategy [([(CocoResult, Bool)], Int)]
-> [([(CocoResult, Bool)], Int)]
forall a. a -> Strategy a -> a
`using` Strategy ([(CocoResult, Bool)], Int)
-> Strategy [([(CocoResult, Bool)], Int)]
forall a. Strategy a -> Strategy [a]
parList Strategy ([(CocoResult, Bool)], Int)
forall a. NFData a => Strategy a
rdeepseq
      numOfGroundTruths :: Int
numOfGroundTruths = [Int] -> Int
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Int] -> Int) -> [Int] -> Int
forall a b. (a -> b) -> a -> b
$ (([(CocoResult, Bool)], Int) -> Int)
-> [([(CocoResult, Bool)], Int)] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map ([(CocoResult, Bool)], Int) -> Int
forall a b. (a, b) -> b
snd [([(CocoResult, Bool)], Int)]
tpAndFps'
      tpAndFps :: [(CocoResult, Bool)]
tpAndFps = ((CocoResult, Bool) -> (CocoResult, Bool) -> Ordering)
-> [(CocoResult, Bool)] -> [(CocoResult, Bool)]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy (\(CocoResult, Bool)
res0 (CocoResult, Bool)
res1 -> Score -> Score -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (CocoResult -> Score
cocoResultScore ((CocoResult, Bool) -> CocoResult
forall a b. (a, b) -> a
fst (CocoResult, Bool)
res1)) (CocoResult -> Score
cocoResultScore ((CocoResult, Bool) -> CocoResult
forall a b. (a, b) -> a
fst (CocoResult, Bool)
res0))) ([(CocoResult, Bool)] -> [(CocoResult, Bool)])
-> [(CocoResult, Bool)] -> [(CocoResult, Bool)]
forall a b. (a -> b) -> a -> b
$ [[(CocoResult, Bool)]] -> [(CocoResult, Bool)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(CocoResult, Bool)]] -> [(CocoResult, Bool)])
-> [[(CocoResult, Bool)]] -> [(CocoResult, Bool)]
forall a b. (a -> b) -> a -> b
$ (([(CocoResult, Bool)], Int) -> [(CocoResult, Bool)])
-> [([(CocoResult, Bool)], Int)] -> [[(CocoResult, Bool)]]
forall a b. (a -> b) -> [a] -> [b]
map ([(CocoResult, Bool)], Int) -> [(CocoResult, Bool)]
forall a b. (a, b) -> a
fst [([(CocoResult, Bool)], Int)]
tpAndFps'
      precisionRecallCurve :: [(CocoResult, Bool)] -> Int -> Int -> [(Double, Double)]
      precisionRecallCurve :: [(CocoResult, Bool)] -> Int -> Int -> [(Double, Double)]
precisionRecallCurve [] Int
_ Int
_ = []
      precisionRecallCurve ((CocoResult, Bool)
x : [(CocoResult, Bool)]
xs) Int
accTps Int
accNum =
        (Double
precision, Double
recall) (Double, Double) -> [(Double, Double)] -> [(Double, Double)]
forall a. a -> [a] -> [a]
: [(CocoResult, Bool)] -> Int -> Int -> [(Double, Double)]
precisionRecallCurve [(CocoResult, Bool)]
xs Int
accTps' Int
accNum'
        where
          accTps' :: Int
accTps' = if (CocoResult, Bool) -> Bool
forall a b. (a, b) -> b
snd (CocoResult, Bool)
x then Int
accTps Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1 else Int
accTps
          accNum' :: Int
accNum' = Int
accNum Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
          precision :: Double
precision = Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
accTps' Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
accNum'
          recall :: Double
recall = Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
accTps' Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
numOfGroundTruths
      precisionRecallCurve' :: [(Double, Double)]
precisionRecallCurve' = [(Double, Double)] -> [(Double, Double)]
forall a. [a] -> [a]
reverse ([(Double, Double)] -> [(Double, Double)])
-> [(Double, Double)] -> [(Double, Double)]
forall a b. (a -> b) -> a -> b
$ [(CocoResult, Bool)] -> Int -> Int -> [(Double, Double)]
precisionRecallCurve [(CocoResult, Bool)]
tpAndFps Int
0 Int
0
      ap :: [(Double, Double)] -> (Double, Double) -> Double
      ap :: [(Double, Double)] -> (Double, Double) -> Double
ap [] (Double
maxPrecision, Double
maxRecall) = Double
maxPrecision Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
maxRecall
      ap ((Double
precision, Double
recall) : [(Double, Double)]
xs) (Double
maxPrecision, Double
maxRecall) =
        if Double
precision Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
maxPrecision Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
> Double
0
          then Double
maxPrecision Double -> Double -> Double
forall a. Num a => a -> a -> a
* (Double
maxRecall Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
recall) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ [(Double, Double)] -> (Double, Double) -> Double
ap [(Double, Double)]
xs (Double
precision, Double
recall)
          else [(Double, Double)] -> (Double, Double) -> Double
ap [(Double, Double)]
xs (Double
maxPrecision, Double
maxRecall)
   in case [(Double, Double)]
precisionRecallCurve' of
        [] -> Double
0
        ((Double, Double)
x : [(Double, Double)]
xs) -> [(Double, Double)] -> (Double, Double) -> Double
ap [(Double, Double)]
xs (Double, Double)
x

mAP :: CocoMap -> IOU -> (Double, [(CategoryId, Double)])
mAP :: CocoMap -> IOU -> (Double, [(CategoryId, Double)])
mAP cocoMap :: CocoMap
cocoMap@CocoMap {String
[CategoryId]
[ImageId]
Map String [ImageId]
Map CategoryId CocoCategory
Map ImageId String
Map ImageId [CocoResult]
Map ImageId [CocoAnnotation]
Map ImageId CocoImage
Coco
cocoMapImageId :: CocoMap -> Map String [ImageId]
cocoMapCocoImage :: CocoMap -> Map ImageId CocoImage
cocoMapCocoAnnotation :: CocoMap -> Map ImageId [CocoAnnotation]
cocoMapCocoCategory :: CocoMap -> Map CategoryId CocoCategory
cocoMapCocoResult :: CocoMap -> Map ImageId [CocoResult]
cocoMapFilepath :: CocoMap -> Map ImageId String
cocoMapImageIds :: CocoMap -> [ImageId]
cocoMapCategoryIds :: CocoMap -> [CategoryId]
cocoMapCoco :: CocoMap -> Coco
cocoMapCocoFile :: CocoMap -> String
cocoMapCocoResultFile :: CocoMap -> String
cocoMapImageId :: Map String [ImageId]
cocoMapCocoImage :: Map ImageId CocoImage
cocoMapCocoAnnotation :: Map ImageId [CocoAnnotation]
cocoMapCocoCategory :: Map CategoryId CocoCategory
cocoMapCocoResult :: Map ImageId [CocoResult]
cocoMapFilepath :: Map ImageId String
cocoMapImageIds :: [ImageId]
cocoMapCategoryIds :: [CategoryId]
cocoMapCoco :: Coco
cocoMapCocoFile :: String
cocoMapCocoResultFile :: String
..} IOU
iouThresh =
  let categoryIds :: [CategoryId]
categoryIds = [CategoryId]
cocoMapCategoryIds
      aps :: [Double]
aps = (CategoryId -> Double) -> [CategoryId] -> [Double]
forall a b. (a -> b) -> [a] -> [b]
map (\CategoryId
categoryId -> CocoMap -> CategoryId -> IOU -> Double
apForCategory CocoMap
cocoMap CategoryId
categoryId IOU
iouThresh) [CategoryId]
categoryIds
      aps' :: [Double]
aps' = [Double]
aps [Double] -> Strategy [Double] -> [Double]
forall a. a -> Strategy a -> a
`using` Strategy Double -> Strategy [Double]
forall a. Strategy a -> Strategy [a]
parList Strategy Double
forall a. NFData a => Strategy a
rdeepseq
   in ([Double] -> Double
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [Double]
aps' Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Double] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Double]
aps'), [CategoryId] -> [Double] -> [(CategoryId, Double)]
forall a b. [a] -> [b] -> [(a, b)]
zip [CategoryId]
categoryIds [Double]
aps')


f1ForCategory :: CocoMap -> CategoryId -> IOU -> Score -> Double
f1ForCategory :: CocoMap -> CategoryId -> IOU -> Score -> Double
f1ForCategory cocoMap :: CocoMap
cocoMap@CocoMap {String
[CategoryId]
[ImageId]
Map String [ImageId]
Map CategoryId CocoCategory
Map ImageId String
Map ImageId [CocoResult]
Map ImageId [CocoAnnotation]
Map ImageId CocoImage
Coco
cocoMapImageId :: CocoMap -> Map String [ImageId]
cocoMapCocoImage :: CocoMap -> Map ImageId CocoImage
cocoMapCocoAnnotation :: CocoMap -> Map ImageId [CocoAnnotation]
cocoMapCocoCategory :: CocoMap -> Map CategoryId CocoCategory
cocoMapCocoResult :: CocoMap -> Map ImageId [CocoResult]
cocoMapFilepath :: CocoMap -> Map ImageId String
cocoMapImageIds :: CocoMap -> [ImageId]
cocoMapCategoryIds :: CocoMap -> [CategoryId]
cocoMapCoco :: CocoMap -> Coco
cocoMapCocoFile :: CocoMap -> String
cocoMapCocoResultFile :: CocoMap -> String
cocoMapImageId :: Map String [ImageId]
cocoMapCocoImage :: Map ImageId CocoImage
cocoMapCocoAnnotation :: Map ImageId [CocoAnnotation]
cocoMapCocoCategory :: Map CategoryId CocoCategory
cocoMapCocoResult :: Map ImageId [CocoResult]
cocoMapFilepath :: Map ImageId String
cocoMapImageIds :: [ImageId]
cocoMapCategoryIds :: [CategoryId]
cocoMapCoco :: Coco
cocoMapCocoFile :: String
cocoMapCocoResultFile :: String
..} CategoryId
categoryId IOU
iouThresh Score
scoreThresh =
  let imageIds :: [ImageId]
imageIds = [ImageId]
cocoMapImageIds
      tpAndFps' :: [([(CocoResult, Bool)], Int)]
tpAndFps' =
        (ImageId -> ([(CocoResult, Bool)], Int))
-> [ImageId] -> [([(CocoResult, Bool)], Int)]
forall a b. (a -> b) -> [a] -> [b]
map (\ImageId
imageId -> CocoMap
-> ImageId -> CategoryId -> IOU -> ([(CocoResult, Bool)], Int)
toTPorFP CocoMap
cocoMap ImageId
imageId CategoryId
categoryId IOU
iouThresh) [ImageId]
imageIds
          [([(CocoResult, Bool)], Int)]
-> Strategy [([(CocoResult, Bool)], Int)]
-> [([(CocoResult, Bool)], Int)]
forall a. a -> Strategy a -> a
`using` Strategy ([(CocoResult, Bool)], Int)
-> Strategy [([(CocoResult, Bool)], Int)]
forall a. Strategy a -> Strategy [a]
parList Strategy ([(CocoResult, Bool)], Int)
forall a. NFData a => Strategy a
rdeepseq
      numOfGroundTruths :: Int
numOfGroundTruths = [Int] -> Int
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Int] -> Int) -> [Int] -> Int
forall a b. (a -> b) -> a -> b
$ (([(CocoResult, Bool)], Int) -> Int)
-> [([(CocoResult, Bool)], Int)] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map ([(CocoResult, Bool)], Int) -> Int
forall a b. (a, b) -> b
snd [([(CocoResult, Bool)], Int)]
tpAndFps'
      tpAndFps :: [(CocoResult, Bool)]
tpAndFps = ((CocoResult, Bool) -> (CocoResult, Bool) -> Ordering)
-> [(CocoResult, Bool)] -> [(CocoResult, Bool)]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy (\(CocoResult, Bool)
res0 (CocoResult, Bool)
res1 -> Score -> Score -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (CocoResult -> Score
cocoResultScore ((CocoResult, Bool) -> CocoResult
forall a b. (a, b) -> a
fst (CocoResult, Bool)
res1)) (CocoResult -> Score
cocoResultScore ((CocoResult, Bool) -> CocoResult
forall a b. (a, b) -> a
fst (CocoResult, Bool)
res0))) ([(CocoResult, Bool)] -> [(CocoResult, Bool)])
-> [(CocoResult, Bool)] -> [(CocoResult, Bool)]
forall a b. (a -> b) -> a -> b
$ [[(CocoResult, Bool)]] -> [(CocoResult, Bool)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(CocoResult, Bool)]] -> [(CocoResult, Bool)])
-> [[(CocoResult, Bool)]] -> [(CocoResult, Bool)]
forall a b. (a -> b) -> a -> b
$ (([(CocoResult, Bool)], Int) -> [(CocoResult, Bool)])
-> [([(CocoResult, Bool)], Int)] -> [[(CocoResult, Bool)]]
forall a b. (a -> b) -> [a] -> [b]
map ([(CocoResult, Bool)], Int) -> [(CocoResult, Bool)]
forall a b. (a, b) -> a
fst [([(CocoResult, Bool)], Int)]
tpAndFps'
      precisionRecallCurve :: [(CocoResult, Bool)] -> Int -> Int -> [(Double, Double, Score)]
      precisionRecallCurve :: [(CocoResult, Bool)] -> Int -> Int -> [(Double, Double, Score)]
precisionRecallCurve [] Int
_ Int
_ = []
      precisionRecallCurve ((CocoResult, Bool)
x : [(CocoResult, Bool)]
xs) Int
accTps Int
accNum =
        (Double
precision, Double
recall, CocoResult -> Score
cocoResultScore ((CocoResult, Bool) -> CocoResult
forall a b. (a, b) -> a
fst (CocoResult, Bool)
x)) (Double, Double, Score)
-> [(Double, Double, Score)] -> [(Double, Double, Score)]
forall a. a -> [a] -> [a]
: [(CocoResult, Bool)] -> Int -> Int -> [(Double, Double, Score)]
precisionRecallCurve [(CocoResult, Bool)]
xs Int
accTps' Int
accNum'
        where
          accTps' :: Int
accTps' = if (CocoResult, Bool) -> Bool
forall a b. (a, b) -> b
snd (CocoResult, Bool)
x then Int
accTps Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1 else Int
accTps
          accNum' :: Int
accNum' = Int
accNum Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
          precision :: Double
precision = Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
accTps' Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
accNum'
          recall :: Double
recall = Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
accTps' Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
numOfGroundTruths
      precisionRecallCurve' :: [(Double, Double, Score)]
precisionRecallCurve' = [(Double, Double, Score)] -> [(Double, Double, Score)]
forall a. [a] -> [a]
reverse ([(Double, Double, Score)] -> [(Double, Double, Score)])
-> [(Double, Double, Score)] -> [(Double, Double, Score)]
forall a b. (a -> b) -> a -> b
$ [(CocoResult, Bool)] -> Int -> Int -> [(Double, Double, Score)]
precisionRecallCurve [(CocoResult, Bool)]
tpAndFps Int
0 Int
0
      f1 :: [(Double, Double, Score)] -> Double
      f1 :: [(Double, Double, Score)] -> Double
f1 [] = Double
0
      f1 ((Double
precision, Double
recall, Score
score) : [(Double, Double, Score)]
xs) = 
        if Score
score Score -> Score -> Bool
forall a. Ord a => a -> a -> Bool
>= Score
scoreThresh
          then Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* (Double
precision Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
recall) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ (Double
precision Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
recall)
          else [(Double, Double, Score)] -> Double
f1 [(Double, Double, Score)]
xs
   in [(Double, Double, Score)] -> Double
f1 [(Double, Double, Score)]
precisionRecallCurve'

mF1 :: CocoMap -> IOU -> Score -> (Double, [(CategoryId, Double)])
mF1 :: CocoMap -> IOU -> Score -> (Double, [(CategoryId, Double)])
mF1 cocoMap :: CocoMap
cocoMap@CocoMap {String
[CategoryId]
[ImageId]
Map String [ImageId]
Map CategoryId CocoCategory
Map ImageId String
Map ImageId [CocoResult]
Map ImageId [CocoAnnotation]
Map ImageId CocoImage
Coco
cocoMapImageId :: CocoMap -> Map String [ImageId]
cocoMapCocoImage :: CocoMap -> Map ImageId CocoImage
cocoMapCocoAnnotation :: CocoMap -> Map ImageId [CocoAnnotation]
cocoMapCocoCategory :: CocoMap -> Map CategoryId CocoCategory
cocoMapCocoResult :: CocoMap -> Map ImageId [CocoResult]
cocoMapFilepath :: CocoMap -> Map ImageId String
cocoMapImageIds :: CocoMap -> [ImageId]
cocoMapCategoryIds :: CocoMap -> [CategoryId]
cocoMapCoco :: CocoMap -> Coco
cocoMapCocoFile :: CocoMap -> String
cocoMapCocoResultFile :: CocoMap -> String
cocoMapImageId :: Map String [ImageId]
cocoMapCocoImage :: Map ImageId CocoImage
cocoMapCocoAnnotation :: Map ImageId [CocoAnnotation]
cocoMapCocoCategory :: Map CategoryId CocoCategory
cocoMapCocoResult :: Map ImageId [CocoResult]
cocoMapFilepath :: Map ImageId String
cocoMapImageIds :: [ImageId]
cocoMapCategoryIds :: [CategoryId]
cocoMapCoco :: Coco
cocoMapCocoFile :: String
cocoMapCocoResultFile :: String
..} IOU
iouThresh Score
scoreThresh =
  let categoryIds :: [CategoryId]
categoryIds = [CategoryId]
cocoMapCategoryIds
      f1s :: [Double]
f1s = (CategoryId -> Double) -> [CategoryId] -> [Double]
forall a b. (a -> b) -> [a] -> [b]
map (\CategoryId
categoryId -> CocoMap -> CategoryId -> IOU -> Score -> Double
f1ForCategory CocoMap
cocoMap CategoryId
categoryId IOU
iouThresh Score
scoreThresh) [CategoryId]
categoryIds
      f1s' :: [Double]
f1s' = [Double]
f1s [Double] -> Strategy [Double] -> [Double]
forall a. a -> Strategy a -> a
`using` Strategy Double -> Strategy [Double]
forall a. Strategy a -> Strategy [a]
parList Strategy Double
forall a. NFData a => Strategy a
rdeepseq
   in ([Double] -> Double
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [Double]
f1s' Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Double] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Double]
f1s'), [CategoryId] -> [Double] -> [(CategoryId, Double)]
forall a b. [a] -> [b] -> [(a, b)]
zip [CategoryId]
categoryIds [Double]
f1s')

sortAndGroup :: (Ord k) => [(k, v)] -> Map k [v]
sortAndGroup :: forall k v. Ord k => [(k, v)] -> Map k [v]
sortAndGroup [(k, v)]
assocs = ([v] -> [v] -> [v]) -> [(k, [v])] -> Map k [v]
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith [v] -> [v] -> [v]
forall a. [a] -> [a] -> [a]
(++) [(k
k, [v
v]) | (k
k, v
v) <- [(k, v)]
assocs]

average :: forall a f. (Num a, Foldable f, Fractional a) => f a -> a
average :: forall a (f :: * -> *).
(Num a, Foldable f, Fractional a) =>
f a -> a
average f a
xs
  | f a -> Bool
forall a. f a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null f a
xs = a
0
  | Bool
otherwise =
      (a -> a -> a) -> (a, a) -> a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry a -> a -> a
forall a. Fractional a => a -> a -> a
(/)
        ((a, a) -> a) -> (f a -> (a, a)) -> f a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a, a) -> a -> (a, a)) -> (a, a) -> f a -> (a, a)
forall b a. (b -> a -> b) -> b -> f a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\(!a
total, !a
count) a
x -> (a
total a -> a -> a
forall a. Num a => a -> a -> a
+ a
x, a
count a -> a -> a
forall a. Num a => a -> a -> a
+ a
1)) (a
0, a
0)
        (f a -> a) -> f a -> a
forall a b. (a -> b) -> a -> b
$ f a
xs