Packing a bin online to maximize the total number of items

A bin of capacity 1 and a nite sequence of items of\ud sizes a1; a2; : : : are considered, where the items are given one by one\ud without information about the future. An online algorithm A must\ud irrevocably decide whether or not to put an item into the bin whenever\ud it is presented. The goal is to maximize the number of items collected.\ud A is f-competitive for some function f if n() f(nA()) holds for all\ud sequences , where n is the (theoretical) optimum and nA the number\ud of items collected by A.\ud A necessary condition on f for the existence of an f-competitive\ud (possibly randomized) online algorithm is given. On the other hand,\ud this condition is seen to guarantee the existence of a deterministic online\ud algorithm that is "almost" f-competitive in a well-dened sense

On the Approximate Core and Nucleon of Flow Games

The flow game with public arcs is a cooperative revenue game derived from a flow network. In this game, each player possesses an arc, while certain arcs, known as public arcs, are not owned by any specific player and are accessible to any coalition. The aim of this game is to maximize the flow that can be routed in the network through strategic coalition formation. By exploring its connection to the maximum partially disjoint path problem, we investigate the approximate core and nucleon of the flow game with public arcs. The approximate core is an extension of the core that allows for some deviation in group rationality, while the nucleon is a multiplicative analogue of the nucleolus. In this paper, we provide two complete characterizations for the optimal approximate core and show that the nucleon can be computed in polynomial time

Integrality gap analysis for bin packing games

A cooperative bin packing game is an $N$-person game, where the player set $N$ consists of $k$ bins of capacity 1 each and $n$ items of sizes $a_1,\dots,a_n$. The value $v(S)$ of a coalition $S$ of players is defined to be the maximum total size of items in $S$ that can be packed into the bins of $S$. We analyze the integrality gap of the corresponding 0–1 integer program of the value $v(N)$, thereby presenting an alternative proof for the non-emptiness of the 1/3-core for all bin packing games. Further, we show how to improve this bound $\epsilon\leq1/3$ (slightly) and point out that the conclusion in Matsui (2000) [9] is wrong (claiming that the bound 1/3 was tight). We conjecture that the true best possible value is $\epsilon=1/7$. The results are obtained using a new “rounding technique” that we develop to derive good (integral) packings from given fractional ones

Parametrisierte Algorithmen für Ganzzahlige Lineare Programme und deren Anwendungen für Zuweisungsprobleme

This thesis is concerned with solving NP-hard problems. We consider two prominent strategies of coping with such computationally hard questions efficiently. The first approach aims to design approximation algorithms, that is, we are content to find good, but non-optimal solutions in polynomial time. The second strategy is called Fixed-Parameter Tractability (FPT) and considers parameters of the instance to capture the hardness of the problem and by that, obtain efficient algorithms with respect to the remaining input. This thesis employs both strategies jointly to develop efficient approximation and exact algorithms using parameterization and modeling the problem as structured integer linear programs (ILPs), which can be solved in FPT. In the first part of this work, we concentrate on these well-structured ILPs. On the one hand, we develop an efficient algorithm for block-structured integer linear programs called n-fold ILPs. On the other hand, we investigate the similarly block-structured 2-stage stochastic ILPs and prove conditional lower bounds regarding the running time of any algorithm solving them that match the best known upper bounds. We also prove the tightness of certain structural parameters called sensitivity and proximity for ILPs which arise from combinatorial questions such as allocation problems. The second part utilizes n-fold ILPs and structural properties to add to and improve upon known results for Scheduling and Bin Packing problems. We design exact FPT algorithms for the Scheduling With Clique Incompatibilities, Bin Packing, and Multiple Knapsack problems. Further, we provide constant-factor approximation algorithms and polynomial time approximation schemes (PTAS) for the Class Constraint Scheduling problems. Broadening our scope, we also investigate this problem and the closely related Cardinality Constraint Scheduling problem in the online setting and derive lower bounds for the approximation ratios as well as a PTAS for them. Altogether, this thesis contributes to the knowledge about structured ILPs, proves their limits and reaffirms their usefulness for a plethora of allocation problems. In doing so, various new and improved algorithms with respect to the running time or approximation quality emerge

The convergence time for selfish bin packing

In classic bin packing, the objective is to partition a set of n items with positive rational sizes in (0, 1] into a minimum number of subsets called bins, such that the total size of the items of each bin at most 1. We study a bin packing game where the cost of each bin is 1, and given a valid packing of the items, each item has a cost associated with it, such that the items that are packed into a bin share its cost equally. We find tight bounds on the exact worst-case number of steps in processes of convergence to pure Nash equilibria. Those are processes that are given an arbitrary packing as an initial packing. As long as there exists an item that can reduce its cost by moving from its bin to another bin, in each step, a controller selects such an item and instructs it to perform such a beneficial move. The process converges when no further beneficial moves exist. The tight function of n that we find is in Θ(n 3/2 ). This improves the previous bound of Ma et al. [14], who showed an upper bound of O(n 2)

GPUTreeShap: massively parallel exact calculation of SHAP scores for tree ensembles

SHapley Additive exPlanation (SHAP) values (Lundberg & Lee, 2017) provide a game theoretic interpretation of the predictions of machine learning models based on Shapley values (Shapley, 1953). While exact calculation of SHAP values is computationally intractable in general, a recursive polynomial-time algorithm called TreeShap (Lundberg et al., 2020) is available for decision tree models. However, despite its polynomial time complexity, TreeShap can become a significant bottleneck in practical machine learning pipelines when applied to large decision tree ensembles. Unfortunately, the complicated TreeShap algorithm is difficult to map to hardware accelerators such as GPUs. In this work, we present GPUTreeShap, a reformulated TreeShap algorithm suitable for massively parallel computation on graphics processing units. Our approach first preprocesses each decision tree to isolate variable sized sub-problems from the original recursive algorithm, then solves a bin packing problem, and finally maps sub-problems to single-instruction, multiple-thread (SIMT) tasks for parallel execution with specialised hardware instructions. With a single NVIDIA Tesla V100-32 GPU, we achieve speedups of up to 19× for SHAP values, and speedups of up to 340× for SHAP interaction values, over a state-of-the-art multi-core CPU implementation executed on two 20-core Xeon E5-2698 v4 2.2 GHz CPUs. We also experiment with multi-GPU computing using eight V100 GPUs, demonstrating throughput of 1.2 M rows per second—equivalent CPU-based performance is estimated to require 6850 CPU cores