Jdi na navigaci předmětu

09: Zpracování a analýza dat

Tento notebook je výukovým materiálem v předmětu BI-JUL.21 vyučovaném v zimním semestru akademického roku 2023/2024 Tomášem Kalvodou. Tvorba těchto materiálů byla podpořena NVS FIT.

Hlavní stránkou předmětu, kde jsou i další notebooky a zajímavé informace, je jeho Course Pages stránka.

versioninfo()

1. DataFrames.jl

Pro práci s daty jistě znáte Pythonovský nástroj pandas. DataFrames.jl je v podstatě Julia analog tohoto nástroje. Pokud jste zvyklí pandas používat, může pro vás být užitečné porovnání pandas s Dataframes.jl.

using DataFrames

1.1 Jak vytvořit DataFrame?

DataFrame lze vytvořit mnoha způsoby. Můžeme začít s prázdnou tabulkou a postupně ji naplnit daty, nebo využít existující matici, nebo data načíst z externího souboru.

Prázdný DataFrame vytvoříme velmi snadno:

DataFrame()

Keyword argumenty a NamedTuple

Data v pojmenovaných sloupcích můžeme předat pomocí keyword argumentů (klíčové slovo je název sloupce, hodnota data):

df = DataFrame(course=["BI-LA1", "BI-DML", "BI-MA1", "BI-MA2"], semester=[1, 1, 2, 2], department=18105)
df.course
df[:, :course]
df[:, 1]

Tímto způsobem bychom ovšem měli problém zadat data se sloupcích, jejichž názvy obsahují třeba speciální znaky jako mezery. K tomu můžeme použít slovník, resp. dvojice (klíče mohou být řetězce nebo symboly -- ty jsou doporučené, místo mezer je vhodnější použít podtžítka :slovo_slovo):

df = DataFrame("fiktivní postava" => ["Gandalf", "Harry Potter"], "kniha" => ["Pán prstenů", "Harry Potter a kámen mudrců"])
df.kniha
df."fiktivní postava"
df.var"fiktivní postava"
df[:, "fiktivní postava"]

Další možností je použít NamedTuple:

nt = (a = 1, b = 3)
nt[1], nt[2]
nt[:a], nt[:b]

Po sloupcích (pozor na jemný rozdíl od výše uvedeného způsobu):

DataFrame((a = [1,2,3], b = [4,5,6]))

Po řádcích:

DataFrame([(a = 1, b = 4), (a = 2, b = 5), (a = 3, b = 6)])
df = DataFrame([(a = 1, b = 4, c = nothing), (a = 2, b = 5, c = nothing), (a = 3, b = nothing, c = 6)])
describe(df)

Matice

K vytvoření DataFrame můžeme použít i matici, jen musíme vyřešit pojmenování sloupců. Automaticky (nutno zadat jako druhý argument :auto) budou označeny jako x1, x2, atd.:

DataFrame(rand(2, 3), :auto)
DataFrame(rand(Int64, 2, 3), :auto)

V druhém argumentu případně můžeme zadat naše názvy sloupců:

DataFrame(rand(2, 3), ["col1", "col2", "col3"])

CSV.jl

V tomto notebooku budeme pro některé ukázky používat CSV anonymizovaný export z Grades předmětu BI-MA1 v semestru B212 (2021/2022). Importu dat z CSV lze snadno docílit pomocí balíčku CSV.jl, který přidáme standardně ] add CSV a pak importujeme:

using CSV

Nyní stačí použít metodu read z modulu CSV, v prvním argumentu zadáme cestu k souboru a v druhém uvedeme požadovaný výstupní "formát", v našem případě DataFrame:

df = CSV.read(joinpath("files", "bi-ma1-b232.csv"), DataFrame)

K těmto datům se vrátíme podrobněji později. Samotnou tabulku občas použijeme v různých ukázkách.


1.2 Práce s DataFrame

Z částečného výpisu dat výše vyvstává hned několik otázek:

  • Jaké sloupce jsou ještě k dispozici?
  • Proč je typ pod některými sloupci s otazníkem?
  • Co znamená missing?

Pojďme se vydat na průzkum. První, co můžeme zkusit, je podívat se na atributy naší instance (interaktivně pomocí TAB):

#df.
df.username
df.assessment

Nebo k tomu můžeme použít metodu names z modulu DataFrames:

names(df)

Metoda eachcol vrátí iterátor přes sloupce. Můžeme tak zjistit typ prvků sloupců:

eltype.(eachcol(df))

Odtud vidíme, co znamenají otazníky u typů prvků sloupců. Prvky sloupce jsou složeného typu Union{Missing, T}, v některých sloupcích mohou hodnoty chybět, obsahují hodnotu missing.

Stručné informace můžeme získat pomocí metody describe. Samozřejmě občas uvedené statistiky nemají moc smysl.

describe(df)

Výpis můžeme kontrolovat uvedením konkrétního rozsahu.

describe(df, cols=["test1", "test2", "test3"])

DataFrame je tabulka, máme pro ní k dispozici podobné metody jako pro matice, na které se také lze dívat jako na "tabulky".

size(df)
nrow(df)
ncol(df)

DataFrame lze kopírovat pomocí metody copy, nebo ho vyprázdnit pomocí metod empty, resp. empty!.

ex1 = DataFrame(rand(3, 2), :auto)
ex2 = copy(ex1)
ex1
empty!(ex2)
empty(ex1)
ex1
ex2

To by bylo pro začátek vše k základním vlastnostem. Pojďme nyní tabulky modifikovat, upravovat.


Indexování a přístup ke sloupcům

Indexování vychází z maticového zápisu a má podobné vlastnosti. Ke sloupcům můžeme přistupovat několika způsoby:

  • pomocí názvu a tečky: df.mark, df."mark"
  • pomocí indexace (nevytvoří kopii): df[!, :mark], df[!, "mark"]
  • pomocí indexace (vytvoří kopii): df[:, :mark], df[:, "mark"]

Tímto způsobem můžeme data číst, ale i je modifikovat.

df.mark
df.mark === df[!, :mark]
df.mark === df[:, :mark] # kopie!
df.mark == df[!, :mark]
df.mark == df[:, :mark]
missing == missing
missing == true
missing == false

Vedle toho nemusíme používat název sloupce, v pořádku je použít i pořadí. Například prvních deset řádků v druhém a třetím sloupci:

df[1:10, ["test1", "test2", "test3"]]

Not, Between, Cols, All

Dále můžeme vybírat pouze potřebné sloupce.

ex = DataFrame(rand(3, 5), :auto)
ex[:, Not(:x2)]
Not(:x2)
ex[:, Not([:x2, :x3])]
ex[:, Between(:x1, :x3)]
ex[:, Not(Between(:x1, :x3))]
ex[:, Cols(:x2, :x4)]
ex[:, All()]

Výše uvedené ukázky využívají funkcionalitu z DataFrames.jl balíčku. "Staré maticové" postupy samozřejmě fungují také, např.:

ex[:, [:x2, :x3]]

Přepisování dat

Údaje můžeme měnit několika způsoby. Vezměme si jednoduchou tabulku:

m = [ "α" 1 0.5; "β" 2 1.5; "γ" 3 2.5]
ex = DataFrame(m, ["a", "b", "c"])

Změna jedné položky (Ξ\Xi je velké ξ\xi):

ex[1, :a] = "Ξ"

ex

Přepsání všech hodnot ve sloupci c:

ex[:, :c] = ["tau", "pi", "omega"]
ex

Přepsání jednou hodnotou.

ex[:, :c] .= "ř"
ex
z = ex[:, :c]
z[2] = "pí"
z
ex
z = ex[!, :c]
z[2] = "¿"
ex
ex.c = [true, false, missing]

ex

Přepsání hodnot ve sloupci a danou hodnotou, ale pouze v řádcích, kde je hodnota ve sloupci b lichá (zde opět používáme indexování bitovým vektorem, nebo "maskování", s kterým jsme se setkali dříve během semestru):

isodd.(ex.b)
ex[isodd.(ex.b), :a] .= "λ"

ex
ex[iseven.(ex.b), :]

Občas je nutné projít tabulku řádek po řádku. V tom případě můžeme iterovat přes index. Například se pokusme změnit první sloupec na řetězec obsahující daný symbol se spodním indexem daným číslem ve sloupci b v LaTeX notaci (tj. λ_1 atd.).

for row_id = axes(ex, 1) # 1:nrow(df)
    ex[row_id, :a] = ex[row_id, :a] * "_" * string(ex[row_id, :b])
end

ex
for row in eachrow(ex)
    println(row)
    println(row[:a])
end

Zobrazovaní (show, first, last, view)

Pokud je DataFrame příliš velký, tak při jeho zobrazení dojde k ořezání (řádků i sloupců). Toto chování můžeme přebít pomocí parametrů metody show.

U našeho BI-ZMA příkladu je to lehce overkill.

df
show(df)
show(df, allcols=true)

Toto by byl ještě větší overkill.

# show(df, allrows=true)

Případně můžeme prozkoumávat začátek a konec tabulky.

first(df, 10)
last(df, 10)

Pro rychlé prozkoumávání částí tabulky slouží metoda view, resp. makro @view, která jen část tabulky zobrazí. Nevytváří nový objekt, měla by být efektivnější.

view(df, 100:150, [:username, :points_total, :mark])
@view df[10:15, [:username, :mark]]

Přidávání a odebírání sloupců

K přidávání sloupců slouží metoda insertcols!:

ex = DataFrame(rand(2, 2), :auto)

Na konec a kopie.

insertcols(ex, :a => [1, 2])

Na konkrétní místo.

insertcols!(ex, 1, :a => [pi, pi])
insertcols!(ex, 1, :a2 => [pi, -pi])
insertcols!(ex, 3, :b => "⊕")
insertcols!(ex, 5, :c => [1, 2])

Ale lze použít i prosté indexování:

ex[:, :d] = [42, 42]

ex

Mazání sloupců musíme provést pomocí indexace, neexistuje metoda "dropcolumns!".

ex[:, Not(:b)]

Přidávání a odebírání řádků

Vytvořme si zase testovací tabulku:

ex = DataFrame(rand(2, 2), :auto)

Přidat řádek lze opět několika způsoby. Nejpřirozenější je asi metoda push!:

push!(ex, [1.0, 2.0])
push!(ex, [1, 2])
push!(ex, (0.5, 2.3))
push!(ex, ["a", "b"])
push!(ex, ["a", "b"], promote=true)
push!(ex, (x2 = 0.5, x1 = 0.3))
push!(ex, (x2 = 7, x1 = 5))

Pomocí append! můžeme spojovat několik tabulek "vertikálně" dohromady:

append!(ex, DataFrame(rand(10, 2), :auto))

Mazat řádky můžeme explicitně pomocí delete!:

delete!(ex, 3)
delete!(ex, [1, 2, 3])
delete!(ex, 2)
ex.x1 .> 0.5
delete!(ex, ex.x1 .> 0.5)

To zdaleka není všechno

Výše jsme shrnuli zřejmě ty nejužitečnější metody a techniky. Tím ale možnosti DataFrames.jl zdaleka nekončí. Zvídavému čtenáři doporučujeme prolétnout dokumentaci. Na tomto místě snad jen upozorněme na následující:

Velmi sofistikované transformace dat v tabulkách lze také provádět pomocí následujících metod:

  • combine
  • select/select!
  • transform/transform!

Jejich podrobný výklad je už nad rámec tohoto kurzu.


2. Cvičení: analýza BI-MA1 v B212, B222, B232

Pojďme se podrobněji podívat na data z předmětu BI-MA1.

Nejprve znovu načteme data z CSV souboru, který je syrovým exportem z Grades, kde jsou anonymizováni uživatelská jména studentů.

using CSV
df1 = CSV.read(joinpath("files", "bi-ma1-b212.csv"), DataFrame)
df2 = CSV.read(joinpath("files", "bi-ma1-b222.csv"), DataFrame)
df3 = CSV.read(joinpath("files", "bi-ma1-b232.csv"), DataFrame)
df4 = CSV.read(joinpath("files", "bi-ma1-b242.csv"), DataFrame);
describe(df1)
size(df1)
nrow(df1)
describe(df2)
size(df2)
nrow(df2)
describe(df3)
size(df3)
describe(df4)

2.1 Základní údaje

Nejprve prozkoumejte dostupné sloupce a pokuste se zjistit základní údaje jako

  • Kolik studentů mělo předmět zapsáno?
  • Kolik studentů získalo zápočet a dokončilo předmět?
  • Kolik studentů bylo v jakém ročníku? (V prvním běhu BI-MA1 toto nemá smysl.)
  • ...

Počet studentů.

nrow(df1)
nrow(df2)
nrow(df3)
nrow(df4)

Kolik studentů má zápočet?

sum(df1.assessment)
length(filter(isone, df1.assessment))
sum(df2.assessment)
sum(skipmissing(df2.assessment))
sum(df2[(!ismissing).(df2.assessment), :assessment])
filter(x -> !ismissing(x), df2.assessment)
filter(x -> !ismissing(x), df2.assessment) |> sum
sum(dropmissing(df2, :assessment).assessment)
coalesce.(df2.assessment, false) |> sum
sum(df3.assessment)
sum(df4.assessment)

Tj. průchodnost zápočtu.

sum(df1.assessment) / nrow(df1)
sum(coalesce.(df2.assessment, 0)) / nrow(df2)
sum(df3.assessment) / nrow(df3)
sum(df4.assessment) / nrow(df4)

Počet vet v tabulce.

sum(df1.veto)
missing + 1 # aha! pozor na missing hodnoty
sum(dropmissing(df1[:, Cols(:veto)]).veto)
sum(filter(x -> !ismissing(x), df1.veto))
sum(dropmissing(df1, :veto).veto)
sum(dropmissing(df2, :veto).veto)
sum(dropmissing(df3, :veto).veto)
sum(dropmissing(df4, :veto).veto)

Úspěšně dokončilo předmět:

length(filter(x -> x != "F", dropmissing(df1, :mark).mark))
sum(dropmissing(df1, :mark).mark .!= "F")
sum(dropmissing(df2, :mark).mark .!= "F")
sum(dropmissing(df3, :mark).mark .!= "F")
sum(dropmissing(df4, :mark).mark .!= "F")

Počet studentů, kteří získali zápočet a současně neuspěli u zkoušky.

sum(df1.assessment .&& (df1.mark .== "F"))
sum(coalesce.(df2.assessment, false) .&& df2.mark .== "F")
sum(coalesce.(df3.assessment, false) .&& df3.mark .== "F")
sum(coalesce.(df4.assessment, false) .&& coalesce.(df4.mark, "F") .== "F")

2.2 Zápočtové písemky, kvízy a semestr

Poté se podívejme podrobněji jak probíhalo získávání zápočtů.

  • Prozkoumejte výsledky jednotlivých zápočtových písemek, vytvořte historgramy výsledků.
  • Kolika studentům zápočet "těsně" unikl?
  • Kolik studentů "odpadlo" už v první polovině semestru?
  • ...
using PyPlot, Statistics

Histogram prvního zápočtové testu.

plt.grid()
hist(collect(skipmissing(df4.test1)), bins=[ -0.49 + j for j in 0:4]);

Pozor, se samotným skipmissing nefunguje.

skipmissing(df3.test1)
collect(skipmissing(df3.test1))
mean(skipmissing(df3.test1))
median(skipmissing(df3.test1))
length(collect(skipmissing(df3.test1)))
nrow(df3) - length(df3.test1[ismissing.(df3.test1)])

Poslední běh lze porovnat s předposledním během!

plt.grid()
hist(collect(skipmissing(df3.test1)), bins=[ -0.49 + j for j in 0:4]);

Histogram druhého zápočtového testu.

plt.grid()
hist(collect(skipmissing(df4.test2)), bins=[ -0.49 + j for j in 0:21]);
plt.grid()
hist(collect(skipmissing(df3.test2)), bins=[ -0.49 + j for j in 0:21]);

Třetí test.

plt.grid()
hist(collect(skipmissing(df4.test3)), bins=[ -0.49 + j for j in 0:21]);
plt.grid()
hist(collect(skipmissing(df3.test3)), bins=[ -0.49 + j for j in 0:21]);

Počet studentů píšících testy v posledním běhu.

df4.test1 |> skipmissing |> collect |> length
df4.test2 |> skipmissing |> collect |> length
df4.test3 |> skipmissing |> collect |> length

A v přeposledním běhu.

df3.test1 |> skipmissing |> collect |> length
df3.test2 |> skipmissing |> collect |> length
df3.test3 |> skipmissing |> collect |> length

Počet studentů, kteří získali zápočet bez opravné zápočtové písemky.

sum(coalesce.(df1.test1 + df1.test2, 0) .>= 25.)
sum(coalesce.(df2.test1 + df2.test2 + df2.test3, 0) .>= 25.)
sum(coalesce.(df3.test1 + df3.test2 + df3.test3, 0) .>= 25.)
sum(coalesce.(df4.test1 + df4.test2 + df4.test3, 0) .>= 25.)

Počet studentů s alespoň 20 body ze zápočtových písemek.

nrow(df1[coalesce.(df1.tests_total .>= 20, false), :])
nrow(df2[coalesce.(df2.tests_total .>= 20, false), :])
nrow(df3[coalesce.(df3.tests_total .>= 20, false), :])
nrow(df4[coalesce.(df4.tests_total .>= 20, false), :])
plt.grid()
hist(collect(skipmissing(df4.test1 + df4.test2 + df4.test3)), bins=[ -0.49 + j for j in 0:44]);
plt.grid()
hist(collect(skipmissing(df3.test1 + df3.test2 + df3.test3)), bins=[ -0.49 + j for j in 0:44]);
plt.grid()
hist(collect(skipmissing(df2.test1 + df2.test2 + df2.test3)), bins=[ -0.49 + j for j in 0:44]);

Histogram opravné zápočtové písemky.

plt.grid()
hist(filter(x -> !ismissing(x), df1.second_chance), bins=[ -0.49 + j for j in 0:25]);
plt.grid()
hist(filter(x -> !ismissing(x), df2.second_chance), bins=[ -0.49 + j for j in 0:25]);
plt.grid()
hist(filter(x -> !ismissing(x), df3.second_chance), bins=[ -0.49 + j for j in 0:25]);
plt.grid()
hist(filter(x -> !ismissing(x), df4.second_chance), bins=[ -0.49 + j for j in 0:25]);

Histogram celkového počtu bodů ze semestru.

plt.grid()
hist(filter(x -> !ismissing(x), df1.tests_total), bins=[ -0.49 + j for j in 0:41]);
plt.grid()
hist(filter(x -> !ismissing(x), df2.tests_total), bins=[ -0.49 + j for j in 0:44]);
plt.grid()
hist(filter(x -> !ismissing(x), df3.tests_total), bins=[ -0.49 + j for j in 0:44]);
plt.grid()
hist(filter(x -> !ismissing(x), df4.tests_total), bins=[ -0.49 + j for j in 0:44]);

Úspěšnost zisku zápočtu podle cvičících.

groupby(df4, :tutor)
df = combine(groupby(df4, :tutor),
    nrow => "studenti",
    :assessment => sum => "zápočty",
    :test1 => (x -> length(collect(skipmissing(x)))) => "psali 1. test",
    :activity => (x -> mean(coalesce.(x, 0))) => "průměrná aktivita"
)
df[:, "propustnost"] = df[:, "zápočty"] ./ df[:, "studenti"]
df
df = combine(groupby(df3, :tutor),
    nrow => "studenti",
    :assessment => sum => "zápočty",
    :test1 => (x -> length(collect(skipmissing(x)))) => "psali 1. test",
    :activity => (x -> mean(coalesce.(x, 0))) => "průměrná aktivita"
)
df[:, "propustnost"] = df[:, "zápočty"] ./ df[:, "studenti"]
df
df = combine(groupby(df2, :tutor),
    nrow => "studenti",
    :assessment => sum => "zápočty",
    :test1 => (x -> length(collect(skipmissing(x)))) => "psali 1. test",
    :activity => (x -> mean(coalesce.(x, 0))) => "průměrná aktivita"
)
df[:, "propustnost"] = df[:, "zápočty"] ./ df[:, "studenti"]
df

2.3 Zkouškové období

V BI-MA1 hodně rozdílné vůči BI-ZMA.

Histogram známek.

combine(groupby(df1, :mark), nrow => "studenti") |> sort
combine(groupby(df2, :mark), nrow => "studenti") |> sort
combine(groupby(df3, :mark), nrow => "studenti") |> sort
sort(combine(groupby(df1[coalesce.(df1.gitlab, 0) .> 0 ,:], :mark), nrow => "studenti"), :mark)
sort(combine(groupby(df2[coalesce.(df2.gitlab, 0) .> 0 ,:], :mark), nrow => "studenti"), :mark)
sort(combine(groupby(df3[coalesce.(df3.gitlab, 0) .> 0 ,:], :mark), nrow => "studenti"), :mark)
sort(combine(groupby(df1[coalesce.(df1.activity, 0) .> 2 ,:], :mark), nrow => "studenti"), :mark)
sort(combine(groupby(df2[coalesce.(df2.activity, 0) .> 2 ,:], :mark), nrow => "studenti"), :mark)
sort(combine(groupby(df3[coalesce.(df3.activity, 0) .> 2 ,:], :mark), nrow => "studenti"), :mark)
plt.grid()
hist(filter(x -> !ismissing(x), df1.oral_exam), bins=[ -0.49 + j for j in 0:61]);
plt.grid()
hist(filter(x -> !ismissing(x), df2.oral_exam), bins=[ -0.49 + j for j in 0:58]);
plt.grid()
hist(filter(x -> !ismissing(x), df3.oral_exam), bins=[ -0.49 + j for j in 0:58]);
plt.grid()
hist(filter(x -> !ismissing(x), df1.exam_test), bins=[ -0.49 + j for j in 0:21]);
plt.grid()
hist(filter(x -> !ismissing(x), df2.exam_test), bins=[ -0.49 + j for j in 0:21]);
plt.grid()
hist(filter(x -> !ismissing(x), df3.exam_test), bins=[ -0.49 + j for j in 0:21]);
combine(groupby(df1, :exam_test), nrow => "počet") |> sort
combine(groupby(df1[df1.assessment .=== true, :], :exam_test), nrow => "počet") |> sort

Reference

Další informace, detaily či tutoriály lze nalézt v dokumentaci DataFrames.jl. V notebooku jsme používali balíček CSV.jl.