DEV Community: Cassandra de la Cruz-Munoz

OpenPGP Proof

Cassandra de la Cruz-Munoz — Tue, 10 May 2022 15:56:52 +0000

This is an OpenPGP proof that connects my OpenPGP key to this dev.to account. For details check out https://docs.keyoxide.org/advanced/openpgp-proofs/

[Verifying my OpenPGP key: openpgp4fpr:d8529ab0d66c173cc1052c64bfebacea812dda70]

Salmon Run Statistics: Matchmaking (Part 4)

Cassandra de la Cruz-Munoz — Thu, 24 Dec 2020 19:28:19 +0000

Hi y'all.
I'm back with a new post on Salmon Run, this time about matchmaking.

You see that big graph at the top?
That's a scatter plot, with the player rank as the x and the hazard level of the match being the y.
I then placed a linear regression on the graph.
An important consideration of this graph is that I set how much points each title is worth to be 100, as that's how many points you need to move from title to title.

With this graph, the equation of the line is:

y = 0.111x + 50.691

As to how I made this graph:
I did it in the scripts/rank_and_danger_rate.py file.

data = core.init("All")
x = []
y = []

First we prepare the dataset, and create empty lists to store the x and y values.

with gzip.open(data) as reader:
    for job in jsonlines.Reader(reader, ujson.loads):
        if "title" in job and "title_exp" in job and job["title"] is not None:
            x.append(job["title"]["splatnet"] * 100 + job["title_exp"])
            y.append(float(job["danger_rate"]))

Here we collect what we're interested in from the data set.

plt.scatter(x, y)
plt.xlabel("Rank")
plt.ylabel("Hazard Level")

Now we prepare the scatter plot.

m, b = numpy.polyfit(x, y, 1)
y_equation = list(sorted([x_val * m + b for x_val in x]))
print("y = {:4}x + {:4}".format(m, b))
plt.plot(list(sorted(x)), y_equation)
plt.show()

Create and plot the linear regression, and show the graph.

Salmon Run Statistics: Tides and Events (Part 3)

Cassandra de la Cruz-Munoz — Wed, 23 Dec 2020 14:52:46 +0000

First | Previous | Next

Today we're gonna look at the probability distribution of events and tides.

high tide:
none: 15.0058% occurrence; 80.8970% wave cleared
mothership: 0.7407% occurrence; 98.5512% wave cleared
fog: 0.7919% occurrence; 83.2775% wave cleared
rush: 0.9527% occurrence; 75.1159% wave cleared
cohock_charge: 0.0% occurrence
griller: 0.9929% occurrence; 77.6987% wave cleared
goldie_seeking: 0.9623% occurrence; 92.9686% wave cleared

normal tide:
none: 45.5480% occurrence; 81.9957% wave cleared
mothership: 2.4686% occurrence; 95.6328% wave cleared
fog: 2.5295% occurrence; 86.8992% wave cleared
rush: 3.1385% occurrence; 85.3304% wave cleared
cohock_charge: 0.0% occurrence
griller: 2.9823% occurrence; 88.2238% wave cleared
goldie_seeking: 3.0713% occurrence; 83.7560% wave cleared

low tide:
none: 15.0909% occurrence; 87.9722% wave cleared
mothership: 0.7476% occurrence; 97.6866% wave cleared
fog: 0.7793% occurrence; 92.1918% wave cleared
rush: 0.0% occurrence
cohock_charge: 4.1976% occurance; 92.0484% wave cleared
griller: 0.0% occurrence
goldie_seeking: 0.0% occurrence

Events

none: 75.64554806202921
mothership: 3.9574326151171575
fog: 4.100073531455544
rush: 4.0913558846642696
cohock_charge: 4.1982418148877196
griller: 3.973857167042747
goldie_seeking: 4.033490924803348

Tides

high: 0.19446164109069133
normal: 0.5973773780856048
low: 0.2081609808237039

Judging from this data, I think it generates the event first, and then the tide.
There is an approximately 25% chance of having an event, with the chance of any particular event being approximately 4%.
For events which can occur on any tide, there is an approximately 60% chance of receiving normal tide, and a 20% chance each for high and low.
Cohock charge is the only event that can only occur on low tide, so if that event is rolled it is guaranteed to be low tide.
Grillers, goldie seeking, and rush all are normal or high tides, so it's 75% normal tide and 25% high tide.

Out of the possible combinations, high tide rush has the lowest wave clear percentage, and high tide mothership has the highest.

Today's file is the appropriately named reports/tides_and_events.py.

Let's go through this file together.

data = core.init("All")

The usual updating the dataset.

tideList: List[str] = ["high", "normal", "low"]
eventList: List[str] = [
    "None",
    "mothership",
    "fog",
    "rush",
    "cohock_charge",
    "griller",
    "goldie_seeking",
]
tideDict: Dict[str, dict] = {}
for tideStr in tideList:
    eventDict: Dict[str, Union[str, int]] = {}
    for eventStr in eventList:
        eventDict[eventStr] = {"key": eventStr, "count": 0.0, "clear_count": 0.0}
    tideDict[tideStr] = eventDict

This creates a dictionary of dictionaries from the list of tides and list of events, where tides are the outer layer and events are the inner layer, with the inner layer dictionaries having the event name, the occurrence count, and the clear count.

total: float = 0.0

We need to store the total number of waves in the data file in order to calculate the percent of occurrences, so we initialize that variable now with a value of 0.0.
Sure, it is only gonna hold integer values, but this saves on having to cast it to a float later.

with gzip.open(data) as reader:
    for job in jsonlines.Reader(reader, ujson.loads):
        waveCount: int = 0
        for wave in job["waves"]:
            total += 1.0
            if wave["known_occurrence"] is not None:
                cast(
                    Dict[str, float],
                    tideDict[wave["water_level"]["key"]][
                        wave["known_occurrence"]["key"]
                    ],
                )["count"] += 1.0
                if job["clear_waves"] > waveCount:
                    cast(
                        Dict[str, float],
                        tideDict[wave["water_level"]["key"]][
                            wave["known_occurrence"]["key"]
                        ],
                    )["clear_count"] += 1.0
            else:
                cast(
                    Dict[str, float], tideDict[wave["water_level"]["key"]]["None"]
                )["count"] += 1.0
                if job["clear_waves"] > waveCount:
                    cast(
                        Dict[str, float],
                        tideDict[wave["water_level"]["key"]]["None"],
                    )["clear_count"] += 1.0
            waveCount += 1

Now, we crack open the data file and start collecting our results.
The first two lines are to extract the job from the gzip encoded jsonlines file.
We need a variable to count which wave we're on because we need to check if the "clear_waves" value in the job is higher than that.
We check if the wave has an event, and if so we store the data in the appropriate event dictionary, otherwise we store it in the "none" dictionary.
We then check if the wave was cleared or not.

for tide in tideDict.values():
    for event in tide.values():
        print(
            cast(str, event["key"])
            + ": "
            + str(100.0 * cast(float, event["count"]) / total)
            + "% occurance; "
            + str(
                100.0
                * cast(float, event["clear_count"])
                / (
                    cast(float, event["count"])
                    if cast(float, event["count"]) > 0.0
                    else 1.0
                )
            )
            + " % wave cleared"
        )

These loops print out the results in the format similar to the one shown in this post.
I did edit the results print to look nicer in this post.

Salmon Run Statistics: Stages (Part 2)

Cassandra de la Cruz-Munoz — Tue, 22 Dec 2020 19:06:36 +0000

Previous | Next

In today's post, I'll be preforming hypothesis testing on the various stages.

What's being tested is whether there is a significant difference in the average waves cleared, hazard level, golden eggs collected, or power eggs collected for each of the stages.

We'll be going in order of stage release.
As a note, a p value listed of 0.0 is not actually zero, but close enough to it that Python cannot tell the difference.

First stage: Lost Outpost

Sample sizes:

On stage: 58465
Not on stage: 237024

Waves cleared:

x̄1 - x̄2 = 0.02202136266782695
d = 0.02180660926876172
t = 4.75855948072555
p = 1.9528027441484954e-06

Hazard Level:

x̄1 - x̄2 = 0.7916590856902417
d = 0.02508002845167262
t = 5.36330448554007
p = 8.191814053431072e-08

Golden Eggs Collected:

x̄1 - x̄2 = 0.29067416948813474
d = 0.03312541526802805
t = 7.1015810044868
p = 1.2426245625649125e-12

Power Eggs Collected:

x̄1 - x̄2 = 0.29067416948813474
d = 0.0009492056915165725
t = 3.2082636985041604
p = 0.001335847436272462

Second stage: Marooner's Bay

Sample Sizes:

On stage: 58206
Not on stage: 237283

Waves Cleared:

x̄1 - x̄2 = -0.09935144682267083
d = -0.09838256668436818
t = -20.991545905954546
p = 1.365533454759977e-97

Hazard Level:

x̄1 - x̄2 = -2.8769270721537907
d = -0.09114202581290942
t = -20.287411896696618
p = 2.632302741250626e-91

Golden Eggs Collected:

x̄1 - x̄2 = -1.6038006761037291
d = -0.18277015634596588
t = -42.74669521494301
p = 0.0

Power Eggs Collected:

x̄1 - x̄2 = -1.6038006761037291
d = -0.0052372618196400425
t = -8.62183075765369
p = 6.705805318363079e-18

Third stage: Salmonid Smokeyard

Sample Sizes:

On stage: 56963
Not on stage: 238526

Waves Cleared:

x̄1 - x̄2 = 0.14200233776683957
d = 0.1406175240670411
t = 31.299034907944364
p = 6.80477043218477e-214

Hazard Level:

x̄1 - x̄2 = 4.759780678961647
d = 0.15079146694564513
t = 32.07588477095397
p = 2.0912126528419186e-224

Golden Eggs Collected:

x̄1 - x̄2 = 1.1372705506692107
d = 0.12960408325705847
t = 27.062506697275193
p = 1.3476593528527444e-160

Power Eggs Collected:

x̄1 - x̄2 = 1.1372705506692107
d = 0.00371379294345405
t = 51.1355543467026
p = 0.0

Fourth stage: Spawning Grounds

Sample Sizes:

On stage: 61733
Not on stage: 233756

Waves Cleared:

x̄1 - x̄2 = -0.061300749402876775
d = -0.06070294151523198
t = -13.206234532306135
p = 8.757489255083284e-40

Hazard Level:

x̄1 - x̄2 = -1.1633113788847709
d = -0.03685409920502122
t = -8.209514401404489
p = 2.247521976981891e-16

Golden Eggs Collected:

x̄1 - x̄2 = -0.32276730159660616
d = -0.03678276924006097
t = -8.014870746224835
p = 1.1149222395261515e-15

Power Eggs Collected:

x̄1 - x̄2 = -0.32276730159660616
d = -0.0010540068291945382
t = 2.822913848544297
p = 0.004759891986650458

Fifth stage: Ruins of Ark Polaris

Sample Size:

On stage: 59908
Not on stage: 235581

Cleared Waves

x̄1 - x̄2 = 0.0020956528774993544
d = 0.002075215968780652
t = 0.4522412772851219
p = 0.6510962365369337

Hazard Level:

x̄1 - x̄2 = -1.3176295304787118
d = -0.041742950609045815
t = -9.06088510509389
p = 1.318471198905114e-19

Golden Eggs Collected:

x̄1 - x̄2 = 0.5202282126739455
d = 0.05928554164036889
t = 12.886738997648841
p = 5.766022404170223e-38

Power Eggs Collected:

x̄1 - x̄2 = 0.5202282126739455
d = 0.0016988216779880055
t = -48.47749341095846
p = 0.0

All but one t-test resulted in a statistically significant result at the p < .05 level.
However, the effect size calculated for each is small enough as to be unremarkable.

Thus while there is a statistically significant difference between the five stages, the effect size is small enough as to hardly matter.

The main script for this was scripts/stages.py
This called upon functions in the core.py and filters.py portions of the code base.
It also utilized some functions from matplotlib.pyplot and scipy, in addition to the usual requirements of jsonlines, ujson, and numpy.

As to how the script works:

data = core.init("All")
stageList: List[str] = []
with gzip.open(data) as reader:
    for job in jsonlines.Reader(reader, ujson.loads):
        if job["stage"] is not None:
            if not (job["stage"]["name"][locale] in stageList):
                    stageList.append(job["stage"]["name"][locale])

This first segment initializes the data, pulling new results from stat.ink.
Then, it finds all the stages in the database, and makes a list of them.

listOfFiles: List[Tuple[str, str]] = []
for stage in stageList:
    listOfFiles.append(filters.onStages(data, [stage]))

This segment then creates a list of the filtered data sets, creating a paired set of data with and without that stage, for each stage in the list.

with open("reports/stages.txt", "w", encoding="utf-8") as writer:
    i: int = 1
    for stageFiles in listOfFiles:
        plt.figure(i)
        withVal: str = stageFiles[0]
        withoutVal: str = stageFiles[1]
        withValClearWaves: List[float] = []
        withValDangerRate: List[float] = []
        withValGoldenTotal: List[float] = []
        withValPowerTotal: List[float] = []
        withoutValClearWaves: List[float] = []
        withoutValDangerRate: List[float] = []
        withoutValGoldenTotal: List[float] = []
        withoutValPowerTotal: List[float] = []
        clearWaves: List[float] = []
        dangerRate: List[float] = []
        goldenTotal: List[float] = []
        powerTotal: List[float] = []
        with gzip.open(withVal) as reader:
            for job in jsonlines.Reader(reader, ujson.loads):
                withValClearWaves.append(float(job["clear_waves"]))
                withValDangerRate.append(float(job["danger_rate"]))
                withValGoldenTotal.append(float(job["my_data"]["golden_egg_delivered"]))
                withValPowerTotal.append(float(job["my_data"]["power_egg_collected"]))
        with gzip.open(withoutVal) as reader:
            for job in jsonlines.Reader(reader, ujson.loads):
                withoutValClearWaves.append(float(job["clear_waves"]))
                withoutValDangerRate.append(float(job["danger_rate"]))
                withoutValGoldenTotal.append(float(job["my_data"]["golden_egg_delivered"]))
                withoutValPowerTotal.append(float(job["my_data"]["power_egg_collected"]))
        with gzip.open(data) as reader:
            for job in jsonlines.Reader(reader, ujson.loads):
                clearWaves.append(float(job["clear_waves"]))
                dangerRate.append(float(job["danger_rate"]))
                goldenTotal.append(float(job["my_data"]["golden_egg_delivered"]))
                powerTotal.append(float(job["my_data"]["power_egg_collected"]))
        diffMeansClearWaves: float = np.mean(withValClearWaves) - np.mean(
            withoutValClearWaves
        )
        t, p = ttest_ind(withValClearWaves, withoutValClearWaves, equal_var=False)
        writer.write(withVal + "\n")
        writer.write(withoutVal + "\n")
        writer.write("n_1 = " + str(len(withValClearWaves)) + "\n")
        writer.write("n_2 = " + str(len(withoutValClearWaves)) + "\n")
        writer.write("\n")
        writer.write("x\u0304_1 - x\u0304_2 = " + str(diffMeansClearWaves) + "\n")
        writer.write("d = " + str(diffMeansClearWaves / np.std(clearWaves)) + "\n")
        writer.write("t = " + str(t) + "\n")
        writer.write("p = " + str(p) + "\n")
        writer.write("\n")
        t, p = ttest_ind(withValDangerRate, withoutValDangerRate, equal_var=False)
        plt.subplot(321)
        plt.hist(withValDangerRate, density=True)
        plt.xlabel("Danger Rate")
        plt.ylabel("Probability")
        plt.subplot(322)
        plt.hist(withoutValDangerRate, density=True)
        plt.xlabel("Danger Rate")
        plt.ylabel("Probability")
        diffMeansDangerRate: float = np.mean(withValDangerRate) - np.mean(
            withoutValDangerRate
        )
        writer.write("x\u0304_1 - x\u0304_2 = " + str(diffMeansDangerRate) + "\n")
        writer.write("d = " + str(diffMeansDangerRate / np.std(dangerRate)) + "\n")
        writer.write("t = " + str(t) + "\n")
        writer.write("p = " + str(p) + "\n")
        writer.write("\n")
        t, p = ttest_ind(withValGoldenTotal, withoutValGoldenTotal, equal_var=False)
        plt.subplot(323)
        plt.hist(withValGoldenTotal, density=True)
        plt.xlabel("Golden Eggs")
        plt.ylabel("Probability")
        plt.subplot(324)
        plt.hist(withoutValGoldenTotal, density=True)
        plt.xlabel("Golden Eggs")
        plt.ylabel("Probability")
        diffMeansGoldenTotal: float = np.mean(withValGoldenTotal) - np.mean(
            withoutValGoldenTotal
        )
        writer.write("x\u0304_1 - x\u0304_2 = " + str(diffMeansGoldenTotal) + "\n")
        writer.write("d = " + str(diffMeansGoldenTotal / np.std(goldenTotal)) + "\n")
        writer.write("t = " + str(t) + "\n")
        writer.write("p = " + str(p) + "\n")
        writer.write("\n")
        t, p = ttest_ind(withValPowerTotal, withoutValPowerTotal, equal_var=False)
        plt.subplot(325)
        plt.hist(withValPowerTotal, density=True)
        plt.xlabel("Power Eggs")
        plt.ylabel("Probability")
        plt.subplot(326)
        plt.hist(withoutValPowerTotal, density=True)
        plt.xlabel("Power Eggs")
        plt.ylabel("Probability")
        diffMeansPowerTotal: float = np.mean(withValGoldenTotal) - np.mean(
            withoutValGoldenTotal
        )
        writer.write("x\u0304_1 - x\u0304_2 = " + str(diffMeansPowerTotal) + "\n")
        writer.write("d = " + str(diffMeansPowerTotal / np.std(powerTotal)) + "\n")
        writer.write("t = " + str(t) + "\n")
        writer.write("p = " + str(p) + "\n")
        writer.write("\n")
        i += 1
plt.show()

This is a big segment.
First, it creates a bunch of lists to store all the data retrieved.
Next it goes through the data files of that iteration, retrieving all the data needed for the calculations.
Then, for each metric, it calculates the d, p, and t values.
It also creates a histogram for all the metrics except the waves cleared.
All of the data generated gets written to the "reports/stages.txt" file, and the histograms are displayed in their own windows on screen.

Salmon Run Statistics (Part 1)

Cassandra de la Cruz-Munoz — Mon, 21 Dec 2020 23:29:03 +0000

| Next

Hi, Cass here.

I'm the developer of Salmon Tracker, a toolkit for performing statistical analysis on the Salmon Run game mode of the Nintendo Switch game Splatoon 2.

Here's an intro to what my tool does and some of the cool things I've found.

First off, let's go through an overview of the data set.

Jobs: 295255
Average Waves: 2.2568457773788757
Clear %: 57.90689404074444
Wave 2 %: 77.00089752925438
Wave 1 %: 90.77678616788878
Golden: 16.685295761291087 (0.0, 16.0, 133.0)
Power Eggs: 632.864202130362 (0.0, 614.0, 3722.0)
Rescued: 2.2307564647508085 (0.0, 2.0, 59.0)
Deaths: 1.624947926368732 (0.0, 1.0, 23.0)
Hazard Level: 154.71349375961694 (4.4, 158.4, 200.0)

This overview was generated by the following code:

data = core.init("All")
print(core.getOverview(data))

Core is the main file of the library, containing functions to prepare the data, as well as fetch parts of the data efficiently.
The init function in core pulls the latest match results from the stat.ink API and stores it in either "salmon.jl.gz" or "salmonAll.jl.gz" depending on whether the mode is set to "All" or "User". "User" mode requires providing an API key.
getOverview takes in one parameter, the path to the data file, and outputs that nice stat summary you see above.

At time of writing, the data set takes up 255 MB with gzip compression, or approximately 6 GB uncompressed.

The library uses jsonlines formatted data stored in gzip files to get around memory limitations.

Next post, I'll cover the hypothesis testing, and show just how powerful the Grizzco weapons are.