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 DataFrames1.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.coursedf[:, :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.knihadf."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 CSVNyní 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.usernamedf.assessmentNebo 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)ex1empty!(ex2)
empty(ex1)ex1ex2To 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.markdf.mark === df[!, :mark]df.mark === df[:, :mark] # kopie!df.mark == df[!, :mark]df.mark == df[:, :mark]missing == missingmissing == truemissing == falseVedle 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 ( je velké ):
ex[1, :a] = "Ξ"
exPřepsání všech hodnot ve sloupci c:
ex[:, :c] = ["tau", "pi", "omega"]exPřepsání jednou hodnotou.
ex[:, :c] .= "ř"exz = ex[:, :c]z[2] = "pí"zexz = ex[!, :c]z[2] = "¿"exex.c = [true, false, missing]
exPř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] .= "λ"
exex[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
exfor row in eachrow(ex)
println(row)
println(row[:a])
endZobrazovaní (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.
dfshow(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]
exMazá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.5delete!(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í:
- Joins.
- Grouping.
- Přehledné porovnání metod s pandas/R/Stata.
- Balíček
Query.jlumožňující pracovat s různými datovými zdroji. - Balíček
DataFramesMeta.jlposkytující užitečná makra pro práci s tabulkami. - Cheat Sheet
Velmi sofistikované transformace dat v tabulkách lze také provádět pomocí následujících metod:
combineselect/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 CSVdf1 = 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) |> sumsum(dropmissing(df2, :assessment).assessment)coalesce.(df2.assessment, false) |> sumsum(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 hodnotysum(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, StatisticsHistogram 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 |> lengthdf4.test2 |> skipmissing |> collect |> lengthdf4.test3 |> skipmissing |> collect |> lengthA v přeposledním běhu.
df3.test1 |> skipmissing |> collect |> lengthdf3.test2 |> skipmissing |> collect |> lengthdf3.test3 |> skipmissing |> collect |> lengthPoč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"]
dfdf = 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"]
dfdf = 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"]
df2.3 Zkouškové období
V BI-MA1 hodně rozdílné vůči BI-ZMA.
Histogram známek.
combine(groupby(df1, :mark), nrow => "studenti") |> sortcombine(groupby(df2, :mark), nrow => "studenti") |> sortcombine(groupby(df3, :mark), nrow => "studenti") |> sortsort(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") |> sortcombine(groupby(df1[df1.assessment .=== true, :], :exam_test), nrow => "počet") |> sortReference
Další informace, detaily či tutoriály lze nalézt v dokumentaci DataFrames.jl.
V notebooku jsme používali balíček CSV.jl.