FasterRisk: Fast and Accurate Interpretable Risk Scores
Anonymous Author(s)
AfﬁliationAddress email
Abstract
Over the last century, risk scores have been the most popular form of predictivemodel used in healthcare and criminal justice.
Risk scores are sparse linear modelswith integer coefﬁcients; often these models can be memorized or placed on anindex card.
Typically, risk scores have been created either without data or byrounding logistic regression coefﬁcients, but these methods do not reliably producehigh-quality risk scores.
Recent work used mathematical programming, whichis computationally slow.
We introduce an approach for efﬁciently producing acollection of high-quality risk scores learned from data.
Our approach involvesproducing a pool of almost-optimal sparse continuous solutions, each with adifferent support set, using a beam-search algorithm.
Each of these continuoussolutions is transformed into a separate risk score through a “star search,” where arange of multipliers are considered before rounding the coefﬁcients sequentiallyto maintain low logistic loss.
Our algorithm returns all of these high-quality riskscores for the user to consider.
This method completes within minutes and can beimpactful in a broad variety of applications.
Introduction
Risk scores are sparse linear models with integer coefﬁcients that predict risks.
They are possiblythe most popular form of predictive model for high stakes decisions through the last century and arethe standard form of model used in criminal justice [3, 19] and medicine [17, 23, 29, 26, 31].
Their history dates back to at least the criminal justice work of Burgess [7], where individuals were assigned integer point scores between 0 and 21 based on their criminal history anddemographics that determined their probability of “making good or of failing upon parole.”
Oval Shape
points ...
Irregular Shape
4 points + ...
Circumscribed Margin
-5 points + ...
Spiculated Margin
2 points + ...
Age 3 points +
SCORE =
SCORE - - - - - -
RISK 6.0% 10.6% 13.8% 17.9% 22.8% 28.6%
SCORE      5 RISK 35.2% 42.4% 50.0% 57.6% 64.8% 71.4%
Other famous risk scores are arguably the most widely-used predictive models in healthcare.
Theseinclude the APGAR score [2], developed in 1952 and given to newborns, and the CHADS 2 score [16],which estimates stroke risk foratrial ﬁbrillation patients.
Figure1 shows an example risk score,which estimates risk of a breast lesion being malignant.
Risk scores have the beneﬁt of being easily memorized; usually theirnames reveal the full model – forinstance, the factors in CHADS are past C hronic heart failure, H ypertension, A ge  75 years, D iabetes, and past S troke (where paststroke receives 2 points and the others each receive 1 point).
For risk scores, counterfactuals areoften trivial to compute, even without a calculator.
Also, checking that the data and calculations arecorrect is easier with risk scores than with other approaches.
In short, risk scores have been createdby humans for a century to support a huge spectrum of applications, because humans ﬁnd them easyto understand.
Traditionally, risk scores have been created in two main ways: (1) without data, with expert knowledgeonly (and validated only afterwards on data), and (2) using a semi-manual process involving manualfeature selection and rounding of logistic regression coefﬁcients.
That is, these approaches relyheavily on domain expertise and rely little on data.
Unfortunately, the converse (relying on data) leadsto computationally hard problems: optimizing risk scores over a global objective on data is NP-hard,because in order to produce integer-valued scores, the feasible region must be the integer lattice.
Therehave been only a few approaches to design risk scores automatically [4, 5, 8, 9, 15, 27, 28, 33, 34, 35],but each of these has a ﬂaw that limits its use in practice: the optimization-based approaches usemathematical programming solvers (which require a license) that are slow and scale poorly, and theother methods are randomized greedy algorithms, producing fast but much lower-quality solutions.
We need an approach that exhibits the best of both worlds: speed fast enough to operate in a fewminutes on a laptop and optimization and search capability as powerful as that of the mathematicalprogramming tools.
Our method, FasterRisk, lies at this intersection.
One may wonder why simple rounding of ` 1 -regularized logistic regression coefﬁcients does notyield sufﬁciently good risk scores.
Past works [32, 34] explain this as follows: the sheer amount of ` 1regularization needed to get a very sparse solution leads to large biases and worse loss values, androunding goes against the performance gradient.
For example, consider a set of ` 1 coefﬁcients foundas [1.45, .87, .83, .47, .23, .15, ... ].
This model would be worse than its unregularized counterpart,because of the bias due to the large ` 1 term.
Its rounded solution is [1,1,1,0,0,0,..], which leads toeven worse loss.
One could attempt instead to multiply by a constant and then round, but whichconstant?
There are an inﬁnite number of choices.
And, even if some value of the multiplier led tominimal loss due to rounding, the bias from the ` 1 term still limits the quality of the solution.
The algorithm presented here does not have these disadvantages.
The steps are: (1) Fast subset searchwith ` 0 optimization (avoiding the bias from ` 1 ).
This requires the solution of an NP-hard problem,but our fast subset selection algorithm is able to solve this quickly.
We proceed from this accuratesparse continuous solution, preserving both sparseness and accuracy in the next steps.
(2) Find a poolof diverse continuous sparse solutions that are almost as good as the solution found in (1) but withdifferent support sets.
(3) A “star ray” search, where we search for feasible integer-valued solutionsalong multipliers of each item in the pool from (2).
By using multipliers, the search space resemblesa ray of a star because it extends each coefﬁcient in the pool outwards from the origin to searchfor solutions.
To ﬁnd integer solutions, we perform a local search (a form of sequential rounding).
This method yields high performance solutions: we provide a theoretical upper bound on the lossdifference between the continuous sparse solution and the rounded integer sparse solution.
Through extensive experiments, we show that our proposed method is computationally fast andproduces high-quality integer solutions.
This work thus provides valuable and novel tools to createrisk scores for professionals in many different ﬁelds, such as healthcare, ﬁnance, and criminal justice.
Related Work
Optimization-based approaches: Risk scores, which model P ( y = 1 | x ) , are different than thresholdclassiﬁers, which predict either y = 1 or y =
1 given x .
Most work in the area of optimization ofinteger-valued sparse linear models focuses on classiﬁers, not risk scores [4, 5, 8, 27, 28, 32, 35, 37].
This difference is important, because a classiﬁer generally cannot be calibrated well for use in riskscoring: only its single decision point is optimized.
Despite this, several works use the hinge lossto calibrate predictions [5, 8, 27].
All of these optimization-based algorithms use mathematicalprogramming solvers (i.e., integer programming solvers), which tend to be slow and cannot be usedon larger problems.
However, they can handle both feature selection and integer constraints.
To directly optimize risk scores, typically the logistic loss would be used.
The RiskSLIM algorithm[34] optimizes the logistic loss regularized with ` 0 regularization, subject to integer constraints on thecoefﬁcients.
RiskSLIM uses callbacks to a MIP solver, alternating between solving linear programs and using branch-and-cut to divide and reduce the search space.
The branch-and-cut procedure needsto keep track of unsolved nodes, whose number increases exponentially with the size of the featurespace.
Thus, RiskSLIM’s major challenge is scalability.
Local search-based approaches: As discussed earlier, a natural way to produce a scoring system orrisk score is by selecting features manually and rounding logistic regression coefﬁcients or hinge-losssolutions to integers [9, 10, 34].
While rounding is fast, rounding errors discussed earlier can cause thesolution quality to be much worse than that of the optimization-based approaches.
Several works haveproposed improvements over traditional rounding.
In Randomized Rounding [9], each coefﬁcientis rounded up or down randomly, based on its continuous coefﬁcient value.
However, randomizedrounding does not seem to perform well in practice.
Chevaleyre [9] also proposed Greedy Rounding,where coefﬁcients are rounded sequentially.
While this technique provides theoretical guaranteesfor greedy rounding for the hinge loss, we have identiﬁed a serious ﬂaw in this argument, renderingthe bounds incorrect (see Appendix B).
The RiskSLIM paper [34] proposed SequentialRounding,which, at each iteration, chooses a coefﬁcient to round up or down, making the best choice accordingto the regularized logistic loss.
This gives better solutions than other types of rounding, because thecoefﬁcients are considered together through their performance on the loss function, not independently.
A drawback of SequentialRounding is that it considers rounding up or down only to the nearestinteger from the continuous solution.
By considering multipliers , we consider a much larger spaceof possible solutions.
The idea of multipliers (i.e., “scale and round”) is used for medical scoringsystems [10], though, as far as we know, it has been used only with traditional rounding rather than
SequentialRounding, which could easily lead to poor performance, and we have seen no previouswork that studies how to perform scale-and-round in a systematic, computationally efﬁcient way.
While the general idea of scale-and-round seems simple, it is not: there are an inﬁnite number ofpossible multipliers, and, for each one, a number of possible nearby integer coefﬁcient vectors that isthe size of a hypercube, expanding exponentially in the search space.
Sampling Methods: The Bayesian method of Ertekin et al.
[15] samples scoring systems, favoringthose that are simpler and more accurate, according to a prior.
“Pooling” [34] creates multiple modelsthrough sampling along the regularization path of ElasticNet.
As discussed, when regularization istuned high enough to induce sparse solutions, it results in substantial bias and low-quality solutions(see [32, 34] for numerous experiments on this point).
Note that there is a literature on ﬁnding diversesolutions to optimization problems [1], but it only focuses on linear objective functions.
Contributions : Our contributions include the three-step framework for producing risk scores, thebeam-search based algorithm for logistic regression with bounded coefﬁcients, the search algorithmto ﬁnd pools of diverse high-quality continuous solutions, the star search technique using multipliers,and a theorem guaranteeing the quality of the star search results.
Limitations: FasterRisk does not provide provably optimal solutions to an NP-hard problem, whichis how it is able to perform in reasonable time for practitioner’s use.
FasterRisk’s models should notbe interpreted as causal.
FasterRisk creates very sparse generalized additive models and thus haslimited capacity.
FasterRisk’s models inherit ﬂaws from data it was trained on.
FasterRisk is not yetcustomized to a given application, which can be done in future work.
Methodology
Deﬁne dataset D = { 1 , x i , y i } ni =1 (1 is a static feature corresponding to the intercept) and scaleddataset as 1 m ⇥ D
= { 1 m , 1 m x i , y i } ni =1 .
Our goal is to produce high-quality risk scores within a few 134 minutes on a small personal computer.
We start with an optimization problem similar to RiskSLIM’s[34], which minimizes the logistic loss subject to sparsity constraints and integer coefﬁcients:min w ,w 0 L ( w , w 0 , D ) , where L ( w , w 0 , D ) = P ni =1 log(1 + exp(  y i ( x Ti w + w 0 )))
(1) such that k w k 0  k and w 2 Z p , 8 j 2 [1 , .., p ] w j
[Equation]
[
[Equation]
, 5] , w
[Equation]
Z .
In practice, the range of these box constraints [  5 , 5] is user-deﬁned and can be different for eachcoefﬁcient.
(We use 5 for ease of exposition.)
The k w k 0 or integer constraints make the problem
NP-hard, and this is a difﬁcult mixed-integer nonlinear program.
Transforming the original featuresto all possible dummy variables, as done in other methods [20], changes the model into a (ﬂexible)generalized additive model; even when transformed into risk scores, they can still be as accurate asthe best machine learning models [34, 36].
1: Call Algorithm 2 SparseBeamLR ( D , k, C, B ) to ﬁnd a high-quality solution ( w ⇤ , w ⇤ 0 ) to the sparse logistic regression problem with continuous coefﬁcients satisfying a box constraint, i.e., solve Problem (1).
(Algorithm SparseBeamLR will call Algorithm ExpandSuppBy1 as a subroutine, which grows the solution by beam search.)
2: Call[-Algorithm 
 CollectSparseDiversePool solves Problem Place its output { pool P P-]
P
Send perform line obtain solution ( w , w t ) with multiplier m t
Algorithm 3 calls Algorithm 6 AuxiliaryLossRounding conducts the step.
Return the collection of risk scores { ( w + t , w + t 0 , m t ) } t .
If desired, return only the best model according to the logistic loss.
To make the solution space substantially larger than [  5 ,  4 , ..., 4 , 5] p , we use multipliers .
Theproblem becomes:
[Equation]
◆ , where L ✓ w , w 0 ,
[Equation]
such that k w k 0  k, w 2 Z p , 8 j 2 [1 , .., p ] w
[Equation]
2 [  5 , 5] , w 0 2 Z
[Equation]
m > 0 . Note that the use of multipliers does not weaken the interpretability of the risk score: the user stillsees integer risk scores comprised of values w j 2 {  5 ,  4 , .., 4 , 5 } , w 0 2 Z
and points are computedfrom them.
Only the risk conversion table is calculated differently, as P ( Y = 1 | x )
= 1 / (1 + e  f ( x ) )
where f ( x ) = 1 m ( w T x + w 0 ) .
Our method proceeds in three steps, as outlined in Algorithm 1.
In the ﬁrst step, it approximatelysolves the following sparse logistic regression problem with a box constraint (but not integerconstraints), detailed in Section 3.1 and Algorithm 2.
[Equation]
The algorithm gives an accurate and sparse real-valued solution ( w ⇤ , w ⇤ 0 ) .
The second step produces many near-optimal sparse logistic regression solutions , again withoutinteger constraints, detailed in Section 3.2 and Algorithm 5.
Algorithm 5 uses ( w ⇤ , w ⇤ 0 ) from theﬁrst step to ﬁnd a set { ( w t , w t 0 ) } t such that for all t and a given threshold ✏ w :
[Equation]
After these steps, we have a pool of almost-optimal sparse logistic regression models.
In the thirdstep, for each coefﬁcient vector in the pool, we compute a risk score .
It is a feasible integer solution( w + t , w + t 0 ) to the following, which includes a positive multiplier m t > 0 :
[Equation]
where we derive a tight theoretical upper bound on ✏ t .
A detailed solution to (5) is shown in Algorithm6 in Appendix A.
We do this for a large range of multipliers in Algorithm 3.
This third step yields alarge collection of risk scores, all of which are approximately as accurate as the best sparse logisticregression model that can be obtained.
All steps in this process are fast and scalable.
Input dataset constraint constraint beam search and
: F ; the collection found supports as an empty set 4: F )
ExpandSuppBy
D F k do do
W
13: Pick
14: Return
3.1 High-quality Sparse Continuous Solution
There are many different approaches for sparse logistic regression, including ` 1 regularization [30],
ElasticNet [38], ` 0 regularization [12, 20], orthogonal matching pursuit (OMP) [13, 21], but noneof these approaches seem to be able to handle both the box constraints and the sparsity constraintin Problem 3, so we developed a new approach.
This approach, in Algorithm 2, SparseBeamLR,uses beam search for best subset selection: each iteration contains several coordinate descent stepsto determine whether a new variable should be added to the support, and it clips coefﬁcients tothe box
[  5 , 5] as it proceeds.
Hence the algorithm is able to determine, before committing to thenew variable, whether it is likely to decrease the loss while obeying the box constraints.
This beamsearch algorithm for solving (3) implicitly uses the assumption that one of the best models of size kimplicitly contains variables of one of the best models of size k  1 .
This type of assumption hasbeen studied in the sparse learning literature [13] (Theorem 5).
However, we are not aware of otherworks applying box constraints or beam search for sparse logistic regression.
In Appendix E, weshow that our proposed method has higher solution qualities than the OMP method presented in [13].
Algorithm 2 calls the ExpandSuppBy1 Algorithm, which has two major steps.
The detailed algorithmcan be found in Appendix A. For the ﬁrst step, given a solution w , we perform optimization on eachsingle coordinate j outside of the current support supp ( w ) :
[Equation]
We ﬁnd d ⇤ j for each j through an iterative thresholding operation, which is done on all coordinates inparallel, iterating several ( ⇠ 10 ) times:for iteration
[Equation]
where c d j = d j  1 l j r j L ( w + d j e j , w 0 , D ) , and l j is a Lipschitz constant on coordinate j .
Importantly, we can perform Equation 7 on all j where w j = 0 in parallel using matrix form.
For the second step, after the parallel single coordinate optimization is done, we pick the top Bindices ( j ’s) with the smallest logistic losses L ( w + d ⇤ j e j ) and ﬁne tune on the new support:
[Equation]
) with supp ( a
[Equation]
supp
[Equation] [Equation]
[Equation]
This can be done again using a variant of Equation 7 iteratively on all the coordinates in thenew support.
We get B pairs of ( w j new , w 0 j new ) through this ExpandSuppBy1 procedure, and thecollection of these pairs form the set W 0 in Line 8 of Algorithm 2.
The ExpandSuppBy1 method iscomputationally efﬁcient because we are doing parallel single coordinate optimization.
This givesthe ﬁne-tuning procedure a warm start.
3.2 Collect Sparse Diverse Pool
We now collect the sparse diverse pool.
In Section 3.1, our goal was to ﬁnd a sparse model ( w ⇤ , w ⇤ 0 )with the smallest logistic loss.
For high dimensional features or in the presence of highly correlatedfeatures, there could exist many sparse models with almost equally good performance [6].
Let us ﬁndthose and turn them into risk scores.
We ﬁrst predeﬁne a tolerance gap level ✏ (usually set to 0 . 3 ).
Then, we delete a feature with index j  in the support supp ( w ⇤ ) and add a new feature with indexj + .
We select each new index to be j + whose logistic loss is within the tolerance gap:
Find all j + s.t.
[Equation]
[Equation]
We ﬁne-tune the coefﬁcients on each of the new supports and then save the new solution in our pool.
Details can be found in Algorithm 5.
Swapping one feature at a time is computationally efﬁcient, andour experiments show it produces sufﬁciently diverse pools over many datasets.
3.3 “Star” Search for Integer Solutions
C max | w | as discussed in Section 3.3.
If m max = 1 , set m
min
m max > 1 , set m min
N m equally spaced multiplier values m l 2 [ m min , m max ] for l 2 [1 , ..., N m ] and
call this set
The last challenge is how to get an integer solution from a continuous solution.
To achieve this, weuse a “star” search that searches along each “ray” of the star, extending each continuous solutionoutward from the origin using many values of a multiplier, as shown in Algorithm 3.
The star searchprovides much more ﬂexibility in ﬁnding a good integer solution than simple rounding.
The largestmultiplier m max is set to 5 / max( | w ⇤ | ) which will take one of the coefﬁcients to the boundary of thebox constraint at 5.
We set the smallest multiplier to be 1.0 and pick N m (usually 20) equally spacedpoints from [ m min , m max ] .
If m max = 1 , we set m min = 0 .
5 to allow shrinkage of the coefﬁcients.
We scale the coefﬁcients and datasets with each multiplier and round the coefﬁcients to integers usingthe sequential rounding technique in Algorithm 6.
For each continuous solution (each “ray” of the“star”), we report the integer solution and multiplier with the smallest logistic loss.
This process yieldsour collection of risk scores.
Note here that a standard line search along the multiplier would notwork because the rounding error is highly non-convex.
We brieﬂy discuss how the sequential rounding technique works.
Details of this method can be foundin
Appendix A. We initialize w + = w .
Then we round the fractional part of w + one coordinate at atime.
At each step, some of the w + j ’s are integer-valued (so w + j  w j is nonzero) and we pick thecoordinate and rounding operation (either ﬂoor or ceil) based on which can minimize the followingobjective function, where we will round to an integer at coordinate r ⇤ :
[Equation]
subject to r 2 { j | w + j / 2 Z } and v 2 { b w + r c , d w + r e } , where l i is the Lipschitz constant restricted to the rounding interval 1 and can be computed asl i = 1 / (1 + exp
( y i x
Ti  i )) with  ij =
b w j c if y i x ij > 0 and  ij = d w j e otherwise.
After weselect r ⇤ and ﬁnd value v ⇤ , we update w + through w + r ⇤ = v ⇤ .
We repeat this process until w + ison the integer lattice: w + 2 Z p .
The objective function in Equation 10 can be understood as anauxiliary upper bound of the logistic loss.
Our algorithm provides an upper bound on the differencebetween the logistic losses of the continuous solution and the ﬁnal rounded solution before we startthe rounding algorithm (See Theorem 3.1).
Additionally, during the sequential rounding procedure,we do not need to perform expensive operations such as logarithms or exponentials as required by thelogistic loss function; the bound and auxiliary function require only sums of squares, not logarithmsor exponentials.
Its derivation and proof are in Appendix C.
Theorem 3.1.
Let w be the real-valued coefﬁcients for the logistic regression model with objectivefunction L ( w ) =
P ni = [Equation] log(1 + exp(  y i x Ti w ))
(the intercept is incorporated).
Let w + be theinteger-valued coefﬁcients returned by the AuxiliaryLossRounding method.
Furthermore, let u j =w j  b w j c .
Let l i = 1 / (1 + exp
( y i x
Ti  i )) with  ij =
b w j c if y i x ij > 0 and  ij = d w j e otherwise.
Then, we have an upper bound on the difference between the loss L ( w ) and the loss L ( w + ) :
[Equation]
Note.
Our method has a higher prediction capacity than RiskSLIM: its search space is much larger.
Compared to RiskSLIM, our use of the multiplier permits a number of solutions that grows exponentially in k as we increase the multiplier.
To see this, consider that for each support of k features, sincelogistic loss is convex, it contains a hypersphere in coefﬁcient space.
The volume of that hypersphereis (as usual) V = ⇡ k/ 2  ( k 2 +1)
r k where r is the radius of the hypersphere.
If we increase the multiplier to2, the grid becomes ﬁner by a factor of 2, which is equivalent to increasing the radius by a factor of 2.
Thus, the volume increases by a factor of 2 k .
In general, for maximum multiplier m , the search spaceis increased by a factor of m k over RiskSLIM.
Experiments
Our experiments focus on three questions: (1) How good is FasterRisk’s solution quality comparedto baselines?
(§4.1) (2) How fast is FasterRisk compared with the state-of-the-art? (§4.2) (3) How does each of our proposed technique, including sparse beam search, diverse pool, and multipliers,contribute to our solution quality?
(see Appendix E)
We compare with RiskSLIM (the current state-of-the-art), as well as algorithms Pooled-PLR-RD,
Pooled-PLR-RSRD, Pooled-PRL-RDSP, Pooled-PLR-Rand and Pooled-PRL-RDP.
These algorithmswere all previously shown to be inferior to RiskSLIM [34].
These methods ﬁrst ﬁnd a pool of sparsecontinuous solutions using different regularizations of ElasticNet (hence the name “Pooled Penalized
Logistic Regression” – Pooled-PLR) and then round the coefﬁcients with different techniques.
Detailsare in Appendix D.3.
The best solution is chosen from this pool of integer solutions that obeysthe sparsity and box constraints and has the smallest logistic loss.
For each dataset, we perform5-fold cross validation and report training and test AUC.
Details about datasets, experimental setup,evaluation metrics, loss values, and computing platform/environment can be found in Appendix D.
More experimental results appear in Appendix E. Code from [9, 15, 27, 28] is not publicly available.
4.1 Solution Quality
We ﬁrst evaluate FasterRisk’s solution quality.
Figure 2 shows the training and test AUC on sixdatasets (results for training loss appear in Appendix E).
FasterRisk (the red line) outperforms allbaselines, consistently obtaining the highest AUC scores on both the training and test sets.
Notably,our method obtains better results than RiskSLIM, which uses a mathematical solver and is thecurrent state-of-the-art method for scoring systems.
This superior performance is due to the use ofmultipliers, which increases the complexity of the hypothesis space.
A more detailed comparisonbetween FasterRisk and RiskSLIM appears in Figure 3.
FasterRisk performs signiﬁcantly better than the other baselines for two reasons.
First, the continuoussparse solutions produced by ElasticNet are low quality for very sparse models.
Second, it is difﬁcultto obtain an exact model size by controlling ` 1 regularization.
For example, Pooled-PLR-RD and
Pooled-PLR-RDSP do not have results for model size 10 on the mammo datasets, because such amodel size does not exist in the pooled solutions after rounding.
4.2 Runtime Comparison
The major drawback of RiskSLIM is its limited scalability.
Figure 4 shows that FasterRisk (redbars) is signiﬁcantly faster than RiskSLIM (blue bars) in general.
We ran these experiments with a900 second (15 minute) timeout.
RiskSLIM ﬁnishes running on small datasets (mammo and breastcancer), but it times out on the larger datasets, timing out on models larger than 3 features for bankand spambase, larger than 4 features for adult, and larger than 7 features for mushroom.
Thus, we seethat FasterRisk is both faster and more accurate than RiskSLIM.
4.3 Example Scoring Systems
The main beneﬁt of risk scores is their interpretability.
We place a few example risk scores in Table 1to allow the reader to judge for themselves.
More risk scores examples can be found in Appendix F.
no high school diploma -
[Figure]
high school diploma only -2 points +
[Table]
age 22 to
[Table]
points
[Table]
any capital gains 3 points
[Table]
married
[Table]
[Table] [Table]
Conclusion
FasterRisk produces a collection of high-quality risk scores within minutes.
Its performance owes tothree key ideas: a better algorithm for sparsity and box-constrained continuous models, using a poolof diverse solutions, and the use of the star search, which leverages multipliers and a new sequentialrounding technique. FasterRisk is suitable for high-stakes decisions, and permits domain experts acollection of interpretable models to choose from.