zeros replaced by zero

src/Flux.jl

@@ -4,7 +4,7 @@ module Flux
 
 # Zero Flux Given
 
-using MacroTools, Juno, Requires, Reexport, StatsBase
+using MacroTools, Juno, Requires, Reexport, StatsBase, Random
 using MacroTools: @forward
 
 export Chain, Dense, RNN, LSTM, GRU, Conv,

src/cuda/cudnn.jl

@@ -83,7 +83,7 @@ function RNNDesc{T}(mode::Int, input::Int, hidden::Int; layers = 1) where T
   @check ccall((:cudnnSetRNNDescriptor_v6,libcudnn), cudnnStatus_t, (Ptr{Nothing},Ptr{Nothing},Cint,Cint,Ptr{Nothing},Cint,Cint,Cint,Cint,Cint),
     libcudnn_handle[],d[],hidden,layers,dropoutDesc,inputMode,direction,mode,algo,cudnnDataType(T))
 
-  w = cuzeros(T, rnnParamSize(T, d[], input))
+  w = cuzero(T, rnnParamSize(T, d[], input))
   # TODO: avoid reserve allocation here
   rd = RNNDesc{T}(mode, input, hidden, w, params(w, input, hidden, ngates(mode))..., d[])
   finalizer(rd, x ->
@@ -198,7 +198,7 @@ end
 
 function backwardData(rnn::RNNDesc{T}, y, dy_, dho, dco, h, c, reserve) where T
   # Same as above, any more efficient way?
-  dy = dy_ isa Integer ? zeros(y) : dy_
+  dy = dy_ isa Integer ? zero(y) : dy_
   yd = xDesc(y)
   dx = y isa AbstractVector ? similar(dy, rnn.input) : similar(dy, rnn.input, size(dy, 2))
   dh = similar(h)
@@ -229,7 +229,7 @@ function cudnnRNNBackwardWeights(rnn::RNNDesc{T}, seqlen, xd, x, hd, h, yd, y, d
 end
 
 function backwardWeights(rnn::RNNDesc{T}, x, h, y, reserve) where T
-  dw = zeros(rnn.params)
+  dw = zero(rnn.params)
   cudnnRNNBackwardWeights(rnn, 1,
     xDesc(x), x, hDesc(h)..., xDesc(y), y,
     FilterDesc(T, (1, 1, length(dw))), dw,

src/data/cmudict.jl

@@ -24,23 +24,23 @@ end
 
 function phones()
   load()
-  Symbol.(first.(split.(split(readstring(deps("cmudict", "cmudict.phones")),
+  Symbol.(first.(split.(split(read(deps("cmudict", "cmudict.phones"),String),
                         "\n", keep = false), "\t")))
 end
 
 function symbols()
   load()
-  Symbol.(split(readstring(deps("cmudict", "cmudict.symbols")),
+  Symbol.(split(read(deps("cmudict", "cmudict.symbols"),String),
                 "\n", keep = false))
 end
 
 function rawdict()
   load()
   Dict(String(xs[1]) => Symbol.(xs[2:end]) for xs in
-       filter(!isempty, split.(split(readstring(deps("cmudict", "cmudict")), "\n"))))
+       filter(!isempty, split.(split(read(deps("cmudict", "cmudict"),String), "\n"))))
 end
 
-validword(s) = isascii(s) && ismatch(r"^[\w\-\.]+$", s)
+validword(s) = isascii(s) && occursin(r"^[\w\-\.]+$", s)
 
 cmudict() = filter((s, ps) -> validword(s), rawdict())
 

src/layers/conv.jl

@@ -32,7 +32,7 @@ Conv(w::AbstractArray{T,N}, b::AbstractVector{T}, σ = identity;
 
 Conv(k::NTuple{N,Integer}, ch::Pair{<:Integer,<:Integer}, σ = identity; init = initn,
      stride = 1, pad = 0, dilation = 1) where N =
-  Conv(param(init(k..., ch...)), param(zeros(ch[2])), σ,
+  Conv(param(init(k..., ch...)), param(zero(ch[2])), σ,
        stride = stride, pad = pad, dilation = dilation)
 
 @treelike Conv

src/layers/normalise.jl

@@ -110,7 +110,7 @@ end
 BatchNorm(chs::Integer, λ = identity;
           initβ = zeros, initγ = ones, ϵ = 1e-8, momentum = .1) =
   BatchNorm(λ, param(initβ(chs)), param(initγ(chs)),
-            zeros(chs), ones(chs), ϵ, momentum, true)
+            zero(chs), ones(chs), ϵ, momentum, true)
 
 function (BN::BatchNorm)(x)
   size(x, ndims(x)-1) == length(BN.β) ||

src/layers/recurrent.jl

@@ -84,7 +84,7 @@ end
 RNNCell(in::Integer, out::Integer, σ = tanh;
         init = glorot_uniform) =
   RNNCell(σ, param(init(out, in)), param(init(out, out)),
-          param(zeros(out)), param(initn(out)))
+          param(zero(out)), param(initn(out)))
 
 function (m::RNNCell)(h, x)
   σ, Wi, Wh, b = m.σ, m.Wi, m.Wh, m.b
@@ -122,7 +122,7 @@ end
 
 function LSTMCell(in::Integer, out::Integer;
                   init = glorot_uniform)
-  cell = LSTMCell(param(init(out*4, in)), param(init(out*4, out)), param(zeros(out*4)),
+  cell = LSTMCell(param(init(out*4, in)), param(init(out*4, out)), param(zero(out*4)),
                   param(initn(out)), param(initn(out)))
   cell.b.data[gate(out, 2)] = 1
   return cell
@@ -170,7 +170,7 @@ end
 
 GRUCell(in, out; init = glorot_uniform) =
   GRUCell(param(init(out*3, in)), param(init(out*3, out)),
-          param(zeros(out*3)), param(initn(out)))
+          param(zero(out*3)), param(initn(out)))
 
 function (m::GRUCell)(h, x)
   b, o = m.b, size(h, 1)

src/optimise/Optimise.jl

@@ -9,7 +9,7 @@ struct Param{T}
   Δ::T
 end
 
-Base.convert(::Type{Param}, x::AbstractArray) = Param(x, zeros(x))
+Base.convert(::Type{Param}, x::AbstractArray) = Param(x, zero(x))
 
 include("optimisers.jl")
 include("interface.jl")

src/optimise/optimisers.jl

@@ -14,7 +14,7 @@ function descentweightdecay(p::Param, η::Real,  γ::Real)
 end
 
 function momentum(p::Param, ρ, η)
-  v = zeros(p.x)
+  v = zero(p.x)
   function ()
     @. v = ρ * v - η * p.Δ
     @. p.Δ = -v
@@ -23,7 +23,7 @@ end
 
 # Ref. https://arxiv.org/pdf/1212.0901.pdf
 function nesterov(p::Param, ρ, η)
-  v = zeros(p.x)
+  v = zero(p.x)
   function ()
     d = @. ρ^2 * v - (1+ρ) * η * p.Δ
     @. v = ρ*v - η*p.Δ
@@ -32,7 +32,7 @@ function nesterov(p::Param, ρ, η)
 end
 
 function rmsprop(p::Param; η::Real = 0.001, ρ::Real = 0.9, ϵ::Real = 1e-8)
-  acc  = zeros(p.x)
+  acc  = zero(p.x)
   function ()
     @. acc = ρ * acc + (1 - ρ) * p.Δ^2
     @. p.Δ *= η / √(acc + ϵ)
@@ -40,7 +40,7 @@ function rmsprop(p::Param; η::Real = 0.001, ρ::Real = 0.9, ϵ::Real = 1e-8)
 end
 
 function adagrad(p::Param; η::Real = 0.01, ϵ::Real = 1e-8)
-  acc = zeros(p.x) .+ ϵ
+  acc = zero(p.x) .+ ϵ
   function ()
     @. acc += p.Δ^2
     @. p.Δ *= η / √(acc + ϵ)
@@ -48,8 +48,8 @@ function adagrad(p::Param; η::Real = 0.01, ϵ::Real = 1e-8)
 end
 
 function adadelta(p::Param; ρ::Real = 0.9, ϵ::Real = 1e-8)
-  acc = zeros(p.x)
-  Δacc = zeros(p.x)
+  acc = zero(p.x)
+  Δacc = zero(p.x)
   function ()
     @. acc = ρ * acc + (1 - ρ) * p.Δ^2
     @. p.Δ *= √(Δacc + ϵ) / √(acc + ϵ)
@@ -58,8 +58,8 @@ function adadelta(p::Param; ρ::Real = 0.9, ϵ::Real = 1e-8)
 end
 
 function adam(p::Param; η::Real = 0.001, β1::Real = 0.9, β2::Real = 0.999, ϵ::Real = 1e-8)
-  mt = zeros(p.x)
-  vt = zeros(p.x)
+  mt = zero(p.x)
+  vt = zero(p.x)
   β1p, β2p = β1, β2
   function ()
     @. mt = β1 * mt + (1 - β1) * p.Δ
@@ -71,8 +71,8 @@ function adam(p::Param; η::Real = 0.001, β1::Real = 0.9, β2::Real = 0.999, ϵ
 end
 
 function adamax(p::Param; η::Real = 0.002, β1::Real = 0.9, β2::Real = 0.999, ϵ::Real = 1e-8)
-  mt = zeros(p.x)
-  ut = zeros(p.x)
+  mt = zero(p.x)
+  ut = zero(p.x)
   β1p = β1
   function ()
     @. mt = β1 * mt + (1 - β1) * p.Δ
@@ -83,9 +83,9 @@ function adamax(p::Param; η::Real = 0.002, β1::Real = 0.9, β2::Real = 0.999,
 end
 
 function amsgrad(p::Param; η::Real = 0.001, β1::Real = 0.9, β2::Real = 0.999, ϵ::Real = 1e-8)
-  mt = zeros(p.x)
-  vt = zeros(p.x) .+ ϵ
-  v̂t = zeros(p.x) .+ ϵ
+  mt = zero(p.x)
+  vt = zero(p.x) .+ ϵ
+  v̂t = zero(p.x) .+ ϵ
   function ()
     @. mt = β1 * mt + (1 - β1) * p.Δ
     @. vt = β2 * vt + (1 - β2) * p.Δ ^ 2
@@ -95,8 +95,8 @@ function amsgrad(p::Param; η::Real = 0.001, β1::Real = 0.9, β2::Real = 0.999,
 end
 
 function nadam(p::Param; η::Real = 0.001, β1::Real = 0.9, β2::Real = 0.999, ϵ::Real = 1e-8)
-  mt = zeros(p.x)
-  vt = zeros(p.x)
+  mt = zero(p.x)
+  vt = zero(p.x)
   β1p, β2p = β1, β2
   function ()
     @. mt = β1 * mt + (1 - β1) * p.Δ

src/utils.jl

@@ -145,7 +145,7 @@ function jacobian(m,x)
     y  = m(xp)
     k  = length(y)
     n  = length(x)
-    J  = Matrix{eltype(x)}(n,k)
+    J  = Matrix{eltype(x)}(undef,n,k)
     for i = 1:k
         Flux.back!(y[i]) # Populate gradient accumulator
         J[:,i] = xp.grad

test/layers/normalisation.jl

@@ -4,7 +4,7 @@ using Flux: testmode!
   x = [1.,2.,3.]
   @test x == testmode!(Dropout(0.1))(x)
   @test x == Dropout(0)(x)
-  @test zeros(x) == Dropout(1)(x)
+  @test zero(x) == Dropout(1)(x)
 
   x = rand(100)
   m = Dropout(0.9)

test/runtests.jl

@@ -1,4 +1,4 @@
-using Flux, Base.Test
+using Flux, Test, Random
 
 srand(0)
 

test/tracker.jl

@@ -99,7 +99,7 @@ end
   @test gradtest((a,b)->cat(a, b, dims = (2,3,5)), rand(2,3), rand(2,4,2,1))
 
   @testset "promotiontest" begin
-    @testset for fcat in [hcat, vcat, (x...) -> cat(3, x...), (x...) -> cat((1,2), x...)]
+    @testset for fcat in [hcat, vcat, (x...) -> cat(x..., dims = 3), (x...) -> cat(x..., dims = (1,2))]
       promotiontest(fcat, rand(2), rand(2), rand(2))
       promotiontest(fcat, rand(2)', rand(2)', rand(2)')
       promotiontest(fcat, rand(2,2), rand(2,2), rand(2,2))