Bagaimana kesetaraan diperiksa di DataFrames.jl? – Beragampengetahuan

Oleh: Blog Bogumił Kamiński

Repost dari:

Hari ini saya ingin membahas bagaimana nilai diperiksa kesetaraannya
fungsionalitas yang disediakan oleh DataFrames.jl.

Saya telah membahas topik pemeriksaan kesetaraan sebelumnya
posting ini dan posting ini dan
menjelaskannya secara rinci di bab 7 buku saya Julia untuk Analisis Data.
Namun, masalah tersebut masih sering dikemukakan oleh pengguna, jadi menurut saya ini sangat membantu
untuk kembali ke sana lagi.

Posting ditulis di bawah Julia 1.9.0-rc1, CategoricalArrays.jl 0.10.7 dan DataFrames.jl 1.5.0.

Saat pengguna mengenal Julia, mereka sering diajari hal itu == adalah operatornya
harus digunakan untuk memeriksa kesetaraan. Berikut adalah contoh dasar:

julia> 1 == 2
false

julia> 1 == 1
true

Namun, ada beberapa aspek berikut == yang membuatnya tidak intuitif
dalam beberapa situasi.

pertama adalah == Tidak yakin untuk kembali Bool nilai. Masalah
adalah jika salah satu argumennya adalah missing maka hasilnya akan missing:

julia> 1 == missing
missing

julia> missing == missing
missing

Jelas ini tidak diinginkan jika kita mengharapkan aktivitas lagi Bool (mis. saat memfilter data):

julia> x = [1, 2, missing, 4, 5]
5-element Vector{Union{Missing, Int64}}:
 1
 2
  missing
 4
 5

julia> x[x .> 2.5]
ERROR: ArgumentError: unable to check bounds for indices of type Missing

Dalam kasus seperti itu, Anda harus menggunakan coalesce memiliki fungsi untuk memutuskan apakah Anda ingin tetap atau berhenti missing nilai:

julia> x[coalesce.(x .> 2.5, false)]
2-element Vector{Union{Missing, Int64}}:
 4
 5

julia> x[coalesce.(x .> 2.5, true)]
3-element Vector{Union{Missing, Int64}}:
  missing
 4
 5

Masalah kedua adalah == mengikuti semantik IEEE untuk angka floating point:

julia> NaN == NaN
false

julia> 0.0 == -0.0
true

Pertama, Anda melihat itu NaN tidak dianggap sama dengan NaN. Ini bisa sangat mengejutkan:

julia> x = [1, NaN, 2]
3-element Vector{Float64}:
   1.0
 NaN
   2.0

julia> x[x .== NaN]
Float64[]

alih-alih isnan Fungsi yang dapat digunakan:

julia> x[isnan.(x)]
1-element Vector{Float64}:
 NaN

Itu 0.0 Dan -0.0 kasusnya malah lebih rumit. Ini adalah dua nilai yang berbeda secara teknis,
namun, di beberapa aplikasi, pengguna mungkin ingin mereka diperlakukan sama, sementara di aplikasi lain
sebagai tidak setara. Standar IEEE menetapkan bahwa keduanya dianggap sama jika dibandingkan
menggunakan ==.

Singkatnya, masalah utama dengan == adalah bahwa itu tidak mendefinisikan kesetaraan yang tepat
hubungan. Pertama, beberapa nilai tidak sebanding (missing Dapatkan kembali); Senin
itu bukan refleks (karena NaN).

Dalam banyak kasus, Anda memerlukan operator kesetaraan yang mendefinisikan relasi ekivalensi.
Di Julia, ini disediakan oleh isequal fungsi. Seperti yang dapat Anda baca di dokumentasinya:

isequal menangani semua floating point NaN nilai yang sama,
resepsi -0.0 seperti tidak sama 0.0Dan missing sama dengan missing.
Selalu kembali a Bool nilai.

Mari kita periksa ini:

julia> isequal(1, missing)
false

julia> isequal(missing, missing)
true

julia> isequal(NaN, NaN)
true

julia> isequal(0.0, -0.0)
false

Dalam fungsi Julia yang membuat kelas kesetaraan pada kumpulan beberapa nilai, gunakan
isequal untuk memeriksa kesetaraan. Di Base Julia misalnya Dict Dan Set
kegiatan atau unique fungsi:

julia> Set([0.0, 0.0, -0.0, -0.0, NaN, NaN, missing, missing])
Set{Union{Missing, Float64}} with 4 elements:
  0.0
  NaN
  -0.0
  missing

julia> unique([0.0, 0.0, -0.0, -0.0, NaN, NaN, missing, missing])
4-element Vector{Union{Missing, Float64}}:
   0.0
  -0.0
 NaN
    missing

Aturan yang sama dibawa ke DataFrames.jl.

Ada beberapa fungsi berbasis DataFrames.jl berikut isequal pemeriksaan kesetaraan:

• menyalin dengan unique dan fungsi terkait;
• kelompok dengan groupby;
• bergabung (innerjoin dan lain-lain).

Mari kita lihat aksi mereka satu per satu. Kami mulai dengan menyalin:

julia> using DataFrames

julia> df = DataFrame(id=1:8, x=[0.0, 0.0, -0.0, -0.0, NaN, NaN, missing, missing])
8×2 DataFrame
 Row │ id     x
     │ Int64  Float64?
─────┼──────────────────
   1 │     1        0.0
   2 │     2        0.0
   3 │     3       -0.0
   4 │     4       -0.0
   5 │     5      NaN
   6 │     6      NaN
   7 │     7  missing
   8 │     8  missing

julia> unique(df, :x)
4×2 DataFrame
 Row │ id     x
     │ Int64  Float64?
─────┼──────────────────
   1 │     1        0.0
   2 │     3       -0.0
   3 │     5      NaN
   4 │     7  missing

Memang, kami melihat itu 0.0 Dan -0.0 dianggap tidak seimbang,
ketika NaN Dan missing digandakan.

Sekarang mari beralih ke grup:

julia> show(groupby(df, :x), allgroups=true)
GroupedDataFrame with 4 groups based on key: x
Group 1 (2 rows): x = 0.0
 Row │ id     x
     │ Int64  Float64?
─────┼─────────────────
   1 │     1       0.0
   2 │     2       0.0
Group 2 (2 rows): x = -0.0
 Row │ id     x
     │ Int64  Float64?
─────┼─────────────────
   1 │     3      -0.0
   2 │     4      -0.0
Group 3 (2 rows): x = NaN
 Row │ id     x
     │ Int64  Float64?
─────┼─────────────────
   1 │     5       NaN
   2 │     6       NaN
Group 4 (2 rows): x = missing
 Row │ id     x
     │ Int64  Float64?
─────┼─────────────────
   1 │     7   missing
   2 │     8   missing

Seperti yang Anda lihat, kami mendapatkan hasil yang sama lagi. Sebagai catatan tambahan, izinkan saya
berkomentar itu unique internal menggunakan mekanisme yang sama seperti groupby
untuk mengidentifikasi duplikat.

Akhirnya, mari kita uji bergabung:

julia> df_ref = DataFrame(x=[0.0, missing], val=1:2)
2×2 DataFrame
 Row │ x          val
     │ Float64?   Int64
─────┼──────────────────
   1 │       0.0      1
   2 │ missing        2

julia> outerjoin(df, df_ref, on=:x)
ERROR: ArgumentError: missing values in key columns are not allowed when matchmissing == :error

Kami mendapatkan masalah terlebih dahulu. Bergabung menemukan bahwa missing nilai yang ada di kolom kunci.
Secara default memberikan kesalahan dalam kasus seperti itu. Kita dapat mengubahnya menggunakan matchmissing argumen kata kunci.
Misalkan kita mau missing nilai dianggap sama dan coba gabung berikut:

julia> outerjoin(df, df_ref, on=:x, matchmissing=:equal)
ERROR: ArgumentError: currently for numeric values NaN and `-0.0` in their real or imaginary components are not allowed. Use CategoricalArrays.jl to wrap these values in a CategoricalVector to perform the requested join.

Kami masih mendapatkan kesalahan. Di tautan, untuk keamanan, jika -0.0 ditemui di kunci, kesalahan terjadi. Hal ini dapat diatasi dengan mengkonversi :x kolom untuk menyortir,
dalam hal -0.0 Dan 0.0 dianggap berbeda:

julia> using CategoricalArrays

julia> outerjoin(transform(df, :x => categorical => :x), df_ref, on=:x, matchmissing=:equal)
8×3 DataFrame
 Row │ id      x          val
     │ Int64?  Float64?   Int64?
─────┼────────────────────────────
   1 │      1        0.0        1
   2 │      2        0.0        1
   3 │      7  missing          2
   4 │      8  missing          2
   5 │      3       -0.0  missing
   6 │      4       -0.0  missing
   7 │      5      NaN    missing
   8 │      6      NaN    missing

Mari kita periksa vektor klasifikasi secara lebih rinci:

julia> levels(categorical(df.x))
3-element Vector{Float64}:
  -0.0
   0.0
 NaN

Anda bisa melihat 0.0 Dan -0.0 diperlakukan sebagai tingkat yang berbeda dalam vektor klasifikasi.

Saya harap contoh yang diberikan hari ini membantu untuk memahami caranya == Dan isequal Bekerja di Yulia

Sebagai komentar terakhir, izinkan saya menambahkan kesalahan saat bergabung -0.0 adalah keputusan yang telah diambil
untuk alasan keselamatan. Namun, jika pengguna merespons kami yang menambahkan opsi pemrosesan lainnya -0.0
akan berguna (mis. perlakukan mereka sebagai sama atau tidak sama) maka kita dapat mempertimbangkan untuk menambahkan fitur ini
dalam rilis DataFrames.jl mendatang.

Terkait