vse_sim

13class Borda(Method):
14    candScore = staticmethod(mean)
15
16    nRanks = 999  # infinity
17
18    @staticmethod
19    def fillPrefOrder(
20        voter,
21        ballot,
22        whichCands=None,  # None means "all"; otherwise, an iterable of cand indexes
23        lowSlot=0,
24        nSlots=None,  # again, None means "all"
25        remainderScore=None,  # what to give candidates that don't fit in nSlots
26    ):
27
28        venum = list(enumerate(voter))
29        if whichCands:
30            venum = [venum[c] for c in whichCands]
31        prefOrder = sorted(venum, key=lambda x: -x[1])  # high to low
32        Borda.fillCands(ballot, prefOrder, lowSlot, nSlots, remainderScore)
33        # modifies ballot argument, returns nothing.
34
35    @staticmethod
36    def fillCands(
37        ballot,
38        whichCands,  # list of tuples starting with cand id, in descending order
39        lowSlot=0,
40        nSlots=None,  # again, None means "all"
41        remainderScore=None,  # what to give candidates that don't fit in nSlots
42    ):
43        if nSlots is None:
44            nSlots = len(whichCands)
45        cur = lowSlot + nSlots - 1
46        for i in range(nSlots):
47            ballot[whichCands[i][0]] = cur
48            cur -= 1
49        if remainderScore is not None:
50            i += 1
51            while i < len(whichCands):
52                ballot[whichCands[i][0]] = remainderScore
53                i += 1
54        # modifies ballot argument, returns nothing.
55
56    @staticmethod  # cls is provided explicitly, not through binding
57    @rememberBallot
58    def honBallot(cls, utils):
59        ballot = [0] * len(utils)
60        cls.fillPrefOrder(utils, ballot)
61        return ballot
62
63    @classmethod
64    def fillStratBallot(
65        cls,
66        voter,
67        polls,
68        places,
69        n,
70        stratGap,
71        ballot,
72        frontId,
73        frontResult,
74        targId,
75        targResult,
76    ):
77        """Mutates the `ballot` argument to be a strategic ballot.
78
79        >>> Borda().stratBallotFor([4,5,2,1])(Borda, Voter([-4,-5,-2,-1]))
80        [3, 0, 1, 2]
81        """
82        nRanks = min(cls.nRanks, n)
83        if stratGap <= 0:
84            ballot[frontId], ballot[targId] = (nRanks - 1), 0
85        else:
86            ballot[frontId], ballot[targId] = 0, (nRanks - 1)
87        nRanks -= 2
88        if nRanks > 0:
89            cls.fillCands(ballot, places[2:][::-1], lowSlot=1, nSlots=nRanks, remainderScore=0)
90        # (don't) return dict(strat=ballot, isStrat=isStrat, stratGap=stratGap)

248def BulletyApprovalWith(bullets=0.5, asClass=False):
249
250    class BulletyApproval((Score(1, True))):
251        bulletiness = bullets
252
253        def __str__(self):
254            return f"BulletyApproval{str(round(self.bulletiness * 100))}"
255
256        @staticmethod  # cls is provided explicitly, not through binding
257        @rememberBallot
258        def honBallot(cls, utils):
259            """Takes utilities and returns an honest ballot (on 0..10)
260
261
262            honest ballots work as expected
263                >>> Score().honBallot(Score, Voter([5,6,7]))
264                [0.0, 5.0, 10.0]
265                >>> Score().resultsFor(DeterministicModel(3)(5,3),Score().honBallot)["results"]
266                [4.0, 6.0, 5.0]
267            """
268            if random.random() > cls.bulletiness:
269                return cls.__bases__[0].honBallot(cls, utils)
270            best = max(utils)
271            return [1 if util == best else 0 for util in utils]
272
273    return BulletyApproval if asClass else BulletyApproval()

10class Chooser:
11    tallyKeys = []
12
13    def __init__(self, choice=None, subChoosers=None):
14        """Subclasses should just copy/paste this logic because
15        each will have its own parameters and so that's easiest."""
16        if choice is not None:
17            self.choice = choice
18        self.subChoosers = [] if subChoosers is None else subChoosers
19
20    def getName(self):
21        if hasattr(self, "choice"):  # only true for base class
22            # print("base")
23            return self.choice
24        if not hasattr(self, "name") or not self.name:
25            # print("generic")
26            self.name = self.__class__.__name__[:-7]  # drop the "Chooser"
27        # print("specific")
28        return self.name
29
30    def __call__(self, cls, voter, tally):
31        return self.choice
32
33    def addTallyKeys(self, tally):
34        for key in self.allTallyKeys:
35            tally[key] = 0
36
37    @cached_property
38    def myKeys(self):
39        prefix = f"{self.getName()}_"
40        return [prefix + key for key in self.tallyKeys]
41
42    @cached_property
43    def allTallyKeys(self):
44        keys = self.myKeys
45        for subChooser in self.subChoosers:
46            keys += subChooser.allTallyKeys
47        return keys
48
49    @cached_property
50    def __name__(self):
51        return self.__class__.__name__

 37class CsvBatch:
 38    @autoassign
 39    def __init__(
 40        self,
 41        model,
 42        methods,
 43        nvot,
 44        ncand,
 45        niter,
 46        baseName=None,
 47        media=truth,
 48        seed=None,
 49        force=False,
 50    ):
 51        """A harness function which creates niter elections from model and finds three kinds
 52        of utility for all methods given.
 53
 54        for instance:
 55
 56        >>> csvs = CsvBatch(PolyaModel(), [[Score(), baseRuns], [Mav(), medianRuns]], nvot=5, ncand=4, niter=3)
 57        >>> len(csvs.rows)
 58        60
 59        """
 60        rows = []
 61        emodel = str(model)
 62        if seed is None:
 63            seed = (baseName or "") + str(niter)
 64            self.seed = seed
 65        random.seed(seed)
 66        try:
 67            from git import Repo
 68
 69            repo = Repo(os.getcwd())
 70            if not force:
 71                assert not repo.is_dirty()
 72            self.repo_version = repo.head.commit.hexsha
 73        except Exception:
 74            self.repo_version = "unknown repo version"
 75        for i in range(niter):
 76            eid = uuid4()
 77            electorate = model(nvot, ncand)
 78            for method, chooserFuns in methods:
 79                results = method.resultsTable(
 80                    eid, emodel, ncand, electorate, chooserFuns, media=media
 81                )
 82                rows.extend(results)
 83            debug(i, results[1:3])
 84        self.rows = rows
 85        if baseName:
 86            self.saveFile(baseName)
 87
 88    def saveFile(self, baseName="SimResults"):
 89        """print the result of doVse in an accessible format.
 90        for instance:
 91
 92        csvs.saveFile()
 93        """
 94        i = 1
 95        while os.path.isfile(baseName + str(i) + ".csv"):
 96            i += 1
 97        keys = ["vse", "method", "chooser", *list(self.rows[0].keys())]
 98        for n in range(4):
 99            keys.extend([f"tallyName{str(n)}", f"tallyVal{str(n)}"])
100        keys = uniquify(keys)
101        path = baseName + str(i) + ".csv"
102        with open(path, "w") as myFile:
103            print(
104                f"# {dict(media=self.media.__name__, version=self.repo_version, seed=self.seed, model=self.model, methods=self.methods, nvot=self.nvot, ncand=self.ncand, niter=self.niter)}",
105                file=myFile,
106            )
107
108            dw = csv.DictWriter(myFile, keys, restval="NA")
109            dw.writeheader()
110            for r in self.rows:
111                dw.writerow(r)
112        return path
113
114    @property
115    def results(self):
116        """Return this batch as a pandas-backed ``VseResults`` object."""
117        from .dataframe import VseResults
118
119        return VseResults.from_rows(self.rows)
120
121    @property
122    def dataframe(self):
123        """Return this batch's rows as a pandas DataFrame."""
124        return self.to_dataframe()
125
126    @property
127    def df(self):
128        """Alias for ``dataframe``."""
129        return self.dataframe
130
131    def to_dataframe(self, copy=True):
132        """Return this batch's rows as a pandas DataFrame."""
133        return self.results.to_dataframe(copy=copy)
134
135    def summarize(self, group_by=("method", "chooser"), sort_by="mean_vse", ascending=False):
136        """Return a pandas DataFrame summarizing VSE scores for this batch."""
137        return self.results.summarize(
138            group_by=group_by,
139            sort_by=sort_by,
140            ascending=ascending,
141        )
142
143    def report(self, group_by=("method", "chooser")):
144        """Return common pandas report tables for this batch."""
145        return self.results.report(group_by=group_by)
146
147    def plot_vse(self, *args, **kwargs):
148        """Plot summarized VSE scores for this batch."""
149        return self.results.plot_vse(*args, **kwargs)

179class DeterministicModel(RandomModel):
180    """Basically, a somewhat non-boring stub for testing.
181
182    >>> DeterministicModel(3)(4, 3)
183    [(0, 1, 2), (1, 2, 0), (2, 0, 1), (0, 1, 2)]
184    """
185
186    @autoassign
187    def __init__(self, modulo):
188        pass
189
190    def __call__(self, nvot, ncand, vType=PersonalityVoter):
191        return Electorate(vType((i + j) % self.modulo for i in range(ncand)) for j in range(nvot))

299class DimElectorate(Electorate):
300    def asDims(self, v, *args):
301        return v
302
303    def fromDims(self, dimvoters, vType):
304        for v in dimvoters:
305            self.append(vType.fromDims(v, self))
306
307    def calcTotWeight(self):
308        self.totWeight = sum(w**2 for w in self.dimWeights)

311class DimModel(RandomModel):
312    """
313
314    >>> dm = DimModel(2,baseElectorate=DeterministicModel(3))
315    >>> dm(2,4)
316    [(-1.8439088914585775, -0.0, -1.0, -1.8439088914585775), (-1.2649110640673518, -1.0, -0.0, -1.2649110640673518)]
317    >>> dm.dimWeights
318    [1, 0.5]
319
320
321    """
322
323    builtElectorate = DimElectorate
324
325    @autoassign
326    def __init__(self, ndims=3, dimWeights=None, baseElectorate=RandomModel()):
327        if self.dimWeights is None:
328            self.dimWeights = [2 ** (-n) for n in range(ndims)]
329        assert len(self.dimWeights) == self.ndims
330
331    def __call__(self, nvot, ncand, vType=DimVoter):
332        elec = self.builtElectorate()
333        elec.dimWeights = self.dimWeights
334        return self.makeElectorate(elec, nvot, ncand, vType)
335
336    def makeElectorate(self, elec, nvot, ncand, vType):
337        elec.calcTotWeight()
338        votersncands = self.baseElectorate(nvot + ncand, len(elec.dimWeights), vType)
339        elec.base = [elec.asDims(v, i) for i, v in enumerate(votersncands[:nvot])]
340        elec.cands = [elec.asDims(v, nvot + i) for i, v in enumerate(votersncands[nvot:])]
341        elec.fromDims(elec.base, vType)
342        return elec

273class DimVoter(PersonalityVoter):
274    """A voter in an n-dimensional model."""
275
276    @classmethod
277    def fromDims(cls, v, e, caring=None):
278        if caring is None:
279            caring = [1] * len(v)
280            totCaring = e.totWeight
281        else:
282            totCaring = sum((c * w) ** 2 for c, w in zip(caring, e.dimWeights))
283        me = cls(
284            -sqrt(
285                sum(
286                    ((vd - cd) * w * cares) ** 2
287                    for (vd, cd, w, cares) in zip(v, c, e.dimWeights, caring)
288                )
289                / totCaring
290            )
291            for c in e.cands
292        )
293        me.copyAttrsFrom(v)
294        me.dims = v
295        me.elec = e
296        return me

124class Electorate(list):
125    """A list of voters.
126    Each voter is a list of candidate utilities"""
127
128    @property
129    def dataframe(self):
130        """Return voter utilities as a tidy DataFrame."""
131        return self.to_dataframe()
132
133    @property
134    def df(self):
135        """Alias for ``dataframe``."""
136        return self.dataframe
137
138    @property
139    def wide_dataframe(self):
140        """Return one row per voter with one utility column per candidate."""
141        return self.to_dataframe(wide=True)
142
143    @cached_property
144    def socUtils(self):
145        """Return mean utility across electorate for each candidate: their social utilities.
146
147        >>> e = Electorate([[1,2],[3,4]])
148        >>> e.socUtils
149        [2.0, 3.0]
150        """
151        return list(map(mean, zip(*self)))
152
153    def to_dataframe(self, wide=False, **kwargs):
154        """Return voter utilities as a tidy or wide DataFrame."""
155        from .dataframe import voters_to_dataframe
156
157        return voters_to_dataframe(self, wide=wide, **kwargs)

1107class IRNR(RankedMethod):
1108    stratMax = 10
1109
1110    stratTargetFor = Method.stratTarget3  # strategize in favor of third place, because second place is pointless (can't change pairwise)
1111
1112    def results(self, ballots, **kwargs):
1113        ballots = ballots_from_dataframe(ballots)
1114        enabled = [True] * len(ballots[0])
1115        numEnabled = sum(enabled)
1116        results = [None] * len(enabled)
1117        while numEnabled > 1:
1118            tsum = [0.0] * len(enabled)
1119            for bal in ballots:
1120                vsum = 0.0
1121                for i, v in enumerate(bal):
1122                    if enabled[i]:
1123                        vsum += abs(v)
1124                if vsum == 0.0:
1125                    # TODO: count spoiled ballot
1126                    continue
1127                for i, v in enumerate(bal):
1128                    if enabled[i]:
1129                        tsum[i] += v / vsum
1130            mini = None
1131            minv = None
1132            for i, v in enumerate(tsum):
1133                if enabled[i] and ((minv is None) or (tsum[i] < minv)):
1134                    minv = tsum[i]
1135                    mini = i
1136            enabled[mini] = False
1137            results[mini] = minv
1138            numEnabled -= 1
1139        for i, v in enumerate(tsum):
1140            if enabled[i]:
1141                results[i] = tsum[i]
1142        return results
1143
1144    @staticmethod  # cls is provided explicitly, not through binding
1145    @rememberBallot
1146    def honBallot(cls, utils):
1147        """Takes utilities and returns an honest ballot"""
1148        return utils
1149
1150    @classmethod
1151    def fillStratBallot(
1152        cls,
1153        voter,
1154        polls,
1155        places,
1156        n,
1157        stratGap,
1158        ballot,
1159        frontId,
1160        frontResult,
1161        targId,
1162        targResult,
1163    ):
1164        if stratGap <= 0:
1165            ballot[frontId], ballot[targId] = cls.stratMax, 0
1166        else:
1167            ballot[frontId], ballot[targId] = 0, cls.stratMax
1168        cls.fillPrefOrder(
1169            voter,
1170            ballot,
1171            whichCands=[c for (c, r) in places[2:]],
1172            nSlots=1,
1173            lowSlot=1,
1174            remainderScore=0,
1175        )