Statistiche gare Bebras italiano 2020

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_2020&events=0&test={}".format(key,92+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 2020/21 con risultati correttamente registrati</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 2020/21 con risultati correttamente registrati
Categoria squadre min max media std.dev. I quartile mediana III quartile Squadre al minimo Squadre al massimo
kilo312004821.812.21221312.6%1.2%
mega657304824.411.61625332.6%1.2%
giga332104819.79.41320262.2%0.4%
tera332504818.710.31118262.1%0.4%
peta236304816.39.6916234.2%0.1%
Totale18702
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
2.63.84.95.98.39.412.113.615.518.220.522.726.028.531.534.136.539.842.545.748.850.954.256.359.562.164.867.669.672.073.776.278.079.882.284.085.087.089.089.792.493.094.694.897.797.998.898.8
Percentili per la categoria mega (che percentuale di squadre si supera con un dato punteggio)
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
2.63.54.44.75.86.77.68.710.112.012.914.917.019.321.023.126.228.431.633.936.939.642.245.949.352.255.058.061.465.167.870.573.675.679.381.684.285.388.289.392.693.995.695.996.897.098.698.8
Percentili per la categoria giga (che percentuale di squadre si supera con un dato punteggio)
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
2.22.63.54.24.97.08.110.312.314.117.520.623.226.530.233.737.941.144.250.053.458.461.466.467.774.476.679.381.084.886.489.091.592.293.295.596.496.797.798.098.098.799.399.399.599.599.699.6
Percentili per la categoria tera (che percentuale di squadre si supera con un dato punteggio)
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
2.12.54.45.67.28.712.714.518.121.424.427.831.434.437.842.044.747.851.455.858.662.864.767.970.073.475.479.180.683.685.187.689.090.892.293.494.496.096.897.297.798.498.999.399.599.599.699.6
Percentili per la categoria peta (che percentuale di squadre si supera con un dato punteggio)
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
4.25.36.79.411.113.816.119.622.325.729.633.537.241.945.749.454.058.062.366.468.971.674.177.579.982.185.086.087.990.891.593.294.495.095.395.996.997.498.398.798.999.299.599.599.799.999.999.9

Analisi delle risposte

In [13]:
rr = []
errors = 0
for r in valid.itertuples():
    for q in r.exam_data['questions']:
        try:
            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)
        except Exception as e:
            #print(q, e)
            errors += 1
print(errors)
1648
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': 'Il questionario',
    'Q02': 'Impronte',
    'Q03': 'La password',
    'Q04': 'I binari del treno',
    'Q05': 'Invito segreto',
    'Q06': 'Prenotazione ferroviaria',
    'Q07': 'Teatro',
    'Q08': 'Una struttura ad albero',
    'Q09': 'Libri in biblioteca',
    'Q10': 'Connetti i punti',
    'Q11': 'Salti',
    'Q12': 'Stelle e lune',
    'Q13': "L'orologio di un tranquillo paese medievale",
    'Q14': "L'alpinista",
    'Q15': 'Le canzoni di Lisa',
    'Q16': 'Riordinatore',
    'Q17': 'Città e autostrade',
    'Q18': 'Visita al museo',
    'Q19': 'Apparecchio magico',
    'Q20': 'Lucine intermittenti',
    'Q21': 'Creazione di numeri',
    'Q22': 'Incontri',
    'Q23': 'Mappa del bosco',
    'Q24': 'Strumento musicale',
    'Q25': 'LT-05',
    'Q26': 'PT-02c',
    'Q27': 'Unità di produzione',
    'Q28': 'Gemme',
    'Q29': 'Reversibilità',
    'Q30': 'Biglie',
}
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 [19]:
vquiz = pd.merge(valid[['anonid', 'categoria', 'punteggio','punteggio_norm','orainizio','teacher_id','school_cap']], quiz, on='anonid')
In [20]:
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()
plt.savefig('tassisol.png')
In [21]:
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()
plt.savefig('punti.png')

Analisi delle squadre

In [22]:
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 [23]:
gender = pupils[pupils['genere'].notnull()].groupby(['categoria', 'genere']).count()
txt = '''<table><caption>Studenti partecipanti al Bebras 2020 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 2020 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
kilo2025955 (47.2%)1070 (52.8%)4970.80
mega40251889 (46.9%)2136 (53.1%)8870.82
giga2031987 (48.6%)1044 (51.4%)4080.83
tera2441752 (30.8%)1689 (69.2%)3600.87
peta1678411 (24.5%)1267 (75.5%)1670.91
Totale:122004994 (40.9%)7206 (59.1%)

I nomi delle squadre più comuni

In [24]:
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[24]:
[('giulia', 17),
 ('matteo', 16),
 ('martina', 15),
 ('lorenzo', 14),
 ('sofia', 13),
 ('riccardo', 13),
 ('andrea', 12),
 ('gabriele', 11),
 ('sara', 11),
 ('emma', 11),
 ('anna', 11),
 ('davide', 10),
 ('aurora', 10),
 ('marco', 10),
 ('luca', 10),
 ('fenici', 9),
 ('francesco', 9),
 ('draghi', 9),
 ('viola', 9),
 ('tommaso', 8),
 ('jacopo', 8),
 ('alessandro', 8),
 ('giorgia', 8),
 ('daniele', 8),
 ('filippo', 7),
 ('pietro', 7),
 ('simone', 7),
 ('federico', 7),
 ('rebecca', 7),
 ('leonardo', 7)]
In [25]:
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')
In [ ]: