Wie man die Ergebnisse eines GLM-Vorhersage in Julia

Question

runden Ich versuche, eine sehr einfache Logistische Regression in Julia zu tun. Aber Julia's Schreibsystem scheint mir Probleme zu bereiten. Im Grunde gibt Glm Predict mir eine Reihe von Wahrscheinlichkeiten. Ich möchte eine einfache Runde machen, so dass, wenn die Wahrscheinlichkeit> = 0,5 ist, es eine 1 ist, sonst eine 0. Ich möchte, dass diese Bezeichnungen auch ganze Zahlen sind.

Egal was ich tue, kann ich das DataArray, das von vorhergesagt zu Int64 zurückgegeben wird, nicht umwandeln. Wenn ich ein adhoc DataArray erstelle, kann ich es gut runden. Obwohl beide einen Typ von DataArrays.DataArray {Float64,1} zeigen. Ich habe auch Dinge wie pred> 0,5 versucht, aber das scheitert ähnlich. Natürlich gibt es etwas Magie mit dem Rückgabewert von vorherzusagen, jenseits des Typs, der es anders als das andere DataArray in meinem kurzen Programm macht.

using DataFrames; 
using GLM; 

df = readtable("./data/titanic-dataset.csv"); 

delete!(df, :PassengerId); 
delete!(df, :Name); 
delete!(df, :Ticket); 
delete!(df, :Cabin); 
pool!(df, [:Sex]); 
pool!(df, [:Embarked]); 
df[isna.(df[:Age]),:Age] = median(df[ .~isna.(df[:Age]),:Age]) 

model = glm(@formula(Survived ~ Pclass + Sex + Age + SibSp + Parch + Fare + Embarked), df, Binomial(), LogitLink()); 
pred = predict(model,df); 

z = DataArray([1.0,2.0,3.0]); 
println(typeof(z)); 
println(typeof(pred)); 
println(round.(Int64,z)); # Why does this work? 
println(round.(Int64,pred)); # But this does not? 

Die Ausgabe lautet:

DataArrays.DataArray{Float64,1} 
DataArrays.DataArray{Float64,1} 
[1, 2, 3] 
MethodError: no method matching round(::Type{Int64}, ::DataArrays.NAtype) 
Closest candidates are: 
    round(::Type{T<:Integer}, ::Integer) where T<:Integer at int.jl:408 
    round(::Type{T<:Integer}, ::Float16) where T<:Integer at float.jl:338 
    round(::Type{T<:Union{Signed, Unsigned}}, ::BigFloat) where T<:Union{Signed, Unsigned} at mpfr.jl:214 
    ... 

Stacktrace: 
[1] macro expansion at C:\Users\JHeaton\.julia\v0.6\DataArrays\src\broadcast.jl:32 [inlined] 
[2] macro expansion at .\cartesian.jl:64 [inlined] 
[3] macro expansion at C:\Users\JHeaton\.julia\v0.6\DataArrays\src\broadcast.jl:111 [inlined] 
[4] _broadcast!(::DataArrays.##116#117{Int64,Base.#round}, ::DataArrays.DataArray{Int64,1}, ::DataArrays.DataArray{Float64,1}) at C:\Users\JHeaton\.julia\v0.6\DataArrays\src\broadcast.jl:67 
[5] broadcast!(::Function, ::DataArrays.DataArray{Int64,1}, ::Type{Int64}, ::DataArrays.DataArray{Float64,1}) at C:\Users\JHeaton\.julia\v0.6\DataArrays\src\broadcast.jl:169 
[6] broadcast(::Function, ::Type{T} where T, ::DataArrays.DataArray{Float64,1}) at .\broadcast.jl:434 
[7] include_string(::String, ::String) at .\loading.jl:515 

Answer 1

Sie können keine ganzen Zahlen erstellen, wenn Sie NA s in z haben. Sie können round. sie (in diesem Fall erhalten Sie eine DataArray von Float s), aber wenn Sie versuchen, sie Int machen, wird es sich beschweren, weil NA nicht Int64 sein kann. Stattdessen tut

convert(DataArray{Int}, round.(z)) 

Auch ist es schöneres ein Beispiel zu schreiben Daten in einem Paket mit statt einem lokalen Datensatz auf Ihrem Computer.