Statistiche gare Bebras italiano 2019

In [1]:
from IPython.display import HTML

HTML('''<script>
code_show=true; 
function code_toggle() {
 if (code_show){
 $('div.input').hide();
 } else {
 $('div.input').show();
 }
 code_show = !code_show
} 
$( document ).ready(code_toggle);
</script>
<input type="button" value="Clicca per vedere/nascondere il codice Python" onclick="code_toggle()">''')
Out[1]:
In [2]:
import warnings
#warnings.filterwarnings('once')
warnings.filterwarnings('ignore')

Distribuzione dei punteggi

In [3]:
import pandas as pd
import json, hashlib, urllib, os.path

pd.options.display.max_rows = None
pd.options.display.max_columns = None
In [4]:
CATS = ('kilo', 'mega', 'giga', 'tera', 'peta')
In [5]:
with open('secret.key') as k:
    key = k.readline().strip()

for i, k in enumerate(CATS):
    if not os.path.exists("results-{}.json".format(k)):
        r = urllib.request.urlopen("https://bebras.it/api?key={}&view=exams&edition=bebras_2019&events=0&test={}".format(key,85+i))
        with open("results-{}.json".format(k), "w") as tw:
            tw.writelines(r.read().decode('utf-8'))
In [6]:
score = []
for k in CATS:
    with open("results-{}.json".format(k), "r") as t:
        j = json.load(t)
        score += j['exams']
In [7]:
scoredf = pd.DataFrame(score)
In [8]:
# L'orario va corretto per il fuso orario

scoredf['server_start'] = pd.to_datetime(scoredf['exam_date'].astype('int64') + 60*60, unit='s')
scoredf['orainizio'] = pd.np.floor((scoredf['exam_date'].astype('int64') + 60*60) / (45*60)) # ore da 45', il tempo di gara
scoredf['punteggio'] = pd.to_numeric(scoredf['score'])
scoredf['punteggio_norm'] = scoredf['punteggio'].map(lambda x: x if x >= 0 else 0)
scoredf['anonid'] = scoredf['team_id'].map(lambda x: hashlib.md5(str(x).encode('utf8')).hexdigest())
scoredf['categoria'] = scoredf['category'].str.lower().astype(pd.api.types.CategoricalDtype(categories = CATS, ordered=True))
In [9]:
valid = scoredf[scoredf['exam_valid_score'] == 1]
valid.to_csv('anonris.csv', columns=['anonid', 'categoria', 'orainizio', 'punteggio', 'punteggio_norm', 'time'])
In [10]:
from IPython.display import display, Markdown

txt = '''<table>
<caption>Squadre partecipanti al Bebras 2019/20 con risultati validi, 
cioè ritenuti confrontabili con gli altri perché privi di anomalie tecniche o organizzative</caption>
<thead>
  <tr><th>Categoria</th>
  <th>squadre</th>
  <th> min </th>
  <th> max </th>
  <th> media </th>
  <th> std.dev. </th>
  <th>I quartile </th>
  <th>mediana </th>
  <th>III quartile</th>
  <th>Squadre al minimo</th>
  <th>Squadre al massimo</th>
</tr>
<tbody>
'''
for k in valid['categoria'].unique():
    s = valid[valid['categoria'] == k]['punteggio_norm'].describe()
    top = valid[(valid['categoria'] == k) & (valid['punteggio_norm'] == int(s['max']))]
    bottom = valid[(valid['categoria'] == k) & (valid['punteggio_norm'] == int(s['min']))]
    txt += "<tr><th>{}</th><td>{}</td><td>{}</td><td>{}</td><td>{:.1f}</td>\
<td>{:3.1f}</td><td>{}</td><td>{}</td><td>{}</td><td>{:.1f}%</td><td>{:.1f}%</td></tr>".format(k, 
                                                              int(s['count']),
                                                              int(s['min']),
                                                              int(s['max']),
                                                              float(s['mean']),
                                                              float(s['std']),
                                                              int(s['25%']), 
                                                              int(s['50%']), 
                                                              int(s['75%']),
                                                              100*len(bottom)/float(s['count']),
                                                              100*len(top)/float(s['count']))
txt += '<tfoot><tr><th>Totale</th><td>{}</td></tr>'.format(valid['punteggio_norm'].count())
txt += '</table>'
display(Markdown(txt))
Squadre partecipanti al Bebras 2019/20 con risultati validi, cioè ritenuti confrontabili con gli altri perché privi di anomalie tecniche o organizzative
Categoria squadre min max media std.dev. I quartile mediana III quartile Squadre al minimo Squadre al massimo
kilo304404828.111.02128370.8%4.9%
mega572804825.410.41825330.6%1.7%
giga270904828.69.92229360.4%1.7%
tera207204824.410.91624330.8%0.8%
peta148104828.89.92230360.3%2.4%
Totale15034
In [11]:
%matplotlib inline
import matplotlib.pyplot as plt
plt.style.use('ggplot')

histograms = valid['punteggio_norm'].hist(by=valid['categoria'], bins=24, figsize=(10,8))

Percentili per punteggio

In [12]:
for k in valid['categoria'].unique():
    tot = float(valid[(valid['categoria'] == k)]['punteggio'].count())
    top = int(valid[(valid['categoria'] == k)]['punteggio'].max())
    pp = [100 * valid[(valid['categoria'] == k) & (valid['punteggio'] < i)]['punteggio'].count()/tot for i in range(1,top+1)]
    txt = '''<table>
    <caption>Percentili per la categoria {} (che percentuale di squadre si supera con un dato punteggio)</caption>
    <thead>'''.format(k)
    txt += ''.join(['<td>{}</td>'.format(i) for i in range(1,top+1)])
    txt += '<tbody>'
    txt += ''.join(['<td>{:.1f}</td>'.format(f) for f in pp])
    txt += '</table>'
    display(Markdown(txt))    
Percentili per la categoria kilo (che percentuale di squadre si supera con un dato punteggio)
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
0.80.91.21.72.02.43.03.54.65.56.57.68.910.212.114.015.617.720.022.124.827.230.534.137.741.144.347.250.754.056.760.664.366.668.772.974.877.480.682.983.888.291.291.793.194.995.195.1
Percentili per la categoria mega (che percentuale di squadre si supera con un dato punteggio)
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
0.60.81.21.41.82.42.93.64.45.46.88.410.712.715.118.020.823.827.531.434.939.042.345.548.352.554.857.761.665.367.370.374.876.078.180.884.085.088.289.590.692.195.896.196.998.098.198.3
Percentili per la categoria giga (che percentuale di squadre si supera con un dato punteggio)
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
0.40.50.91.01.31.31.72.02.84.04.25.66.17.28.111.012.514.616.818.320.422.827.029.133.535.040.642.249.450.557.057.964.665.572.472.678.678.784.184.289.089.192.993.097.097.098.398.3
Percentili per la categoria tera (che percentuale di squadre si supera con un dato punteggio)
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
0.81.21.82.33.03.74.75.98.19.711.513.315.818.020.323.025.628.831.334.737.340.644.448.450.854.356.959.862.465.468.470.773.775.879.981.885.586.389.290.194.395.196.897.097.697.798.899.2
Percentili per la categoria peta (che percentuale di squadre si supera con un dato punteggio)
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
0.30.30.70.91.11.72.32.83.24.04.85.86.88.09.010.912.214.015.717.419.922.525.427.531.633.537.940.743.646.652.754.661.365.368.674.378.680.785.187.889.090.294.194.695.997.297.697.6

Analisi delle risposte

In [13]:
rr = []
for r in valid.itertuples():
    for q in r.exam_data['questions']:
        t = dict((k, q[k]) for k in ('q_id','q_class','q_score','q_scoreMax','q_time'))
        t['anonid'] = r.anonid
        rr.append(t)
In [14]:
quiz = pd.DataFrame(rr)
In [15]:
MAPBEBRAS = dict((x.split('_')[-1], x.split('_')[1]) for x in list(quiz['q_id'].unique()))
In [16]:
MAPNAMES = {
    'Q01': 'La rappresentazione di immagini',
    'Q02': 'Pupazzi di neve',
    'Q03': 'Sgraffito',
    'Q04': 'Rabbit',
    'Q05': 'Palline',
    'Q06': 'Nuvole',
    'Q07': 'Riconoscimento',
    'Q08': 'Samba',
    'Q09': 'Timbri',
    'Q10': 'Festa',
    'Q11': 'Castori rupestri',
    'Q12': 'Animali e recinti',
    'Q13': 'Parcheggio',
    'Q14': 'Scatola',
    'Q15': 'Piatti in ordine',
    'Q16': 'Numeri digitali',
    'Q17': 'Reti e incroci',
    'Q18': 'Viaggia spaziali',
    'Q19': 'Disegni',
    'Q20': 'Scatole da riempire',
    'Q21': 'Armadietti',
    'Q22': "L'arcipelago",
    'Q23': 'Riciclo',
    'Q24': 'Sorveglianza',
    'Q25': 'Formiche',
    'Q26': 'Salici e pioppi',
    'Q27': 'Palline in pericolo',
    'Q28': 'La ferrovia',
    'Q30': 'Torte',
    'Q31': 'Mappe cifrate',
}
In [17]:
quiz = quiz.rename(columns={'q_time': 'time', 'q_score': 'score', 'q_scoreMax': 'score_max', 'q_class': 'cat'})
In [18]:
quiz['nome'] = quiz['q_id'].str.extract('[0-9]+_(.+)', expand=False)
quiz['edizione'] = quiz['q_id'].str.extract('([0-9]+)_.+', expand=False)
quiz['completo'] = quiz['score'] == quiz['score_max']
quiz['parziale'] = (quiz['score'] > 0) & (quiz['score'] != quiz['score_max'])
quiz['penalizzato'] = quiz['score'] < 0
quiz['voto'] = quiz['score'] / quiz['score_max'].astype('float64')
quiz['minuti'] = quiz['time'].map(lambda x: float(x)/60. if float(x) >= 0 and float(x) <= 45*60 else pd.np.NaN)

quiz.to_csv('quiz.csv', columns=['anonid', 'cat', 'edizione', 'nome', 'bebras', 'score', 'score_max', 'time'])
In [28]:
vquiz = pd.merge(valid[['anonid', 'categoria', 'punteggio','punteggio_norm','orainizio','teacher_id','school_cap']], quiz, on='anonid')
In [41]:
plt.figure(figsize=(16,20))

def bname(n):
    if n in MAPBEBRAS and n in MAPNAMES:
        return '{}'.format(MAPNAMES[n])
    else:
        return n

for j, k in enumerate(valid['categoria'].unique()):
    plt.subplot(5,1, j+1)
    plt.ylim(0,1.2)
    m = vquiz[vquiz['categoria'] == k].groupby('nome', 
                                             sort=False)[['completo','voto', 'parziale', 'penalizzato', 'minuti','score_max']].mean()
    m['vparziale'] = m['voto'] - m['completo']

    c = plt.bar(pd.np.arange(m.index.size), m['completo'], color='blue')
    p = plt.bar(pd.np.arange(m.index.size), m['parziale'], bottom=m['completo'], color='lightblue')   
    plt.xticks(pd.np.arange(m.index.size), map(bname, m.index.tolist()), rotation=90)
    plt.ylim([0,1])
    plt.yticks(pd.np.arange(0,1.2,.2), ['{:.0f}%'.format(100*y) for y in pd.np.arange(0,1.2,.2)])
    for i, y in enumerate(m['voto'].tolist()):
        plt.annotate(s='{:.0f}\''.format(m['minuti'].iloc[i]), xy=(i, .75*m['completo'].iloc[i]), color='white')
        plt.annotate(s='{:.0f}'.format(m['score_max'].iloc[i]), xy=(i-.15, .02), color='yellow', fontsize='x-large')
    plt.legend((c[0],p[0]), ('completo','parziale'), loc=(.92,.6))
    plt.title('{}: tassi di soluzione (il numero in alto indica i minuti spesi in media sul quesito, \
il numero in basso il punteggio massimo ottenibile)'.format(k))

plt.tight_layout()
In [43]:
plt.figure(figsize=(16,20))

for j, k in enumerate(valid['categoria'].unique()):
    plt.subplot(5,1, j+1)
    plt.ylim(0,1.2)
    m = vquiz[vquiz['categoria'] == k].groupby('nome', 
                                             sort=False)[['completo','voto', 'parziale', 'penalizzato', 'minuti','score_max']].mean()
    m['vparziale'] = m['voto'] - m['completo']

    c = plt.bar(pd.np.arange(m.index.size), m['voto'], color='green')
    z = plt.bar(pd.np.arange(m.index.size), -m['penalizzato'], color='red')
    plt.ylim([-1,1])
    plt.yticks(pd.np.arange(-1,1.2,.2), ['{:.0f}%'.format(100*abs(y)) for y in pd.np.arange(-1,1.2,.2)])
 
    plt.xticks(pd.np.arange(m.index.size), map(bname, m.index.tolist()), rotation=90)
    for i, y in enumerate(m['voto'].tolist()):
        plt.annotate(s='{:.0f}'.format(m['score_max'].iloc[i]), xy=(i, -.8), color='blue')
    
    plt.legend((c[0],z[0]), ('punteggio','penalità'), loc=(0.91,.725))
    plt.title('{}: percentuale di punteggio attribuito in media, in rosso la percentuale di penalizzati (il numero in basso è il punteggio massimo)'.format(k))

plt.tight_layout()

Analisi delle squadre

In [44]:
members = []
for r in valid.itertuples():
    if r.team_composition and 'members' in r.team_composition:
        for m in r.team_composition['members']:
            m['categoria'] = r.category.lower()
            m['team_id'] = r.team_id
            members.append(m)

pupils = pd.DataFrame(members)
pupils['genere'] = pupils['sex'].map(lambda x: x if x != '-' else pd.np.NaN)
pupils['categoria'] = pupils['categoria'].astype(pd.api.types.CategoricalDtype(categories = CATS, ordered=True))
In [45]:
gender = pupils[pupils['genere'].notnull()].groupby(['categoria', 'genere']).count()
txt = '''<table><caption>Studenti partecipanti al Bebras 2019 con risultati validi 
(i dati dipendono dalla corretta compilazione dei profili delle squadre)</caption>
<thead>
  <tr><th>Categoria</th>
  <th>studenti</th>
  <th>femmine</th>
  <th>maschi</th>
  <th>squadre con dati mancanti</th>
  <th>media componenti per squadra</th>
  </tr>
<tbody>
'''
notempty = pupils[pupils['genere'].notnull()].groupby('categoria')['team_id'].nunique()
empty = pupils[pupils['genere'].isnull()].groupby('categoria')['team_id'].nunique()

totf = 0
totm = 0
for k in pupils['categoria'].unique():
    f = gender.loc[(k,'f')]['class']
    totf += f
    m = gender.loc[(k,'m')]['class']
    totm += m
    
    txt += '<tr><th>{}</th><td>{}</td><td>{} ({:.1f}%)</td><td>{} ({:.1f}%)</td><td>{}</td><td>{:.2f}</td></tr>'.format(
        k, f+m, f, 100*float(f)/float(f+m), m, 100*float(m)/float(f+m), empty[k], float(f+m) / float(notempty[k])
    )
txt += '<tr><th>Totale:</th><td>{}</td><td>{} ({:.1f}%)</td><td>{} ({:.1f}%)</td></tr>'.format(totf+totm, 
                                                                           totf, 100*float(totf)/float(totf+totm), 
                                                                           totm, 100*float(totm)/float(totf+totm))    
txt += '</table>'
display(Markdown(txt)) 
Studenti partecipanti al Bebras 2019 con risultati validi (i dati dipendono dalla corretta compilazione dei profili delle squadre)
Categoria studenti femmine maschi squadre con dati mancanti media componenti per squadra
kilo98794810 (48.7%)5069 (51.3%)9623.71
mega170977974 (46.6%)9123 (53.4%)19663.68
giga81433949 (48.5%)4194 (51.5%)8853.71
tera64782115 (32.6%)4363 (67.4%)7463.63
peta44551392 (31.2%)3063 (68.8%)5243.57
Totale:4605220240 (44.0%)25812 (56.0%)

I nomi delle squadre più comuni

In [46]:
import re
from collections import Counter

notwanted = re.compile('^0[0-9]+$|^[0-9][a-zA-Z0-9_]|^the$|^and$|^classe$|^squadra$|^gruppo$|^team$|^i+$|^iv$|^[a-zA-Z0-9_]$|^prima$|^seconda$\
|^terza$|^quarta$|^quinta$|^$')

names = scoredf['team_name'].str.strip().str.lower().tolist()
oknames = filter(lambda w: not notwanted.match(w), names)

c = Counter(oknames)

c.most_common(30)
Out[46]:
[('i matematici', 26),
 ('i fantastici 4', 25),
 ('blu', 22),
 ('gli informatici', 17),
 ('leoni', 15),
 ('gli invincibili', 14),
 ('viola', 13),
 ('rosso', 13),
 ('the best', 13),
 ('tigri', 13),
 ('i leoni', 13),
 ('verde', 12),
 ('carote', 12),
 ('i migliori', 11),
 ('rossi', 11),
 ('i tecnologici', 10),
 ('giallo', 10),
 ('i mitici', 10),
 ('gialli', 10),
 ('senza nome', 10),
 ('le tigri', 9),
 ('verdi', 9),
 ('i leggendari', 9),
 ('le matematiche', 9),
 ('mercurio', 9),
 ('i fulmini', 8),
 ('leone', 8),
 ('giove', 8),
 ('volpi', 8),
 ('le potenze', 8)]
In [47]:
plt.axis('off')
os = scoredf['operating_system'].value_counts().plot.pie(autopct='%.1f', radius=1.22,
                                                    explode=[.06*i*i for i in range(len(scoredf['operating_system'].unique()))],
                                                    figsize=(5,5), title='Sistemi operativi utilizzati')