Statistiche gare Bebras italiano 2023

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 numpy as np
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')
CATEGORIES = tuple(f'{c}' for c in CATS)
CAT_FILES = tuple(f'{c}' for c in CATS)
In [5]:
with open('secret.key') as k:
    key = k.readline().strip()

for i, k in enumerate(CAT_FILES):
    if not os.path.exists(f"results-{k}.json"):
        r = urllib.request.urlopen(f"https://bebras.it/api?key={key}&view=exams&edition=bebras_2023&events=0&test={114+i}")
        with open(f"results-{k}.json", "w") as tw:
            tw.writelines(r.read().decode('utf-8'))
In [6]:
score = []
for k in CATEGORIES:
    with open(f"results-{k}.json", "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'] = 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 = CATEGORIES, 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 2023/24 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().sort_values():
    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 2023/24 con risultati correttamente registrati
Categoria squadre min max media std.dev. I quartile mediana III quartile Squadre al minimo Squadre al massimo
kilo361904830.610.22432380.1%5.7%
mega1022304822.89.21622300.3%0.9%
giga466304818.910.01218260.9%0.5%
tera276005420.810.81220281.4%0.4%
peta189405222.411.61422301.2%0.9%
Totale23159
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,16), layout=(5, 2))
No description has been provided for this image

Percentili per punteggio

In [12]:
for k in valid['categoria'].unique().sort_values():
    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.10.20.40.60.60.71.11.32.12.33.13.55.25.77.57.910.711.313.614.617.818.823.024.028.229.534.535.540.742.247.648.955.957.062.263.470.470.977.778.581.581.889.889.993.193.494.394.3
Percentili per la categoria mega (che percentuale di squadre si supera con un dato punteggio)
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
0.30.40.60.91.21.82.53.54.56.38.010.512.615.219.222.726.529.535.437.844.847.652.554.861.362.369.270.673.974.980.681.185.586.488.188.493.093.194.895.195.895.998.698.698.999.099.199.1
Percentili per la categoria giga (che percentuale di squadre si supera con un dato punteggio)
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
0.91.22.83.46.56.911.211.916.417.123.924.631.432.138.438.946.947.354.154.661.461.868.368.773.073.378.879.183.783.986.987.190.290.492.592.694.494.496.796.797.597.598.798.799.399.399.499.5
Percentili per la categoria tera (che percentuale di squadre si supera con un dato punteggio)
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354
1.41.42.93.05.15.29.59.614.114.219.219.525.726.031.431.738.138.545.445.753.553.960.561.067.467.673.173.478.378.682.482.685.886.489.189.391.892.094.094.295.495.596.696.697.897.898.398.399.099.099.499.499.699.6
Percentili per la categoria peta (che percentuale di squadre si supera con un dato punteggio)
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152
1.21.22.52.55.15.18.68.613.013.018.318.324.024.030.330.336.336.342.742.748.848.854.154.159.659.665.265.270.170.175.975.981.281.285.285.288.188.190.790.793.693.695.395.396.896.898.098.098.698.699.199.1

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)
2681
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 casa dei sogni di Karla',
    'Q02': 'I cucchiaini',
    'Q03': 'Testa o croce',
    'Q04': 'Mazzi di fiori',
    'Q05': 'Il villaggio degli animali',
    'Q06': 'Arabeschi',
    'Q07': 'Albero di mele',
    'Q08': 'Palline nei tubi',
    'Q09': 'Scegliamo un regalo',
    'Q10': 'Alfabeto celtico',
    'Q11': 'Blocchi da raggruppare',
    'Q12': 'Quanti giri?',
    'Q13': "La rana e l'insetto",
    'Q14': "Fabbrica di giocattoli",
    'Q15': 'Fuochino',
    'Q16': 'Buste sigillate',
    'Q17': 'Robot nel parco',
    'Q18': 'Castelli fatati',
    'Q19': 'Gara di canto',
    'Q20': 'Deposito di pacchi',
    'Q21': 'BebrasGPT',
    'Q22': 'Guida autonoma difettosa',
    'Q23': 'Espressioni straordinarie',
    'Q24': 'Interruttori a levetta',
    'Q25': "Evoluzione simultanea",
    'Q26': 'Trenini',
    'Q27': 'Robot sincronizzati',
    'Q28': 'Il progetto del canale',
    'Q29': 'Mappatura digitale',
    'Q30': 'La raccolta delle mele'
}
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 np.NaN)

quiz.to_csv('quiz.csv', columns=['anonid', 'cat', 'edizione', 'nome', '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,40))

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().sort_values()):
    plt.subplot(len(valid['categoria'].unique()), 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(np.arange(m.index.size), m['completo'], color='blue')
    p = plt.bar(np.arange(m.index.size), m['parziale'], bottom=m['completo'], color='lightblue')   
    plt.xticks(np.arange(m.index.size), map(bname, m.index.tolist()), rotation=45)
    plt.ylim([0,1])
    plt.yticks(np.arange(0,1.2,.2), ['{:.0f}%'.format(100*y) for y in np.arange(0,1.2,.2)])
    for i, y in enumerate(m['voto'].tolist()):
        plt.annotate(text='{:.0f}\''.format(m['minuti'].iloc[i]), xy=(i, .75*m['completo'].iloc[i]), color='white')
        plt.annotate(text='{:.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')
No description has been provided for this image
In [21]:
plt.figure(figsize=(16,40))

for j, k in enumerate(valid['categoria'].unique()):
    plt.subplot(len(valid['categoria'].unique()),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(np.arange(m.index.size), m['voto'], color='green')
    z = plt.bar(np.arange(m.index.size), -m['penalizzato'], color='red')
    plt.ylim([-1,1])
    plt.yticks(np.arange(-1,1.2,.2), ['{:.0f}%'.format(100*abs(y)) for y in np.arange(-1,1.2,.2)])
 
    plt.xticks(np.arange(m.index.size), map(bname, m.index.tolist()), rotation=45)
    for i, y in enumerate(m['voto'].tolist()):
        plt.annotate(text='{:.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')