Merge pull request #12 from CC-RMD-EpiBio/initial

Initial

Author: joshchangNIH

libfabulouscatpy/cat/itemselection.py

@@ -292,10 +292,10 @@ def _next_scored_item(
 
         criterion = self.criterion(scoring=self.scoring, items = un_items, scale=scale)
 
-        variance = list(criterion.values())
+        criterion = list(criterion.values())
 
-        variance /= np.max(variance)
-        probs = np.exp(-variance / self.temperature)
+        criterion -= np.max(criterion)
+        probs = np.exp(criterion / self.temperature)
         probs /= np.sum(probs)
 
         if self.deterministic:

libfabulouscatpy/cat/itemselectors/fisher.py

@@ -88,9 +88,7 @@ def criterion(self, scoring: BayesianScoring, items: list[dict], scale=None) ->
 
         return fish_scored
 
-
-
-class StochasticFisherItemSelector(ItemSelector):
+class StochasticFisherItemSelector(FisherItemSelector):
 
     description = """Selection based on Fisher information"""
 

libfabulouscatpy/cat/itemselectors/globalinfo.py

@@ -10,32 +10,32 @@
 # of Health and Human Services, which is making the software available to the
 # public for any commercial or non-commercial purpose under the following
 # open-source BSD license.
-# 
+#
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are met:
-# 
+#
 # (1) Redistributions of source code must retain this copyright
 # notice, this list of conditions and the following disclaimer.
-# 
+#
 # (2) Redistributions in binary form must reproduce this copyright
 # notice, this list of conditions and the following disclaimer in the
 # documentation and/or other materials provided with the distribution.
-# 
+#
 # (3) Neither the names of the National Institutes of Health Clinical
 # Center, the National Institutes of Health, the U.S. Department of
 # Health and Human Services, nor the names of any of the software
 # developers may be used to endorse or promote products derived from
 # this software without specific prior written permission.
-# 
+#
 # (4) Please acknowledge NIHCC as the source of this software by including
 # the phrase "Courtesy of the U.S. National Institutes of Health Clinical
 # Center"or "Source: U.S. National Institutes of Health Clinical Center."
-# 
+#
 # THIS SOFTWARE IS PROVIDED BY THE U.S. GOVERNMENT AND CONTRIBUTORS "AS
 # IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 # PARTICULAR PURPOSE ARE DISCLAIMED.
-# 
+#
 # You are under no obligation whatsoever to provide any bug fixes,
 # patches, or upgrades to the features, functionality or performance of
 # the source code ("Enhancements") to anyone; however, if you choose to
@@ -54,6 +54,7 @@
 import numpy as np
 
 from libfabulouscatpy.cat.itemselection import ItemSelector
+from libfabulouscatpy.cat.session import CatSessionTracker
 from libfabulouscatpy.irt.scoring import BayesianScoring
 
 
@@ -67,14 +68,14 @@ def __init__(self, scoring, deterministic=True, hybrid=False, **kwargs):
         self.hybrid = hybrid
         self.deterministic = deterministic
 
-    def criterion(self, scoring: BayesianScoring, items: list[dict], scale=None) -> dict[str: Any]:
-
+    def criterion(
+        self, scoring: BayesianScoring, items: list[dict], scale=None
+    ) -> dict[str:Any]:
         """
         Parameters: session: instance of CatSession
         Returns:    item dictionary entry or None
         """
 
-
         unresponded = [i for i in items if "scales" in i.keys()]
         in_scale = [i for i in unresponded if scale in i["scales"].keys()]
 
@@ -105,12 +106,58 @@ def criterion(self, scoring: BayesianScoring, items: list[dict], scale=None) ->
         )[
             :, unresponded_ndx, :
         ]  #
-        
+
         p_itemized = np.exp(lp_itemized)
         pi_density = scoring.scores[scale].density
 
-        criterion = np.sum(p_itemized*(lp_itemized - lp_point)*pi_density[:, np.newaxis, np.newaxis], axis=0)
+        criterion = np.trapz(
+            p_itemized
+            * (lp_itemized - lp_point)
+            * pi_density[:, np.newaxis, np.newaxis],
+            x=scoring.interpolation_pts[scale],
+            axis=0,
+        )
         criterion = np.sum(criterion, axis=-1)
-        criterion = dict(zip([x['item'] for x in items], criterion))
+        criterion = dict(zip([x["item"] for x in items], criterion))
         return criterion
-    
+
+    def _next_scored_item(
+        self, tracker: CatSessionTracker, scale=None
+    ) -> dict[str : dict[str:Any]]:
+
+        scale = self.next_scale(tracker)
+        un_items = self.un_items(tracker, scale)
+
+        if un_items is None:
+            # Not sure if this can happen under normal testing, but included as
+            # a safety feature.
+            return None
+
+        trait = tracker.scores[scale]
+        trait = 0.0 if trait is None else trait
+        error = tracker.errors[scale]
+        error = 100.0 if error is None else error
+
+        criterion = self.criterion(scoring=self.scoring, items=un_items, scale=scale)
+        valid_items = [x["item"] for x in un_items]
+        items = []
+        Delta = []
+        for k, v in criterion.items():
+            if k in valid_items:
+                items += [k]
+                Delta += [v]
+        if len(items) == 0:
+            return {}
+        Delta -= np.max(Delta)
+        probs = np.exp(Delta / self.temperature)
+        probs /= np.sum(probs)
+
+        if self.deterministic or (self.hybrid and ((self.scoring.n_scored[scale] > 3))):
+            ndx = np.argmax(probs)
+        else:
+            ndx = np.random.choice(np.arange(len(criterion.keys())), p=probs)
+        result = list(criterion.keys())[ndx]
+        for i in un_items:
+            if i["item"] == result:
+                return i
+        return {}

libfabulouscatpy/cat/itemselectors/kl.py

@@ -104,15 +104,19 @@ def criterion(self, scoring: BayesianScoring, items: list[dict], scale=None) ->
         p_itemized = np.exp(lp_itemized)
         pi_density = scoring.scores[scale].density
 
-        lp_infty = lp_itemized + energy[:, np.newaxis, np.newaxis]
+        # lp_infty = lp_itemized + energy[:, np.newaxis, np.newaxis]
+        lp_infty = 0.5*lp_itemized + energy[:, np.newaxis, np.newaxis] * (lp_itemized.shape[1] - 1)/2
         # N_grid x N_item x K
         expected_lp_infty = np.sum(lp_infty*p_itemized, axis=-1, keepdims=True)
         expected_lp_infty = np.sum(expected_lp_infty, axis=-2, keepdims=True)
-        # N_grid x N_item x 1
+        # shift it so that it is closer to the running estimate
+        
+        
+        # N_grid x 1 x 1
         pi_infty = np.exp(expected_lp_infty - np.max(expected_lp_infty, axis=0, keepdims=True))
         pi_infty /= np.trapz(
             y=pi_infty, x=scoring.interpolation_pts[scale], axis=0
-        ) # N_grid x N_item x 1
+        ) # N_grid x 1 x 1
         ##########
         # $\pi_\infty$ is computed
         ########
@@ -223,15 +227,17 @@ def criterion(self, scoring: BayesianScoring, items: list[dict], scale=None) ->
         p_itemized = np.exp(lp_itemized)
         pi_density = scoring.scores[scale].density
 
-        lp_infty = lp_itemized + energy[:, np.newaxis, np.newaxis]
+        # lp_infty = lp_itemized + energy[:, np.newaxis, np.newaxis]
+        lp_infty = 0.5*lp_itemized + energy[:, np.newaxis, np.newaxis] * (lp_itemized.shape[1] - 1)/2
+
         # N_grid x N_item x K
         expected_lp_infty = np.sum(lp_infty*p_itemized, axis=-1, keepdims=True)
         # N_grid x N_item x 1
         expected_lp_infty = np.sum(expected_lp_infty, axis=-2, keepdims=True)
         pi_infty = np.exp(expected_lp_infty - np.max(expected_lp_infty, axis=0, keepdims=True))
         pi_infty /= np.trapz(
             y=pi_infty, x=scoring.interpolation_pts[scale], axis=0
-        ) # N_grid x N_item x 1
+        ) # N_grid x 1 x 1
         ##########
         # $\pi_\infty$ is computed
         ########

libfabulouscatpy/cat/itemselectors/variance.py

@@ -38,13 +38,16 @@ def criterion(self, scoring: BayesianScoring, items: list[dict], scale=None) ->
 
         # previously observed
         energy = self.scoring.log_like[scale] + self.scoring.log_prior[scale]
+        pi_now = scoring.scores[scale].density
 
         ###
 
         #######
         # Future
 
         lp_infty = log_ell + energy[:, np.newaxis, np.newaxis]
+        p_now = np.exp(log_ell)
+        p_now = np.sum(pi_now[:, np.newaxis, np.newaxis]*p_now, axis=0)
         pi_infty = np.exp(lp_infty - np.max(lp_infty, axis=0, keepdims=True))
         pi_infty /= np.trapz(
             y=pi_infty, x=self.scoring.interpolation_pts[scale], axis=0
@@ -62,9 +65,9 @@ def criterion(self, scoring: BayesianScoring, items: list[dict], scale=None) ->
             x=self.scoring.interpolation_pts[scale],
             axis=0,
         )
+        mean = np.sum(mean*p_now, axis=-1)
+        second = np.sum(second*p_now, axis=-1)
         variance = second - mean**2
-        variance = np.sum(variance * np.exp(log_ell) * pi_infty, axis=-1)
-        variance = np.sum(variance, axis=0)
 
         criterion = dict(zip([x['item'] for x in items], variance))
         return criterion
@@ -93,7 +96,7 @@ def _next_scored_item(
         variance = list(criterion.values())
 
         variance /= np.max(variance)
-        probs = np.exp(-variance) ** (1 / self.temperature)
+        probs = np.exp(-variance / self.temperature)
         probs /= np.sum(probs)
 
         if self.deterministic: