Campaign drop rates¶

Introduction¶

This is a step-by-step notebook of the rune drop rate calculations in Magic Rush. The analysis is done in Python and its standard scientific stack.

As far as the code goes, there are certainly things that could've been done faster or more elegantly. The data size is trivial enough (2420 rows) so that performance doesn't matter that much. After all, premature optimization is the root of all evil.

We start by importing the modules we need.

In [2]:

import itertools

import numpy as np
import pandas as pd

Next, we load out data and show the last 20 rows.

In [3]:

sweep_log = pd.DataFrame.from_csv('sweep_log.csv', index_col=None)
sweep_log[-20:]

Out[3]:

	Chapter-Stage	Type	Loot
2405	13-6	C	-
2406	13-6	C	Valkyrie
2407	13-6	C	Bull Horn;Mammoth;Infinity
2408	13-6	C	-
2409	13-6	C	Aggression;Exp
2410	13-6	C	Aegis;Mammoth;Exp
2411	13-6	C	Siren;Attack Damage
2412	13-6	C	-
2413	13-6	C	Bowmaster
2414	13-6	C	Bull Horn;Aggression
2415	13-6	C	Valkyrie;Mammoth;Exp
2416	13-6	C	Aggression
2417	13-6	C	Bull Horn;Exp
2418	13-6	C	-
2419	13-6	C	Immortality
2420	13-6	C	Mammoth
2421	13-6	C	Valkyrie;Heracles;Exp
2422	13-6	C	Mammoth;Aggression
2423	13-6	C	Bull Horn;Exp
2424	13-6	C	-

As you can see, the third column has lists where elements are separated by semicolons. To make the analysis easier, we need to unnest the data first. We will split the elements of those lists into separate rows and give each sweep an ID.

In [4]:

loot_only = sweep_log.Loot.str.split(';', expand=True)
sweep_log = sweep_log.join(loot_only, how='right').drop('Loot', axis=1)

# Copy a named index into a new column, which will be used as an ID for each sweep.
sweep_log.index.name = 'Sweep'
sweep_log.reset_index(level=0, inplace=True)

# Unpivot
sweep_log = pd.melt(sweep_log, 
                    id_vars=['Sweep', 'Chapter-Stage', 'Type'], 
                    value_vars=[0, 1, 2, 3, 4], 
                    var_name='Order',
                    value_name='Loot')

sweep_log = sweep_log.sort_values(by=['Sweep', 'Order'])

# Remove empty rows. Sweeps which dropped nothing are kept intact, 
# since they are marked as '-' in the original file.
sweep_log = sweep_log[sweep_log.Loot.notnull()]

In [5]:

sweep_log[-20:]

Out[5]:

	Sweep	Chapter-Stage	Type	Order	Loot
2413	2413	13-6	C	0	Bowmaster
2414	2414	13-6	C	0	Bull Horn
4839	2414	13-6	C	1	Aggression
2415	2415	13-6	C	0	Valkyrie
4840	2415	13-6	C	1	Mammoth
7265	2415	13-6	C	2	Exp
2416	2416	13-6	C	0	Aggression
2417	2417	13-6	C	0	Bull Horn
4842	2417	13-6	C	1	Exp
2418	2418	13-6	C	0	-
2419	2419	13-6	C	0	Immortality
2420	2420	13-6	C	0	Mammoth
2421	2421	13-6	C	0	Valkyrie
4846	2421	13-6	C	1	Heracles
7271	2421	13-6	C	2	Exp
2422	2422	13-6	C	0	Mammoth
4847	2422	13-6	C	1	Aggression
2423	2423	13-6	C	0	Bull Horn
4848	2423	13-6	C	1	Exp
2424	2424	13-6	C	0	-

First look at data¶

Much better.

It's always a good idea to just look at data first and see what we're working with. For example, what stages do we have records of?

In [6]:

recorded_stages = sweep_log['Chapter-Stage'].unique()
recorded_stages

Out[6]:

array(['1-1', '1-2', '1-3', '2-1', '3-4', '3-5', '3-7', '3-8', '4-1',
       '5-3', '5-5', '6-2', '6-4', '6-5', '6-7', '6-8', '7-4', '7-6',
       '8-3', '8-4', '8-6', '9-2', '9-5', '10-1', '10-2', '10-3', '11-3',
       '11-4', '12-1', '12-2', '12-3', '12-4', '12-5', '13-2', '13-3',
       '13-4', '13-5', '13-6'], dtype=object)

It's not perfect. We're missing some stages. But beggars can't be ~~choosers~~ analysts.

How many times did we sweep stage 10-1?

In [7]:

def count_sweeps(stage):
    stage_sweeps = sweep_log[sweep_log['Chapter-Stage'] == stage]
    count = stage_sweeps['Sweep'].nunique()
    
    return count

In [8]:

count_sweeps('10-1')

Out[8]:

What are the most common drops in our data?

In [9]:

sweep_log['Loot'].value_counts()[:10]

Out[9]:

Exp             664
-               438
Magic Resist    119
Wizard           95
Health           87
Extra Health     84
Magic Force      78
Divine Power     78
Warrior          67
Lightning        63
Name: Loot, dtype: int64

Lastly, in which stages did we drop Aegis fragments and how many times?

In [10]:

def get_loot_frequency(loot_name, min_freq=0):
    stages = sweep_log[sweep_log['Loot'] == loot_name]
    frequency = stages['Chapter-Stage'].value_counts()
    
    return frequency[frequency > min_freq]

In [11]:

get_loot_frequency('Aegis')

Out[11]:

13-4    23
13-6     2
12-4     1
13-3     1
13-5     1
8-6      1
11-4     1
12-2     1
Name: Chapter-Stage, dtype: int64

Calculating drop rates¶

Let's create a little function that will calculate drop rates for a given stage. It will only show the most common drops (i.e. with chances better than one fragment per 10 sweeps).

It's simple. We will take a total number of times we swept a given stage and divide it by the quantity of each loot type.

In [12]:

def get_drop_rate(stage, threshold=10):
    stage_sweeps = sweep_log[sweep_log['Chapter-Stage'] == stage]
    total_sweeps = stage_sweeps['Sweep'].nunique()
    odds = total_sweeps / stage_sweeps['Loot'].value_counts()
    common_loot_rates = odds[odds < threshold]
    
    common_loot = pd.DataFrame([common_loot_rates]).T
    common_loot['Stage'] = stage
    common_loot.columns = ['Avg. sweeps/loot', 'Stage']
    
    return common_loot

Why don't we give it a try?

In [13]:

get_drop_rate('12-4')

Out[13]:

	Avg. sweeps/loot	Stage
Magic Force	2.538462	12-4
Exp	2.946429	12-4
Wizard	3.928571	12-4
Akso	4.714286	12-4
Excalibur	5.000000	12-4
-	7.500000	12-4

It shows that we can expect one Excalibur fragment per 5 sweeps and one Wizard fragment per 3.93 sweeps. Pretty cool, huh?

Also, it shows that in this stage once per 7.5 sweeps we will get nothing :(.

Now, we can repeat this for other stages as well.

In [14]:

final_rates = pd.DataFrame()

for stage in recorded_stages:
    result = get_drop_rate(stage)
    # DataFrame.append() returns a new object each time, so incrementally adding rows is 
    # inefficient. Since our dataset is small, we can ignore that. Normally we would preallocate
    # the rows with empty data. Alternatively, PyTables handles incremental data better.
    final_rates = final_rates.append(result)

In [15]:

final_rates = final_rates[final_rates.index != '-']
final_rates.sort_values(by='Avg. sweeps/loot')

Out[15]:

	Avg. sweeps/loot	Stage
Exp	1.153846	6-8
Exp	1.172414	5-5
Exp	1.363636	4-1
Exp	1.388889	6-7
Crabbie Es	2.000000	11-4
Attack Damage	2.142857	6-8
Attack Damage	2.266667	5-5
Health	2.307692	1-1
Magic Resist	2.434783	3-5
Magic Resist	2.448980	11-4
Regenerate	2.500000	4-1
Exp	2.500000	6-4
Magic Resist	2.500000	6-7
Energy Regen	2.500000	12-1
Double Attack	2.500000	6-8
Hardiness	2.500000	8-3
Armor Penetration	2.500000	9-2
Crit Strike	2.500000	12-2
Attack Force	2.500000	12-5
Magic Penetration	2.500000	6-2
Hardiness	2.500000	3-8
Health Regen	2.500000	1-1
Attack Damage	2.500000	1-2
Armor	2.500000	1-2
Energy Regen	2.500000	3-7
Ability Power	2.500000	1-3
Magic Resist	2.500000	1-3
Armor Penetration	2.500000	2-1
Armor	2.500000	3-4
Health	2.517857	11-3
...	...	...
Bronco	4.375000	12-5
Sage	4.444444	9-2
Spider Queen	4.615385	12-2
Akso	4.684211	7-6
Hera	4.700000	11-3
Akso	4.714286	12-4
Magic Mirror	4.750000	9-5
Kraken	4.777778	13-2
World Serpent	4.800000	12-2
Cerberus	4.846154	10-1
Aegis	4.869565	13-4
Lightning	4.900000	13-5
Mjolnir	5.000000	12-5
Excalibur	5.000000	12-4
Primeval Giant	5.000000	12-3
Fenrir	5.000000	12-1
Spider Queen	5.000000	8-3
Titan	5.000000	11-4
Exp	5.000000	10-3
Lightning	5.000000	8-6
Poseidon	5.000000	12-5
Bull Horn	5.000000	13-6
Heracles	5.000000	9-2
Briareos	5.043478	13-3
Sphinx	5.166667	10-2
Tyr	6.588235	13-4
Valkyrie	6.739130	13-6
Heimdall	6.805556	13-5
Hel	6.823529	13-3
Exp	7.750000	10-2

138 rows × 2 columns

We can immediately notice a couple of things:

a bunch of Grey runes have drop rate of 2.5
Exp has different drop rates in different stages
some of the same Blue fragments have slightly lower drop rate in later stages
most Purple fragments and some orange fragments have drop rates close to 5.0
some other Orange fragments have drop rates over 6.5
drop rate of "nothingness" also varies by stage

Let's investigate Blue fragments. But first, we need to organize runes into their respective qualities.

In [16]:

rune_quality = {'Grey':      ['Health Regen', 'Health', 'Armor', 'Attack Force', 'Crit Strike',
                              'Attack Damage', 'Ability Power', 'Double Attack', 'Magic Resist',
                              'Magic Force', 'Magic Penetration', 'Armor Penetration',],
                'Green':     ['Meditation', 'Fortitude', 'Extra Health', 'Aggression',
                              'Bloodthirst', 'Divine Power'], 
                'Green Sp':  ['Avarice', 'Valor', 'Immortality', 'Balance', 'Osmosis',
                              'Infinity', 'Illusion'], 
                'Blue':      ['Bronco', 'Spider', 'Banshee', 'Mermaid', 'Elephant', 'Cheetah'],
                'Blue Sp':   ['Lion', 'Grizzly', 'Giant', 'Bison', 'Viper', 'Wizard', 'Demon',
                              'Wargod', 'Platybelodon', 'Strongman', 'Tiger', 'War Horse',
                              'Peacock', 'Arch Wizard', 'Sirenelle', 'Anaconda', 'Unicorn',
                              'Soldier', 'Mammoth', 'Sage', 'Hawk', 'Knight', 'Wolf Spider',
                              'Warrior', 'Undead Spider', 'Bowmaster', 'Elf'],
                'Purple':    ['Lightning', 'Aegis', 'Briareos', 'Magic Mirror',  'Harp', 'Bull Horn'],
                'Purple Sp': ['Apollo', 'Medusa', 'Hades', 'Akso', 'Spider Queen', 'Poseidon',
                              'Siren', 'Dionysus', 'Hermes', 'Harpy', 'Heracles', 'Ares',
                              'Fire God', 'Cerberus', 'Sphinx', 'Athena', 'Fury', 'Pandora',
                              'Cupid', 'Venus', 'Hera', 'Titan', 'Gaia', 'Uranus'],
                'Orange 1':  ['Fenrir', 'World Serpent', 'Gram', 'Mjolnir', 'Burr', 'Kraken'],
                'Orange 2':  ['Hel', 'Heimdall', 'Tyr', 'Valkyrie']}

In [17]:

final_rates.loc[rune_quality['Blue']].sort_values(by='Avg. sweeps/loot')

Out[17]:

	Avg. sweeps/loot	Stage
Bronco	3.333333	4-1
Mermaid	3.333333	7-4
Cheetah	3.560000	7-6
Mermaid	3.733333	3-5
Spider	3.750000	3-4
Banshee	3.750000	12-2
Spider	3.928571	12-3
Elephant	4.148148	13-4
Mermaid	4.285714	12-1
Bronco	4.375000	12-5

Although Blue fragments in chapters 12 and 13 do have a lower drop rate, Banshee from 12-2 has the same chances as Spider from 3-4. Can we see the same pattern with Green fragments?

In [18]:

final_rates.loc[rune_quality['Green'] + rune_quality['Green Sp']].sort_values(by='Avg. sweeps/loot')

Out[18]:

	Avg. sweeps/loot	Stage
Divine Power	3.333333	8-6
Avarice	3.333333	10-3
Immortality	3.636364	6-5
Fortitude	3.705882	10-1
Extra Health	3.741935	13-3
Extra Health	3.750000	2-1
Osmosis	3.750000	7-4
Divine Power	3.828125	13-5
Illusion	3.846154	6-7
Bloodthirst	3.875000	10-2
Fortitude	3.909091	13-2
Bloodthirst	4.000000	13-4
Extra Health	4.071429	9-5
Aggression	4.078947	13-6
Meditation	NaN	NaN
Valor	NaN	NaN
Balance	NaN	NaN
Infinity	NaN	NaN

Once again, most Green fragments in chapters 12 and 13 have a lower drop rate. But Extra Health is all over the place. It's not enough to conclude that the same runes have lower drop rates in later stages.

In [19]:

final_rates.loc[rune_quality['Blue Sp']].sort_values(by='Avg. sweeps/loot')

Out[19]:

	Avg. sweeps/loot	Stage
Grizzly	3.750000	3-7
Unicorn	3.750000	7-4
Peacock	3.750000	6-4
Mammoth	3.750000	6-8
Strongman	3.750000	6-2
Demon	3.777778	5-5
Wizard	3.777778	5-3
Arch Wizard	3.846154	6-7
Mammoth	3.875000	13-6
Sirenelle	3.875000	10-2
Unicorn	3.916667	11-3
Wizard	3.928571	12-4
Undead Spider	3.937500	10-1
Warrior	3.951613	13-5
Peacock	4.000000	11-4
Sirenelle	4.000000	6-5
Soldier	4.000000	13-3
Wizard	4.071429	9-5
Lion	4.285714	8-6
Viper	4.285714	8-4
Giant	4.285714	8-3
Giant	4.285714	3-8
Soldier	4.285714	10-3
Bowmaster	4.300000	13-2
Sage	4.444444	9-2
Bison	NaN	NaN
Wargod	NaN	NaN
Platybelodon	NaN	NaN
Tiger	NaN	NaN
War Horse	NaN	NaN
Anaconda	NaN	NaN
Hawk	NaN	NaN
Knight	NaN	NaN
Wolf Spider	NaN	NaN
Elf	NaN	NaN

Notice that Strongman and Mammoth, which both need 10 fragments for one spirit, have much lower drop rate than Giant (5 fragments).

Some quick and dirty functions to calculate a combined drop rate for a group of runes. Yes, nested for loops are O(n²), but again, we're not concerned with perfromance here.

In [20]:

def calculate_runes_sweeps(runes_list, min_freq=5):
    total_sweeps = 0
    
    for rune in runes_list:
        loot_freq = get_loot_frequency(rune, min_freq)
        
        for sweep in loot_freq.index:
            total_sweeps += count_sweeps(sweep)
    
    return total_sweeps

def calculate_runes_loot(runes_list, min_freq=5):
    total_loot = 0
    
    for rune in runes_list:
        loot_freq = get_loot_frequency(rune, min_freq)
        
        for sweep in loot_freq:
            total_loot += sweep
    
    return total_loot

def calculate_combined_drop_rate(runes_list, min_freq=5):
    total_loot = calculate_runes_loot(runes_list, min_freq=5)
    total_sweeps = calculate_runes_sweeps(runes_list, min_freq=5)

    try:
        combined_drop_rate = total_sweeps / total_loot
    except(ZeroDivisionError):
        return np.NaN
    
    return combined_drop_rate

Let's put our new functions to work.

In [21]:

print('Average sweeps per one fragment:')
for key in rune_quality:
    drop_rate = calculate_combined_drop_rate(rune_quality[key])
    print('{}: {:.2f}'.format(key, drop_rate))

Average sweeps per one fragment:
Grey: 2.50
Orange 2: 6.75
Orange 1: 4.85
Purple: 4.91
Green Sp: 3.66
Blue Sp: 3.97
Purple Sp: 4.69
Blue: 3.81
Green: 3.89

One fragment per 6.75 sweeps for Tier 2 Orange sounds about right.

It doesn't make sense that Green Runes have lower drop rate than the Blue ones. I suspect that Green and Blue runes have the same drop rate.

In [22]:

green_blue_combined = rune_quality['Green'] + rune_quality['Green Sp'] + rune_quality['Blue'] + rune_quality['Blue Sp']
green_blue_rate = calculate_combined_drop_rate(green_blue_combined)

print('Combined Green and Blue drop rate: {:.2f}'.format(green_blue_rate))

Combined Green and Blue drop rate: 3.91

Purple runes, Purple spirits, and Tier 1 Orange clearly drop more than per 5 sweeps. Once again, it doesn't make sense that Purple runes have lower drop rate than Orange 1. I also suspect that Purple and Orange 1 runes have the same drop rate.

In [23]:

purple_orange1_combined = rune_quality['Purple'] + rune_quality['Purple Sp'] + rune_quality['Orange 1']
purple_orange1_rate = calculate_combined_drop_rate(purple_orange1_combined)

print('Combined Purple and Tier 1 Orange drop rate: {:.2f}'.format(purple_orange1_rate))

Combined Purple and Tier 1 Orange drop rate: 4.79

Randomness¶

Loot distribution in Magic Rush is not truly random. If it was really random, sweeps would be independent of each other. We would see unusually long droughts (no Purple fragments in 20+ sweeps) and lucky streaks (four identical Purple rune fragments in a row).

Here's how a random distribution of Purple rune fragments (1 rune per 4.85 sweeps on average) from 50 sweeps would look like:

In [24]:

purple = 1 / 4.85
no_purple = 1 - purple
# Technically, this sequence is also pseudorandom, as numpy uses the Mersenne Twister to generate numbers.
# It's good enough to illustrate the point of the above paragraph, though. 
np.random.choice(2, 50, p=[no_purple, purple])

Out[24]:

array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
       0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
       0, 0, 1, 1], dtype=int64)

Loot distribution in Magic Rush is pseudorandom. After enough unlucky sweeps you will be guaranteed to get the fragment you're looking for.

Let's see how long do we have to wait until we are certain to get another fragment.

In [25]:

def find_spread(rune):
    main_stages = get_loot_frequency(rune, min_freq=6).index
    
    results = []
    
    for stage in main_stages:
        stage_loot = sweep_log[sweep_log['Chapter-Stage'] == stage]
        stage_rune = stage_loot[stage_loot['Loot'] == rune]
        difference = np.diff(stage_rune['Sweep']) - 1
        dif_min = np.min(difference)
        dif_max = np.max(difference)
        results.append([rune, stage, dif_min, dif_max])
        
    return results

In [26]:

find_spread('Briareos')

Out[26]:

[['Briareos', '13-3', 2, 6]]

We can get another Briareos fragment as soon as in two sweeps and as late as in six sweeps. We can of course calculate the spread for all the recorded stages and their main runes.

In [27]:

# First, we need to unnest lists from our rune dictionary.
nested_runes = (value for key, value in rune_quality.items())
runes = list(itertools.chain.from_iterable(nested_runes))

spreads = []

for rune in runes:
    rune_spread = find_spread(rune)
    if rune_spread:
        spreads.append(rune_spread)

spreads = list(itertools.chain.from_iterable(spreads))
spreads = pd.DataFrame(spreads, columns=['Rune', 'Stage', 'Min sweeps', 'Max sweeps'])
spreads.sort_values(['Min sweeps', 'Max sweeps', 'Rune'], inplace=True)

In [28]:

spreads

Out[28]:

	Rune	Stage	Min sweeps	Max sweeps
84	Mermaid	7-4	-1	5
5	Armor	3-4	0	3
23	Armor Penetration	2-1	0	3
7	Attack Force	12-5	0	3
20	Magic Penetration	6-2	0	3
13	Ability Power	1-3	0	4
6	Armor	6-4	0	4
21	Armor Penetration	12-3	0	4
10	Attack Damage	5-5	0	4
11	Attack Damage	6-8	0	4
12	Attack Damage	1-2	0	4
9	Crit Strike	12-2	0	4
97	Divine Power	8-6	0	4
2	Health	1-1	0	4
19	Magic Force	12-4	0	4
15	Magic Resist	11-4	0	4
16	Magic Resist	3-5	0	4
17	Magic Resist	6-7	0	4
18	Magic Resist	1-3	0	4
75	Athena	10-3	0	5
71	Dionysus	8-4	0	5
96	Divine Power	13-5	0	5
1	Health	11-3	0	5
37	Immortality	6-5	0	5
66	Akso	12-4	0	6
76	Hera	11-3	0	6
31	Lightning	13-5	0	6
34	Magic Mirror	9-5	0	6
65	Medusa	12-3	0	6
4	Armor	1-2	1	4
...	...	...	...	...
47	Wizard	5-3	1	5
93	Aggression	13-6	1	6
72	Harpy	13-2	1	6
29	Mjolnir	12-5	1	6
50	Peacock	11-4	1	6
70	Siren	12-1	1	6
55	Unicorn	11-3	1	6
44	Viper	8-4	2	4
95	Bloodthirst	10-2	2	5
64	Bowmaster	13-2	2	5
43	Giant	3-8	2	5
85	Mermaid	12-1	2	5
38	Osmosis	7-4	2	5
80	Spider	12-3	2	5
81	Spider	3-4	2	5
67	Akso	7-6	2	6
33	Briareos	13-3	2	6
35	Bull Horn	13-6	2	6
74	Cerberus	10-1	2	6
30	Kraken	13-2	2	6
68	Spider Queen	12-2	2	6
77	Titan	11-4	2	6
28	World Serpent	12-2	2	6
32	Aegis	13-4	2	7
69	Poseidon	12-5	2	7
73	Heracles	9-2	3	6
25	Heimdall	13-5	4	8
24	Hel	13-3	4	8
26	Tyr	13-4	4	8
27	Valkyrie	13-6	4	9

98 rows × 4 columns

You can easily drop low quality runes twice in a row. It may also occasionally happenen with Purple fragments too. I'm not sure if two identical Purple fragments in a row come from the same loot table (more about it below).

As expected, tier 2 Orange fragments are the hardest to get. You can't get one sooner than in four more sweeps and you can wait as much as nine.

You might have noticed that Mermaid has a spread of -1. It's because two Mermaid fragments dropped in a single sweep:

In [29]:

sweep_log[sweep_log['Sweep'] == 563]

Out[29]:

	Sweep	Chapter-Stage	Type	Order	Loot
563	563	7-4	C	0	Mermaid
2988	563	7-4	C	1	Mermaid
5413	563	7-4	C	2	Exp

Auxiliary fragments¶

During sweeps you can get other fragments of the same quality. Usually it's a fragment from a different rune, but it's possible that the extra fragment is the same as the main drop of the stage. The drop rate of those auxiliary fragments seems to be somewhere between 8 to 30 sweeps per one fragment.

Orange fragments don't have auxiliary drops.

In [30]:

def get_auxiliary_drop_rate(stage):

    stage_sweeps = sweep_log[sweep_log['Chapter-Stage'] == stage]
    total_sweeps = count_sweeps(stage)
    stage_loot = stage_sweeps['Loot'].value_counts()
    purple_runes = stage_loot.index.isin(rune_quality['Purple'] + rune_quality['Purple Sp'])
    auxiliary_sum = np.sum(stage_loot[purple_runes][1:])
    
    try:
        auxiliary_drop_rate = total_sweeps / auxiliary_sum
    except(ZeroDivisionError):
        auxiliary_drop_rate = 0
    
    return auxiliary_drop_rate

In [31]:

aux_rates = []

for stage in recorded_stages:
    aux_dr = get_auxiliary_drop_rate(stage)
    if aux_dr > 0:
        aux_rates.append([stage, aux_dr])

pd.DataFrame(aux_rates, columns=['Stage', 'Auxiliary Drop Rate'])

Out[31]:

	Stage	Auxiliary Drop Rate
0	7-6	17.800000
1	8-3	15.000000
2	8-4	30.000000
3	8-6	15.000000
4	9-2	13.333333
5	9-5	17.100000
6	10-1	15.750000
7	10-2	10.333333
8	10-3	15.000000
9	11-3	20.142857
10	11-4	15.000000
11	12-1	30.000000
12	12-2	8.571429
13	12-3	9.166667
14	12-4	7.500000
15	12-5	8.750000
16	13-2	8.600000
17	13-3	8.285714
18	13-4	10.181818
19	13-5	8.750000
20	13-6	8.157895