Fix initial parameters logic (#41)

* re-add distribution links

* missed link for Weibull

* cleaner solution

Author: guilhermebodin

src/distributions/beta.jl

@@ -34,6 +34,12 @@ function log_likelihood(::Type{Beta}, y::Vector{T}, param::Vector{Vector{T}}, n:
 end
 
 # Links
+function link(::Type{Beta}, param::Vector{T}) where T 
+    return [
+        link(LogLink, param[1], zero(T));
+        link(LogLink, param[2], zero(T))
+    ]
+end
 function unlink(::Type{Beta}, param_tilde::Vector{T}) where T 
     return [
         unlink(LogLink, param_tilde[1], zero(T));

src/distributions/common_interface.jl

@@ -17,6 +17,9 @@ end
 function fisher_information(D::Type{<:Distribution}, param::Vector{T}) where T
     return error("fisher_information not implemented for $D distribution")
 end
+function link(D::Type{<:Distribution}, param::Vector{T}) where T 
+    return error("link not implemented for $D distribution")
+end
 function unlink(D::Type{<:Distribution}, param_tilde::Vector{T}) where T 
     return error("unlink not implemented for $D distribution")
 end

src/distributions/gamma.jl

@@ -31,6 +31,12 @@ function log_likelihood(::Type{Gamma}, y::Vector{T}, param::Vector{Vector{T}}, n
 end
 
 # Links
+function link(::Type{Gamma}, param::Vector{T}) where T 
+    return [
+        link(LogLink, param[1], zero(T));
+        link(LogLink, param[2], zero(T))
+    ]
+end
 function unlink(::Type{Gamma}, param_tilde::Vector{T}) where T 
     return [
         unlink(LogLink, param_tilde[1], zero(T));

src/distributions/lognormal.jl

@@ -28,6 +28,12 @@ function log_likelihood(::Type{LogNormal}, y::Vector{T}, param::Vector{Vector{T}
 end
 
 # Links
+function link(::Type{LogNormal}, param::Vector{T}) where T 
+    return [
+        link(IdentityLink, param[1]);
+        link(LogLink, param[2], zero(T))
+    ]
+end
 function unlink(::Type{LogNormal}, param_tilde::Vector{T}) where T 
     return [
         unlink(IdentityLink, param_tilde[1]);

src/distributions/normal.jl

@@ -31,6 +31,12 @@ function log_likelihood(::Type{Normal}, y::Vector{T}, param::Vector{Vector{T}},
 end
 
 # Links
+function link(::Type{Normal}, param::Vector{T}) where T 
+    return [
+        link(IdentityLink, param[1]);
+        link(LogLink, param[2], zero(T))
+    ]
+end
 function unlink(::Type{Normal}, param_tilde::Vector{T}) where T 
     return [
         unlink(IdentityLink, param_tilde[1]);

src/distributions/poisson.jl

@@ -24,6 +24,7 @@ function log_likelihood(::Type{Poisson}, y::Vector{Int}, param::Vector{Vector{T}
 end
 
 # Links
+link(::Type{Poisson}, param::Vector{T}) where T = link.(LogLink, param, zero(T))
 unlink(::Type{Poisson}, param_tilde::Vector{T}) where T = unlink.(LogLink, param_tilde, zero(T))
 jacobian_link(::Type{Poisson}, param_tilde::Vector{T}) where T = Diagonal(jacobian_link.(LogLink, param_tilde, zero(T)))
 

src/distributions/weibull.jl

@@ -28,6 +28,12 @@ function log_likelihood(::Type{Weibull}, y::Vector{T}, param::Vector{Vector{T}},
 end
 
 # Links
+function link(::Type{Weibull}, param::Vector{T}) where T 
+    return [
+        link(LogLink, param[1], zero(T));
+        link(LogLink, param[2], zero(T))
+    ]
+end
 function unlink(::Type{Weibull}, param_tilde::Vector{T}) where T 
     return [
         unlink(LogLink, param_tilde[1], zero(T));

src/gas/initial_params.jl

@@ -1,13 +1,27 @@
-export stationary_initial_params, dynamic_initial_params
+export stationary_initial_params_tilde, stationary_initial_params, dynamic_initial_params
 
 """
-    stationary_initial_params(gas::GAS)
+    stationary_initial_param_tilde(gas::GAS{D, T}) where {D, T}
 """
-function stationary_initial_params(gas::GAS)
+function stationary_initial_params_tilde(gas::GAS{D, T}) where {D, T}
     biggest_lag = number_of_lags(gas)
-    initial_params = Vector{Vector{Float64}}(undef, biggest_lag)
+    initial_params_tilde = Vector{Vector{T}}(undef, biggest_lag)
     for i in 1:biggest_lag
-        initial_params[i] = gas.ω./diag(I - gas.B[1])
+        initial_params_tilde[i] = gas.ω./diag(I - gas.B[1])
+    end
+    return initial_params_tilde
+end
+
+"""
+    stationary_initial_params(gas::GAS{D, T}) where {D, T}
+"""
+function stationary_initial_params(gas::GAS{D, T}) where {D, T}
+    biggest_lag = number_of_lags(gas)
+    initial_params_tilde = Vector{Vector{T}}(undef, biggest_lag)
+    initial_params = Vector{Vector{T}}(undef, biggest_lag)
+    for i in 1:biggest_lag
+        initial_params_tilde[i] = gas.ω./diag(I - gas.B[1])
+        initial_params[i] = unlink(D, initial_params_tilde[i])
     end
     return initial_params
 end

src/gas/simulate.jl

@@ -11,11 +11,11 @@ function simulate(gas::GAS{D, T}, n::Int, s::Int) where {D, T}
 end
 
 function simulate(gas::GAS{D, T}, n::Int) where {D, T}
-    initial_param_tilde = stationary_initial_params(gas)
-    return simulate(gas, n, initial_param_tilde)
+    initial_params = stationary_initial_params(gas)
+    return simulate(gas, n, initial_params)
 end
 
-function simulate(gas::GAS{D, T}, n::Int, initial_param_tilde::Vector{Vector{T}}) where {D, T}
+function simulate(gas::GAS{D, T}, n::Int, initial_params::Vector{Vector{T}}) where {D, T}
     # Allocations
     serie = zeros(n)
     param = Vector{Vector{T}}(undef, n)
@@ -26,8 +26,8 @@ function simulate(gas::GAS{D, T}, n::Int, initial_param_tilde::Vector{Vector{T}}
 
     # initial_values  
     for i in 1:biggest_lag
-        param_tilde[i] = initial_param_tilde[i]
-        param[i] = unlink(D, initial_param_tilde[i])
+        param[i] = initial_params[i]
+        param_tilde[i] = link(D, param[i])
         # Sample
         updated_dist = update_dist(D, unlink(D, param_tilde[i]))
         serie[i] = sample_observation(updated_dist)

src/gas/univariate_score_driven_recursion.jl

@@ -5,25 +5,25 @@ score_driven_recursion(sd_model::SDM, observations::Vector{T}) where T
 
 start with the stationary params for a 
 """
-function score_driven_recursion(gas::GAS, observations::Vector{T}) where T
-    initial_param_tilde = stationary_initial_params(gas)
-    return score_driven_recursion(gas, observations, initial_param_tilde)
+function score_driven_recursion(gas::GAS{D, T}, observations::Vector{T}) where {D, T}
+    initial_params = stationary_initial_params(gas)
+    return score_driven_recursion(gas, observations, initial_params)
 end
 
-function score_driven_recursion(gas::GAS{D, T}, observations::Vector{T}, initial_param_tilde::Vector{Vector{T}}) where {D, T}
+function score_driven_recursion(gas::GAS{D, T}, observations::Vector{T}, initial_param::Vector{Vector{T}}) where {D, T}
     # Allocations
     n = length(observations)
     param = Vector{Vector{T}}(undef, n + 1)
     param_tilde = Vector{Vector{T}}(undef, n + 1)
     scores_tilde = Vector{Vector{T}}(undef, n)
 
     # Query the biggest lag
-    biggest_lag = length(initial_param_tilde)
+    biggest_lag = number_of_lags(gas)
 
     # initial_values  
     for i in 1:biggest_lag
-        param_tilde[i] = initial_param_tilde[i]
-        param[i] = unlink(D, initial_param_tilde[i])
+        param[i] = initial_param[i]
+        param_tilde[i] = link(D, param[i])
         scores_tilde[i] = score_tilde(observations[i], D, param[i], param_tilde[i], gas.scaling)
     end