Tabel Pivot di DataFrames.jl 1.4 – Beragampengetahuan
Oleh: Blog Bogumił Kamiński
Repost dari:
Beberapa waktu yang lalu saya menulis artikel tentang unstack fungsi
di DataFrames.jl. Sejak rilis DataFrames.jl 1.4, fungsi ini telah diterima
Pembaruan utama fungsionalitas disediakan. Itu mungkin sekarang
Membuat tabel pivot dengan mudah menggunakan unstack seperti yang akan saya tunjukkan hari ini.
Contoh yang akan kita gunakan adalah analisis simulasi grafik, seperti pada bulan Mei 2023
Saya ikut mengatur
Lokakarya ke-18 tentang Algoritma dan Model untuk Grafik Web.
Jika Anda tertarik dengan topik ini, silakan datang dan bergabunglah dengan kami. jika kamu mau
ingin mempresentasikan karya anda, berikut adalah Paper Requestnya.
Posting ditulis di bawah Julia 1.8.2, Graphs.jl 1.7.4,
ProgressMeter.jl 1.7.2, Plots.jl 1.36.2 dan DataFrames.jl 1.4.3.
Kami akan mempertimbangkan grafik stokastik Erdős–Rényi. Grafik ini memiliki dua
parameter n (jumlah node dalam grafik) dan p probabilitas tepi
(independen untuk setiap sisi). Oleh karena itu, dapat dihitung bahwa harapan
Banyaknya sisi dari graf tersebut adalah pn(n-1)/2jadi diharapkan tingkat node rata-rata
Menjadi d=p(n-1). Jadi berikan n dan d kita bisa menghitung p=d/(n-1). Di Graphs.jl
Anda dapat membuat bagan ini menggunakan erdos_renyi fungsi.
Komponen terhubung dari graf adalah kelas ekuivalensi dari a
hubungan aksesibilitas antara pasangan node. informal: dalam hubungan
komposisi semua node dapat dicapai dari satu sama lain dan tidak ada node yang berada di luar
dari komponen yang terhubung dapat diperoleh dari itu.
Izinkan saya menjelaskannya dengan contoh:
julia> using Graphs
julia> using Random
julia> Random.seed!(1234);
julia> er = erdos_renyi(7, 0.2)
{7, 4} undirected simple Int64 graph
julia> collect(edges(er))
4-element Vector{Graphs.SimpleGraphs.SimpleEdge{Int64}}:
Edge 1 => 6
Edge 3 => 7
Edge 4 => 6
Edge 5 => 6
julia> connected_components(er)
3-element Vector{Vector{Int64}}:
[1, 4, 5, 6]
[2]
[3, 7]
Kami telah menghasilkan histogram acak pada 7 node dengan probabilitas tepi sama dengan 0,2.
Ini memiliki 4 tepi. Perhatikan bahwa grafik kita tidak diarahkan, jadi meskipun Graphs.jl
tampilkan tepi seperti ini: 1 => 6tepinya dua dimensi.
Kami mencatat bahwa node 6 terhubung ke node 1, 4 dan 5. Jadi mereka
membentuk komponen yang terhubung. Ada juga tepi antara node 3 dan 7,
jadi ini adalah komponen terhubung kedua. Akhirnya node 2 diisolasi, untuk
Kami adalah pihak ketiga. Kita dapat dengan mudah menemukan komponen-komponen graf yang terhubung
menggunakan connected_components fungsi.
Kami ingin menyelidiki bagaimana ukuran komponen yang terhubung terbesar
dari grafik stokastik Erdős–Rényi bergantung pada n dan d menggunakan simulasi.
Kami menghasilkan data untuk n berharga [100, 1000, 10_000, 100_000]
dan d berharga 0.5:0.1:2.0. Untuk setiap kombinasi
dari nilai kami ulangi percobaan 64 waktu.
Mari pertama-tama buat kerangka data awal dengan pengaturan pengujian:
julia> using DataFrames
julia> df = allcombinations(DataFrame,
d=0.5:0.1:2.0,
n=[100, 1000, 10_000, 100_000],
rep=1:64)
4096×3 DataFrame
Row │ d n rep
│ Float64 Int64 Int64
──────┼────────────────────────
1 │ 0.5 100 1
2 │ 0.6 100 1
3 │ 0.7 100 1
4 │ 0.8 100 1
5 │ 0.9 100 1
⋮ │ ⋮ ⋮ ⋮
4092 │ 1.6 100000 64
4093 │ 1.7 100000 64
4094 │ 1.8 100000 64
4095 │ 1.9 100000 64
4096 │ 2.0 100000 64
4086 rows omitted
Sekarang kita menghitung p Untuk setiap percobaan:
julia> df.p = df.d ./ (df.n .- 1);
julia> df
4096×4 DataFrame
Row │ d n rep p
│ Float64 Int64 Int64 Float64
──────┼─────────────────────────────────────
1 │ 0.5 100 1 0.00505051
2 │ 0.6 100 1 0.00606061
3 │ 0.7 100 1 0.00707071
4 │ 0.8 100 1 0.00808081
5 │ 0.9 100 1 0.00909091
⋮ │ ⋮ ⋮ ⋮ ⋮
4092 │ 1.6 100000 64 1.60002e-5
4093 │ 1.7 100000 64 1.70002e-5
4094 │ 1.8 100000 64 1.80002e-5
4095 │ 1.9 100000 64 1.90002e-5
4096 │ 2.0 100000 64 2.00002e-5
4086 rows omitted
Terakhir, untuk setiap baris, kami menghitung proporsi node dalam komponen terbesar
(perhitungannya memakan waktu, jadi saya gunakan @showprogress untuk memantaunya):
julia> using ProgressMeter
julia> df.largest = @showprogress map(eachrow(df)) do row
er = erdos_renyi(row.n, row.p)
cc = connected_components(er)
return maximum(length, cc) / row.n
end;
Progress: 100%|███████████████████████████████████████████████| Time: 0:00:39
julia> df
4096×5 DataFrame
Row │ d n rep p largest
│ Float64 Int64 Int64 Float64 Float64
──────┼──────────────────────────────────────────────
1 │ 0.5 100 1 0.00505051 0.04
2 │ 0.6 100 1 0.00606061 0.07
3 │ 0.7 100 1 0.00707071 0.22
4 │ 0.8 100 1 0.00808081 0.29
5 │ 0.9 100 1 0.00909091 0.35
⋮ │ ⋮ ⋮ ⋮ ⋮ ⋮
4092 │ 1.6 100000 64 1.60002e-5 0.64289
4093 │ 1.7 100000 64 1.70002e-5 0.69333
4094 │ 1.8 100000 64 1.80002e-5 0.73421
4095 │ 1.9 100000 64 1.90002e-5 0.77021
4096 │ 2.0 100000 64 2.00002e-5 0.79805
4086 rows omitted
Sekarang kami siap untuk menganalisis data ini menggunakan unstack.
Izinkan saya mengulangi struktur umum dari unstack panggilan
(lihat dokumentasinya untuk detail lebih lanjut):
unstack([data_frame],
[columns to use as row keys],
[column storing column names],
[column storing the values];
combine=[function to apply to the values])
Strukturnya mudah diingat. Setelah kerangka data, kami lulus secara berurutan
apa yang kita inginkan di baris, apa yang kita inginkan di kolom, nilai apa yang ingin kita hapus,
dan akhirnya, a combine argumen kata kunci (diperkenalkan di DataFrames.jl 1.4)
tentukan operasi apa yang ingin kita terapkan pada nilai-nilai ini.
secara default combine Menjadi onlyberarti kita menginginkan nilai unik
kombinasi baris-kolom dan jika tidak, kami mendapatkan kesalahan. Mari kita periksa caranyaunstack berfungsi secara default menggunakan [:d, :rep] untuk barang, :n untuk kolom,
dan :largest untuk nilai:
julia> unstack(df, [:d, :rep], :n, :largest)
1024×6 DataFrame
Row │ d rep 100 1000 10000 100000
│ Float64 Int64 Float64? Float64? Float64? Float64?
──────┼────────────────────────────────────────────────────────
1 │ 0.5 1 0.04 0.009 0.0017 0.00021
2 │ 0.6 1 0.07 0.046 0.0024 0.00035
3 │ 0.7 1 0.22 0.011 0.0042 0.00048
4 │ 0.8 1 0.29 0.019 0.01 0.00139
5 │ 0.9 1 0.35 0.027 0.0109 0.00166
⋮ │ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮
1020 │ 1.6 64 0.63 0.665 0.6419 0.64289
1021 │ 1.7 64 0.69 0.683 0.6941 0.69333
1022 │ 1.8 64 0.33 0.746 0.7389 0.73421
1023 │ 1.9 64 0.84 0.761 0.7696 0.77021
1024 │ 2.0 64 0.83 0.818 0.7991 0.79805
1104 rows omitted
Semuanya berfungsi, karena untuk setiap sel kami memiliki kombinasi baris dan
kunci kolom. Namun, jika kita, misalnya, mengurangi :repkita akan mendapatkan sebuah
kesalahan:
julia> unstack(df, :d, :n, :largest)
ERROR: ArgumentError: Duplicate entries in unstack
at row 65 for key (0.5,) and variable 100.
Pass `combine` keyword argumen t to specify how they should be handled.
Mari kita mulai dengan lewat combine=copy untuk hanya menyimpan semua nilai:largest setiap kombinasi baris-kolom:
julia> unstack(df, :d, :n, :biggest, combine=copy) Baris dataframe 16×5 │ d 100 1000 │ Array64…? Himpunan…? 1 0,5 [0.04, 0.06, 0.05, 0.05, 0.08, 0… [0.009, 0.015, 0.009,
2 │ 0.6 [0.07, 0.07, 0.05, 0.07, 0.04, 0… [0.046, 0.013, 0.018,
3 │ 0.7 [0.22, 0.13, 0.05, 0.09, 0.18, 0… [0.011, 0.019, 0.024,
4 │ 0.8 [0.29, 0.11, 0.08, 0.09, 0.1, 0.… [0.019, 0.068, 0.018,
5 │ 0.9 [0.35, 0.19, 0.19, 0.19, 0.11, 0… [0.027, 0.029, 0.057,
6 │ 1.0 [0.42, 0.12, 0.15, 0.22, 0.16, 0… [0.11, 0.068, 0.042,
7 │ 1.1 [0.26, 0.32, 0.23, 0.69, 0.36, 0… [0.146, 0.085, 0.266,
8 │ 1.2 [0.45, 0.09, 0.35, 0.42, 0.25, 0… [0.232, 0.175, 0.338,
9 │ 1.3 [0.49, 0.47, 0.12, 0.17, 0.67, 0… [0.376, 0.504, 0.434,
10 │ 1.4 [0.36, 0.45, 0.49, 0.49, 0.47, 0… [0.448, 0.527, 0.443,
11 │ 1.5 [0.72, 0.6, 0.65, 0.57, 0.69, 0.… [0.577, 0.474, 0.581,
12 │ 1.6 [0.31, 0.77, 0.41, 0.42, 0.73, 0… [0.639, 0.584, 0.644,
13 │ 1.7 [0.78, 0.62, 0.68, 0.7, 0.67, 0.… [0.673, 0.651, 0.653,
14 │ 1.8 [0.86, 0.91, 0.7, 0.71, 0.76, 0.… [0.721, 0.739, 0.748,
15 │ 1.9 [0.8, 0.76, 0.79, 0.83, 0.76, 0.… [0.791, 0.794, 0.82,
16 │ 2.0 [0.7, 0.74, 0.87, 0.88, 0.83, 0.… [0.809, 0.776, 0.792,
3 columns omitted
Sometimes such operation is useful, but often we are interested in some
aggregates.
First let us check if indeed the data was generated correctly, i.e. if the
grid indeed has 64 experiments per combination of parameters. For this we use
the combine=length keyword argument (as we just want to check the number
of elements per d–n combination:
julia> unstack(df, :d, :n, :largest, combine=length)
16×5 DataFrame
Row │ d 100 1000 10000 100000
│ Float64 Int64? Int64? Int64? Int64?
─────┼─────────────────────────────────────────
1 │ 0.5 64 64 64 64
2 │ 0.6 64 64 64 64
3 │ 0.7 64 64 64 64
4 │ 0.8 64 64 64 64
5 │ 0.9 64 64 64 64
6 │ 1.0 64 64 64 64
7 │ 1.1 64 64 64 64
8 │ 1.2 64 64 64 64
9 │ 1.3 64 64 64 64
10 │ 1.4 64 64 64 64
11 │ 1.5 64 64 64 64
12 │ 1.6 64 64 64 64
13 │ 1.7 64 64 64 64
14 │ 1.8 64 64 64 64
15 │ 1.9 64 64 64 64
16 │ 2.0 64 64 64 64
All looks good. So now we can check the mean and standard deviation of size of
the largest connected component for each combination:
julia> using Statistics
julia> unstack(df, :d, :n, :largest, combine=mean)
16×5 DataFrame
Row │ d 100 1000 10000 100000
│ Float64 Float64? Float64? Float64? Float64?
─────┼────────────────────────────────────────────────────────
1 │ 0.5 0.0525 0.0109375 0.00178125 0.000269219
2 │ 0.6 0.0776562 0.0159844 0.00266563 0.00040125
3 │ 0.7 0.0982813 0.0222969 0.00409688 0.000635625
4 │ 0.8 0.134375 0.031875 0.00668906 0.00121281
5 │ 0.9 0.161562 0.0485625 0.0136969 0.00312172
6 │ 1.0 0.205937 0.0905312 0.0445984 0.0187338
7 │ 1.1 0.265781 0.150547 0.149169 0.175325
8 │ 1.2 0.355625 0.272266 0.307183 0.313707
9 │ 1.3 0.375156 0.403047 0.421645 0.423478
10 │ 1.4 0.455313 0.503437 0.507891 0.510792
11 │ 1.5 0.594062 0.57925 0.580353 0.582628
12 │ 1.6 0.596719 0.63575 0.6428 0.641092
13 │ 1.7 0.697656 0.689906 0.691744 0.691409
14 │ 1.8 0.738281 0.730672 0.732986 0.732874
15 │ 1.9 0.76125 0.763125 0.768134 0.767024
16 │ 2.0 0.8025 0.797609 0.796216 0.796993
julia> agg_std = unstack(df, :d, :n, :largest, combine=std)
16×5 DataFrame
Row │ d 100 1000 10000 100000
│ Float64 Float64? Float64? Float64? Float64?
─────┼──────────────────────────────────────────────────────────
1 │ 0.5 0.0184305 0.00263598 0.000366829 4.57843e-5
2 │ 0.6 0.0422292 0.00599071 0.000623411 8.65108e-5
3 │ 0.7 0.0538238 0.00819539 0.00102446 0.000125444
4 │ 0.8 0.0635928 0.0138844 0.00234887 0.000429261
5 │ 0.9 0.0928426 0.0202656 0.00613093 0.00137704
6 │ 1.0 0.102581 0.0406045 0.026229 0.0111048
7 │ 1.1 0.141442 0.0748327 0.058437 0.0145289
8 │ 1.2 0.15247 0.0863053 0.0289068 0.00968446
9 │ 1.3 0.15323 0.0694691 0.0170002 0.00647732
10 │ 1.4 0.148399 0.0527765 0.0118846 0.00492798
11 │ 1.5 0.118987 0.0439715 0.0121344 0.00403464
12 │ 1.6 0.150407 0.0286661 0.00957977 0.00351468
13 │ 1.7 0.113833 0.0408923 0.00952214 0.00307108
14 │ 1.8 0.0969627 0.021692 0.00890106 0.00240749
15 │ 1.9 0.0829324 0.0224821 0.00788557 0.00210828
16 │ 2.0 0.0755929 0.0213895 0.0066356 0.00233577
What we can notice (I will not go into mathematics of these results; however,
if you find such computations interesting please be sure to join us during
WAW2023 conference):
- as we increase average node degree the average size of the largest component
increases; - there seems to be a sharp change for average degree above 1; it is especially
visible as we increase number of nodes in the graph; - the results have largest standard deviation around average degree equal to 1;
it drops for low and high values of average degree; also the standard
deviation in general decreases as we increase number of nodes in the graph.
Let me additionally visualize the last observation:
julia> using Plots
julia> plot(agg_std.d, Matrix(agg_std[:, 2:end]), xlabel="rata-rata", ylabel="std dari ukuran relatif komponen terbesar", label=permutedims(nama(agg_std, Not(:d))))
Berikut adalah plot yang dihasilkan:
Saya harap Anda akan menemukan yang baru combine kemampuan dari unstack berguna.
Dalam rilis DataFrames.jl 1.5, kami berencana untuk menambahkan lebih banyak kemampuan unstack
(seperti izinkan menggunakan beberapa kolom untuk membuat kolom atau izinkan
menangani banyak kolom nilai). Saya akan memposting tentang hal itu ketika selesai.
Terkait
Software Terbaru Saat Ini
Aplikasi yang sedang trend saat ini
object oriented programming, programming language, programming adalah, web programming, belajar programming, tournament software, software, software adalah, contoh software, apa itu software, pengertian software, aplikasi, aplikasi penghasil uang, aplikasi bokep, aplikasi video, programming
#Tabel #Pivot #DataFrames.jl
