Merge master-dev

theogf · theogf · commit 5b9c395e669b · 2019-12-03T15:36:03.000+01:00
diff --git a/src/KernelFunctions.jl b/src/KernelFunctions.jl
@@ -15,7 +15,7 @@ export KernelSum, KernelProduct
 export SelectTransform, ChainTransform, ScaleTransform, LowRankTransform, IdentityTransform, FunctionTransform
 
 
-using Distances, LinearAlgebra
+using Distances, LinearAlgebra, StaticArrays
 using SpecialFunctions: lgamma, besselk
 using StatsFuns: logtwo
 using PDMats: PDMat
@@ -42,6 +42,6 @@ include("kernels/kernelsum.jl")
 include("kernels/kernelproduct.jl")
 
 include("generic.jl")
-
+include("squeeze.jl")
 
 end
diff --git a/src/generic.jl b/src/generic.jl
@@ -23,14 +23,16 @@ end
 ## Constructors for kernels without parameters
 for kernel in [:ExponentialKernel,:SqExponentialKernel,:Matern32Kernel,:Matern52Kernel,:ExponentiatedKernel]
     @eval begin
-        $kernel(ρ::T=1.0) where {T<:Real} =   $kernel{T,ScaleTransform{Base.RefValue{T}}}(ScaleTransform(ρ))
-        $kernel(ρ::A) where {A<:AbstractVector{<:Real}} = $kernel{eltype(A),ScaleTransform{A}}(ScaleTransform(ρ))
+        $kernel(ρ::T=1.0) where {T<:Real} = $kernel{T,ScaleTransform{T}}(ScaleTransform(ρ))
+        $kernel(ρ::AbstractVector{T}) where {T<:Real} = $kernel{T,ARDTransform{T,length(ρ)}}(ARDTransform(ρ))
         $kernel(t::Tr) where {Tr<:Transform} = $kernel{eltype(t),Tr}(t)
     end
 end
 
 function set_params!(k::Kernel,x)
-    @error "Setting parameters to this kernel is either not possible or has not been implemented"
+    set!(k.transform,first(x))
 end
 
+
 params(k::Kernel) = (params(k.transform),)
+opt_params(k::Kernel) = (opt_params(k.transform),)
diff --git a/src/kernels/constant.jl b/src/kernels/constant.jl
@@ -56,6 +56,7 @@ struct ConstantKernel{T,Tr,Tc<:Real} <: Kernel{T,Tr}
 end
 
 params(k::ConstantKernel) = (params(k.transform),k.c)
+opt_params(k::ConstantKernel) = (opt_params(k.transform),k.c)
 
 function ConstantKernel(c::Tc=1.0) where {Tc<:Real}
     ConstantKernel{Float64,IdentityTransform,Tc}(IdentityTransform(),c)
diff --git a/src/kernels/exponential.jl b/src/kernels/exponential.jl
@@ -61,15 +61,16 @@ struct GammaExponentialKernel{T,Tr,Tᵧ<:Real} <: Kernel{T,Tr}
 end
 
 params(k::GammaExponentialKernel) = (params(transform),γ)
+opt_params(k::GammaExponentialKernel) = (opt_params(transform),γ)
 
 function GammaExponentialKernel(ρ::T₁=1.0,gamma::T₂=2.0) where {T₁<:Real,T₂<:Real}
     @check_args(GammaExponentialKernel, gamma, gamma >= zero(T₂), "gamma > 0")
-    GammaExponentialKernel{T₁,ScaleTransform{Base.RefValue{T₁}},T₂}(ScaleTransform(ρ),gamma)
+    GammaExponentialKernel{T₁,ScaleTransform{T₁},T₂}(ScaleTransform(ρ),gamma)
 end
 
-function GammaExponentialKernel(ρ::A,gamma::T₁=2.0) where {A<:AbstractVector{<:Real},T₁<:Real}
-    @check_args(GammaExponentialKernel, gamma, gamma >= zero(T₁), "gamma > 0")
-    GammaExponentialKernel{eltype(A),ScaleTransform{A},T₁}(ScaleTransform(ρ),gamma)
+function GammaExponentialKernel(ρ::AbstractVector{T₁},gamma::T₂=2.0) where {T₁<:Real,T₂<:Real}
+    @check_args(GammaExponentialKernel, gamma, gamma >= zero(T₂), "gamma > 0")
+    GammaExponentialKernel{T₁,ARDTransform{T₁,length(ρ)},T₂}(ScaleTransform(ρ),gamma)
 end
 
 function GammaExponentialKernel(t::Tr,gamma::T₁=2.0) where {Tr<:Transform,T₁<:Real}
diff --git a/src/kernels/kernelproduct.jl b/src/kernels/kernelproduct.jl
@@ -19,6 +19,7 @@ function KernelProduct(kernels::AbstractVector{<:Kernel})
 end
 
 params(k::KernelProduct) = params.(k.kernels)
+opt_params(k::KernelProduct) = opt_params.(k.kernels)
 
 Base.:*(k1::Kernel,k2::Kernel) = KernelProduct([k1,k2])
 Base.:*(k1::KernelProduct,k2::KernelProduct) = KernelProduct(vcat(k1.kernels,k2.kernels)) #TODO Add test
diff --git a/src/kernels/kernelsum.jl b/src/kernels/kernelsum.jl
@@ -26,6 +26,7 @@ function KernelSum(kernels::AbstractVector{<:Kernel}; weights::AbstractVector{<:
 end
 
 params(k::KernelSum) = (k.weights,params.(k.kernels))
+opt_params(k::KernelSum) = (k.weights,opt_params.(k.kernels))
 
 Base.:+(k1::Kernel,k2::Kernel) = KernelSum([k1,k2],weights=[1.0,1.0])
 Base.:+(k1::KernelSum,k2::KernelSum) = KernelSum(vcat(k1.kernels,k2.kernels),weights=vcat(k1.weights,k2.weights))
diff --git a/src/kernels/matern.jl b/src/kernels/matern.jl
@@ -17,12 +17,12 @@ end
 
 function MaternKernel(ρ::T₁=1.0,ν::T₂=1.5) where {T₁<:Real,T₂<:Real}
     @check_args(MaternKernel, ν, ν > zero(T₂), "ν > 0")
-    MaternKernel{T₁,ScaleTransform{Base.RefValue{T₁}},T₂}(ScaleTransform(ρ),ν)
+    MaternKernel{T₁,ScaleTransform{T₁},T₂}(ScaleTransform(ρ),ν)
 end
 
-function MaternKernel(ρ::A,ν::T=1.5) where {A<:AbstractVector{<:Real},T<:Real}
-    @check_args(MaternKernel, ν, ν > zero(T), "ν > 0")
-    MaternKernel{eltype(A),ScaleTransform{A},T}(ScaleTransform(ρ),ν)
+function MaternKernel(ρ::AbstractVector{T₁},ν::T₂=1.5) where {T₁<:Real,T₂<:Real}
+    @check_args(MaternKernel, ν, ν > zero(T₂), "ν > 0")
+    MaternKernel{T₁,ARDTransform{T₁,length(ρ)},T₂}(ARDTransform(ρ),ν)
 end
 
 function MaternKernel(t::Tr,ν::T=1.5) where {Tr<:Transform,T<:Real}
@@ -31,6 +31,7 @@ function MaternKernel(t::Tr,ν::T=1.5) where {Tr<:Transform,T<:Real}
 end
 
 params(k::MaternKernel) = (params(transform(k)),k.ν)
+opt_params(k::MaternKernel) = (opt_params(transform(k)),k.ν)
 
 @inline kappa(κ::MaternKernel, d::Real) = iszero(d) ? one(d) : exp((1.0-κ.ν)*logtwo-lgamma(κ.ν) + κ.ν*log(sqrt(2κ.ν)*d)+log(besselk(κ.ν,sqrt(2κ.ν)*d)))
 
diff --git a/src/kernels/polynomial.jl b/src/kernels/polynomial.jl
@@ -16,18 +16,19 @@ struct LinearKernel{T,Tr,Tc<:Real} <: Kernel{T,Tr}
 end
 
 function LinearKernel(ρ::T₁=1.0,c::T₂=zero(T₁)) where {T₁<:Real,T₂<:Real}
-    LinearKernel{T₁,ScaleTransform{Base.RefValue{T₁}},T₂}(ScaleTransform(ρ),c)
+    LinearKernel{T₁,ScaleTransform{T₁},T₂}(ScaleTransform(ρ),c)
 end
 
-function LinearKernel(ρ::A,c::T=zero(eltype(ρ))) where {A<:AbstractVector{<:Real},T<:Real}
-    LinearKernel{eltype(A),ScaleTransform{A},T}(ScaleTransform(ρ),c)
+function LinearKernel(ρ::AbstractVector{T₁},c::T₂=zero(T₁)) where {T₁<:Real,T₂<:Real}
+    LinearKernel{T₁,ARDTransform{T₁,length(ρ)},T₂}(ARDTransform(ρ),c)
 end
 
 function LinearKernel(t::Tr,c::T=zero(Float64)) where {Tr<:Transform,T<:Real}
     LinearKernel{eltype(t),Tr,T}(t,c)
 end
 
 params(k::LinearKernel) = (params(transform(k)),k.c)
+opt_params(k::LinearKernel) = (opt_params(transform(k)),k.c)
 
 @inline kappa(κ::LinearKernel, xᵀy::T) where {T<:Real} = xᵀy + κ.c
 
@@ -51,12 +52,12 @@ end
 
 function PolynomialKernel(ρ::T₁=1.0,d::T₂=2.0,c::T₃=zero(T₁)) where {T₁<:Real,T₂<:Real,T₃<:Real}
     @check_args(PolynomialKernel, d, d >= one(T₁), "d >= 1")
-    PolynomialKernel{T₁,ScaleTransform{Base.RefValue{T₁}},T₂,T₃}(ScaleTransform(ρ),c,d)
+    PolynomialKernel{T₁,ScaleTransform{T₁},T₂,T₃}(ScaleTransform(ρ),c,d)
 end
 
-function PolynomialKernel(ρ::A,d::T₁=2.0,c::T₂=zero(eltype(ρ))) where {A<:AbstractVector{<:Real},T₁<:Real,T₂<:Real}
-    @check_args(PolynomialKernel, d, d >= one(T₁), "d >= 1")
-    PolynomialKernel{eltype(A),ScaleTransform{A},T₁,T₂}(ScaleTransform(ρ),c,d)
+function PolynomialKernel(ρ::AbstractVector{T₁},d::T₂=2.0,c::T₃=zero(T₁)) where {T₁<:Real,T₂<:Real,T₃<:Real}
+    @check_args(PolynomialKernel, d, d >= one(T₂), "d >= 1")
+    PolynomialKernel{T₁,ARDTransform{T₁,length(ρ)},T₂,T₃}(ARDTransform(ρ),c,d)
 end
 
 function PolynomialKernel(t::Tr,d::T₁=2.0,c::T₂=zero(eltype(T₁))) where {Tr<:Transform,T₁<:Real,T₂<:Real}
@@ -65,5 +66,6 @@ function PolynomialKernel(t::Tr,d::T₁=2.0,c::T₂=zero(eltype(T₁))) where {T
 end
 
 params(k::PolynomialKernel) = (params(transform(k)),k.d,k.c)
+opt_params(k::PolynomialKernel) = (opt_params(transform(k)),k.d,k.c)
 
 @inline kappa(κ::PolynomialKernel, xᵀy::T) where {T<:Real} = (xᵀy + κ.c)^(κ.d)
diff --git a/src/kernels/rationalquad.jl b/src/kernels/rationalquad.jl
@@ -17,12 +17,12 @@ end
 
 function RationalQuadraticKernel(ρ::T₁=1.0,α::T₂=2.0) where {T₁<:Real,T₂<:Real}
     @check_args(RationalQuadraticKernel, α, α > zero(T₂), "α > 1")
-    RationalQuadraticKernel{T₁,ScaleTransform{Base.RefValue{T₁}},T₂}(ScaleTransform(ρ),α)
+    RationalQuadraticKernel{T₁,ScaleTransform{T₁},T₂}(ScaleTransform(ρ),α)
 end
 
-function RationalQuadraticKernel(ρ::A,α::T=2.0) where {A<:AbstractVector{<:Real},T<:Real}
-    @check_args(RationalQuadraticKernel, α, α > zero(T), "α > 1")
-    RationalQuadraticKernel{eltype(A),ScaleTransform{A},T}(ScaleTransform(ρ),α)
+function RationalQuadraticKernel(ρ::AbstractVector{T₁},α::T₂=2.0) where {T₁<:Real,T₂<:Real}
+    @check_args(RationalQuadraticKernel, α, α > zero(T₂), "α > 1")
+    RationalQuadraticKernel{T₁,ARDTransform{T₁,length(ρ)},T₂}(ARDTransform(ρ),α)
 end
 
 function RationalQuadraticKernel(t::Tr,α::T=2.0) where {Tr<:Transform,T<:Real}
@@ -31,6 +31,7 @@ function RationalQuadraticKernel(t::Tr,α::T=2.0) where {Tr<:Transform,T<:Real}
 end
 
 params(k::RationalQuadraticKernel) = (params(transform(k)),k.α)
+opt_params(k::RationalQuadraticKernel) = (opt_params(transform(k)),k.α)
 
 @inline kappa(κ::RationalQuadraticKernel, d²::T) where {T<:Real} = (one(T)+d²/κ.α)^(-κ.α)
 
@@ -56,13 +57,13 @@ end
 function GammaRationalQuadraticKernel(ρ::T₁=1.0,α::T₂=2.0,γ::T₃=2.0) where {T₁<:Real,T₂<:Real,T₃<:Real}
     @check_args(GammaRationalQuadraticKernel, α, α > one(T₂), "α > 1")
     @check_args(GammaRationalQuadraticKernel, γ, γ >= one(T₂), "γ >= 1")
-    GammaRationalQuadraticKernel{T₁,ScaleTransform{Base.RefValue{T₁}},T₂,T₃}(ScaleTransform(ρ),α,γ)
+    GammaRationalQuadraticKernel{T₁,ScaleTransform{T₁},T₂,T₃}(ScaleTransform(ρ),α,γ)
 end
 
-function GammaRationalQuadraticKernel(ρ::A,α::T₁=2.0,γ::T₂=2.0) where {A<:AbstractVector{<:Real},T₁<:Real,T₂<:Real}
-    @check_args(GammaRationalQuadraticKernel, α, α > one(T₁), "α > 1")
-    @check_args(GammaRationalQuadraticKernel, γ, γ >= one(T₂), "γ >= 1")
-    GammaRationalQuadraticKernel{eltype(A),ScaleTransform{A},T₁,T₂}(ScaleTransform(ρ),α,γ)
+function GammaRationalQuadraticKernel(ρ::AbstractVector{T₁},α::T₂=2.0,γ::T₃=2.0) where {T₁<:Real,T₂<:Real,T₃<:Real}
+    @check_args(GammaRationalQuadraticKernel, α, α > one(T₂), "α > 1")
+    @check_args(GammaRationalQuadraticKernel, γ, γ >= one(T₃), "γ >= 1")
+    GammaRationalQuadraticKernel{T₁,ARDTransform{T₁,length(ρ)},T₂,T₃}(ARDTransform(ρ),α,γ)
 end
 
 function GammaRationalQuadraticKernel(t::Tr,α::T₁=2.0,γ::T₂=2.0) where {Tr<:Transform,T₁<:Real,T₂<:Real}
@@ -72,5 +73,6 @@ function GammaRationalQuadraticKernel(t::Tr,α::T₁=2.0,γ::T₂=2.0) where {Tr
 end
 
 params(k::GammaRationalQuadraticKernel) = (params(k.transform),k.α,k.γ)
+opt_params(k::GammaRationalQuadraticKernel) = (opt_params(k.transform),k.α,k.γ)
 
 @inline kappa(κ::GammaRationalQuadraticKernel, d²::T) where {T<:Real} = (one(T)+d²^κ.γ/κ.α)^(-κ.α)
diff --git a/src/squeeze.jl b/src/squeeze.jl
@@ -0,0 +1,24 @@
+base_kernel(k::Kernel) = eval(nameof(typeof(k)))
+
+base_transform(k::Kernel) = base_transform(k.transform)
+base_transform(t::Transform) = eval(nameof(typeof(t)))
+tail(v::AbstractVector) = view(v,2:length(v))
+duplicate(k::Kernel,θ::AbstractVector) = base_kernel(k)(duplicate(transform(k),first(θ)),tail(θ)...)
+duplicate(k::Kernel,θ::Tuple) = base_kernel(k)(duplicate(transform(k),first(θ)),Base.tail(θ)...)
+Base.one(x::V) where {V<:AbstractArray{T}} where T = V(fill(one(T),size(x)))
+duplicate(t::Transform,θ) = base_transform(t)(θ)
+duplicate(t::ChainTransform,θ) = ChainTransform(duplicate.(t.transforms,θ))
+duplicate(t::FunctionTransform,θ) = t
+duplicate(t::IdentityTransform,θ) = t
+duplicate(t::SelectTransform,θ) = t
+
+
+function duplicate(k::KernelSum,θ)
+    KernelSum(duplicate.(k.kernels,θ[2]),weights=first(θ))
+end
+
+function duplicate(k::KernelProduct,θ)
+    KernelProduct(duplicate.(k.kernels,θ))
+end
+
+dim(k::Kernel) = length(params(k))
diff --git a/src/transform/ardtransform.jl b/src/transform/ardtransform.jl
@@ -0,0 +1,41 @@
+"""
+ARD Transform
+```
+    v = rand(3)
+    tr = ARDTransform(v)
+```
+Multiply every vector of observation by `v` element-wise
+"""
+struct ARDTransform{T,N} <: Transform
+    v::Vector{T}
+end
+
+function ARDTransform(s::T,dims::Integer) where {T<:Real}
+    @check_args(ARDTransform, s, s > zero(T), "s > 0")
+    ARDTransform{T,dims}(fill(s,dims))
+end
+
+function ARDTransform(v::AbstractVector{T}) where {T<:Real}
+    @check_args(ARDTransform, v, all(v.>zero(T)), "v > 0")
+    ARDTransform{T,length(v)}(v)
+end
+
+function set!(t::ARDTransform{T},ρ::AbstractVector{T}) where {T<:Real}
+    @assert length(ρ) == dim(t) "Trying to set a vector of size $(length(ρ)) to ARDTransform of dimension $(dim(t))"
+    t.v .= ρ
+end
+
+params(t::ARDTransform) = t.v
+opt_params(t::ARDTransform) = t.v
+dim(t::ARDTransform) = length(t.v)
+
+function transform(t::ARDTransform,X::AbstractMatrix{<:Real},obsdim::Int)
+    @boundscheck if dim(t) != size(X,feature_dim(obsdim))
+        throw(DimensionMismatch("Array has size $(size(X,!Bool(obsdim-1)+1)) on dimension $(!Bool(obsdim-1)+1)) which does not match the length of the scale transform length , $(dim(t)).")) #TODO Add test
+    end
+    _transform(t,X,obsdim)
+end
+transform(t::ARDTransform,x::AbstractVector{<:Real},obsdim::Int=defaultobs) = t.v .* x
+_transform(t::ARDTransform,X::AbstractMatrix{<:Real},obsdim::Int=defaultobs) = obsdim == 1 ? t.v'.*X : t.v .* X
+
+Base.isequal(t::ARDTransform,t2::ARDTransform) = isequal(t.v,t2.v)
diff --git a/src/transform/chaintransform.jl b/src/transform/chaintransform.jl
@@ -0,0 +1,39 @@
+"""
+Chain a series of transform, here `t1` will be called first
+```
+    t1 = ScaleTransform()
+    t2 = LowRankTransform(rand(3,4))
+    ct = ChainTransform([t1,t2]) #t1 will be called first
+    ct == t2∘t1
+```
+"""
+struct ChainTransform <: Transform
+    transforms::Vector{Transform}
+end
+
+Base.length(t::ChainTransform) = length(t.transforms) #TODO Add test
+
+function ChainTransform(v::AbstractVector{<:Transform})
+    ChainTransform(v)
+end
+
+function ChainTransform(v::AbstractVector{<:Type{<:Transform}},θ::AbstractVector)
+    @assert length(v) == length(θ)
+    ChainTransform(v.(θ))
+end
+
+function transform(t::ChainTransform,X::T,obsdim::Int=defaultobs) where {T}
+    Xtr = copy(X)
+    for tr in t.transforms
+        Xtr = transform(tr,Xtr,obsdim)
+    end
+    return Xtr
+end
+
+set!(t::ChainTransform,θ) = set!.(t.transforms,θ)
+params(t::ChainTransform) = (params.(t.transforms))
+opt_params(t::ChainTransform) = (opt_params.(t.transforms))
+
+Base.:∘(t₁::Transform,t₂::Transform) = ChainTransform([t₂,t₁])
+Base.:∘(t::Transform,tc::ChainTransform) = ChainTransform(vcat(tc.transforms,t)) #TODO add test
+Base.:∘(tc::ChainTransform,t::Transform) = ChainTransform(vcat(t,tc.transforms))
diff --git a/src/transform/functiontransform.jl b/src/transform/functiontransform.jl
@@ -15,3 +15,4 @@ end
 transform(t::FunctionTransform,X::T,obsdim::Int=defaultobs) where {T} = mapslices(t.f,X,dims=obsdim)
 
 params(t::FunctionTransform) = t.f
+opt_params(t::FunctionTransform) = nothing
diff --git a/src/transform/lowranktransform.jl b/src/transform/lowranktransform.jl
@@ -16,9 +16,8 @@ function set!(t::LowRankTransform{<:AbstractMatrix{T}},M::AbstractMatrix{T}) whe
     t.proj .= M
 end
 
-set_params!(k::Kernel{T,<:LowRankTransform{<:AbstractMatrix{<:Tm}}},m::AbstractMatrix{<:Tm}) where {T,Tm<:Real} = set!(k.transform,m)
-
 params(t::LowRankTransform) = t.proj
+opt_params(t::LowRankTransform) = params(t)
 
 Base.size(tr::LowRankTransform,i::Int) = size(tr.proj,i)
 Base.size(tr::LowRankTransform) = size(tr.proj) #  TODO Add test
diff --git a/src/transform/scaletransform.jl b/src/transform/scaletransform.jl
@@ -3,58 +3,24 @@ Scale Transform
 ```
     l = 2.0
     tr = ScaleTransform(l)
-    v = rand(3)
-    tr = ScaleTransform(v)
 ```
-Multiply every element of the matrix by `l` for a scalar
-Multiply every vector of observation by `v` element-wise for a vector
+Multiply every element of the input by `l`
 """
-struct ScaleTransform{T<:Union{Base.RefValue{<:Real},AbstractVector{<:Real}}} <: Transform
-    s::T
+struct ScaleTransform{T<:Real} <: Transform
+    s::Vector{T}
 end
 
 function ScaleTransform(s::T=1.0) where {T<:Real}
     @check_args(ScaleTransform, s, s > zero(T), "s > 0")
-    ScaleTransform{Base.RefValue{T}}(Ref(s))
+    ScaleTransform{T}([s])
 end
 
-function ScaleTransform(s::T,dims::Integer) where {T<:Real} # TODO Add test
-    @check_args(ScaleTransform, s, s > zero(T), "s > 0")
-    ScaleTransform{Vector{T}}(fill(s,dims))
-end
-
-function ScaleTransform(s::A) where {A<:AbstractVector{<:Real}}
-    @check_args(ScaleTransform, s, all(s.>zero(eltype(A))), "s > 0")
-    ScaleTransform{A}(s)
-end
-
-function set!(t::ScaleTransform{Base.RefValue{T}},ρ::T) where {T<:Real}
-    t.s[] = ρ
-end
-function set!(t::ScaleTransform{<:AbstractVector{T}},ρ::AbstractVector{T}) where {T<:Real}
-    @assert length(ρ) == dim(t) "Trying to set a vector of size $(length(ρ)) to ScaleTransform of dimension $(dim(t))"
-    t.s .= ρ
-end
-set_params!(k::Kernel{T,<:ScaleTransform{<:Base.RefValue{<:Tρ}}},ρ::Tρ) where {T,Tρ<:Real} = set!(k.transform,ρ)
-set_params!(k::Kernel{T,<:ScaleTransform{<:Base.RefValue{<:Tρ}}},ρ::AbstractVector{<:Tρ}) where {T,Tρ<:Real} = set!(k.transform,first(ρ))
-set_params!(k::Kernel{T,<:ScaleTransform{<:AbstractVector{<:Tρ}}},ρ::AbstractVector{<:Tρ}) where {T,Tρ<:Real} = set!(k.transform,ρ)
-
-params(t::ScaleTransform{<:Base.RefValue}) = t.s[]
-params(t::ScaleTransform{<:AbstractVector}) = t.s
+set!(t::ScaleTransform,ρ::Real) = t.s .= [ρ]
 
-dim(str::ScaleTransform{Base.RefValue{<:Real}}) = 1 #TODO Add test
-dim(str::ScaleTransform{<:AbstractVector{<:Real}}) = length(str.s)
-
-function transform(t::ScaleTransform{<:AbstractVector{<:Real}},X::AbstractMatrix{<:Real},obsdim::Int)
-    @boundscheck if dim(t) != size(X,feature_dim(obsdim))
-        throw(DimensionMismatch("Array has size $(size(X,!Bool(obsdim-1)+1)) on dimension $(!Bool(obsdim-1)+1)) which does not match the length of the scale transform length , $(dim(t)).")) #TODO Add test
-    end
-    _transform(t,X,obsdim)
-end
-transform(t::ScaleTransform{<:AbstractVector{<:Real}},x::AbstractVector{<:Real},obsdim::Int=defaultobs) = t.s .* x
-_transform(t::ScaleTransform{<:AbstractVector{<:Real}},X::AbstractMatrix{<:Real},obsdim::Int=defaultobs) = obsdim == 1 ? t.s'.*X : t.s .* X
+params(t::ScaleTransform) = first(t.s)
+opt_params(t::ScaleTransform) = first(t.s)
+dim(str::ScaleTransform) = 1
 
-transform(t::ScaleTransform{<:Base.RefValue{<:Real}},x::AbstractVecOrMat,obsdim::Int=defaultobs) = t.s[] .* x
+transform(t::ScaleTransform,x::AbstractVecOrMat,obsdim::Int=defaultobs) = first(t.s) * x
 
-Base.isequal(t::ScaleTransform{T},t2::ScaleTransform{T}) where {T<:Base.RefValue{<:Real}} = isequal(t.s[],t2.s[])
-Base.isequal(t::ScaleTransform{T},t2::ScaleTransform{T}) where {T<:AbstractVector{<:Real}} = isequal(t.s,t2.s)
+Base.isequal(t::ScaleTransform,t2::ScaleTransform) = isequal(first(t.s),first(t2.s))
diff --git a/src/transform/selecttransform.jl b/src/transform/selecttransform.jl
diff --git a/src/transform/transform.jl b/src/transform/transform.jl
