update from julia 0.7 to 1.1

Author: lalvim

src/kernel_perceptron.jl

@@ -44,7 +44,7 @@ end
 function trainer(model::KernelPerceptron{T},
 	              X::AbstractArray{T},
         			  Y::Vector{T}) where T<:AbstractFloat
-   Y[Y .== 0]  = -1 # fix in the future outside this function
+   Y[Y .== 0]  .= -1 # fix in the future outside this function
    max_epochs  = model.max_epochs
    λ           = model.λ    # langrange multipliers
    K           = ΦΦ(X,model.width) # computing the kernel gram matrix
@@ -100,7 +100,7 @@ function predictor(model::KernelPerceptron{T},
       y[i] = s
    end
    y   = sign.(y)
-   y[y .== -1]  = 0 # fix in the future outside this function!!
+   y[y .== -1]  .= 0 # fix in the future outside this function!!
    return y
 
 end

src/linear_perceptron.jl

@@ -1,6 +1,7 @@
 # use in linear perceptron
 @inline   h(Θ,x) = sinal(Θ'*x)
 
+import Random
 
 function trainer(model::LinearPerceptron{T},
 	              X::AbstractArray{T},
@@ -11,15 +12,15 @@ function trainer(model::LinearPerceptron{T},
    max_epochs    = model.max_epochs
 
    if random_state!=-1
-      srand(random_state)
+      Random.seed!(random_state)
    end
 
    n,m         = size(X)
    X           = hcat(X,ones(n,1)) # adding bias
    history     = []
    nerrors,nlast_errors = Inf,0
    epochs      = 0
-   Θ           = rand(m+1)   #  already with bias
+   Θ           = Random.rand(m+1)   #  already with bias
    α           = model.α   #  learning rate
    while  nerrors>0 && epochs < max_epochs
    # stops when error is equal to zero or grater than last_error or reached max iterations

src/types.jl

@@ -2,7 +2,7 @@
 const MODEL_FILENAME = "perceptron_model.jld" # jld filename for storing the model
 const MODEL_ID       = "perceptron_model"     # if od the model in the filesystem jld data
 
-using Statistics 
+using Statistics
 
 #### An abstract perceptron model
 abstract type PerceptronModel{T} end
@@ -30,14 +30,14 @@ function LinearPerceptron(X::AbstractArray{T},
                           centralize) where T<:AbstractFloat
 
    return LinearPerceptron(alpha, # I will refactor to a constructor. Cleaner
-                           Vector{T}(1),
+                           Vector{T}(undef,1),
                            shuffle_epoch,
                            random_state,
                            max_epochs,
                            0,
-                           Vector{Integer}(1),
-                           mean(X,1),
-                           std(X,1),
+                           Vector{Integer}(undef,1),
+                           mean(X,dims=1),
+                           std(X,dims=1),
                            centralize,
                            size(X,2))
 
@@ -76,9 +76,9 @@ function VotedPerceptron(X::AbstractArray{T},
                            random_state,
                            max_epochs,
                            0,
-                           Vector{Integer}(1),
-                           mean(X,1),
-                           std(X,1),
+                           Vector{Integer}(undef,1),
+                           mean(X,dims=1),
+                           std(X,dims=1),
                            centralize,
                            size(X,2))
 
@@ -113,15 +113,15 @@ function KernelPerceptron(X::AbstractArray{T},
    return KernelPerceptron(zeros(T,size(X,1)),
                            max_epochs,
                            0,
-                           Vector{Integer}(1),
-                           mean(X,1),
-                           std(X,1),
+                           Vector{Integer}(undef,1),
+                           mean(X,dims=1),
+                           std(X,dims=1),
                            centralize,
                            size(X,2),
                            kernel,
                            width,
-                           Vector{T}(1),
-                           Vector{T}(1))
+                           Vector{T}(undef,1),
+                           Vector{T}(undef,1))
 
 end
 
@@ -155,9 +155,9 @@ function AveragedPerceptron(X::AbstractArray{T},
                            random_state,
                            max_epochs,
                            0,
-                           Vector{Integer}(1),
-                           mean(X,1),
-                           std(X,1),
+                           Vector{Integer}(undef,1),
+                           mean(X,dims=1),
+                           std(X,dims=1),
                            centralize,
                            size(X,2))
 
@@ -169,7 +169,7 @@ end
 
 ## choosing types
 ######################################################################################################
-function Model(X::AbstractArray{T},
+function Model(X,#::AbstractArray{T},
                alpha,
                shuffle_epoch,
                random_state,
@@ -179,6 +179,7 @@ function Model(X::AbstractArray{T},
                width,
                mode) where T<:AbstractFloat
 
+      println("size",size(X))
       if mode == "linear"
          return LinearPerceptron(X,
                                  alpha,

test/kernel_perceptron_test.jl

@@ -103,6 +103,10 @@ end
     X = [1.0 1.0; 0.0 1.0; 1.0 0.0; 0.0 0.0]
     Y = [1.0 ; -1; 0.0; 0.0]
 
-    try model = Perceptrons.fit(X,Y,mode="kernel",kernel="rbf",width=1.0) catch @test true end
+    try
+        model = Perceptrons.fit(X,Y,mode="kernel",kernel="rbf",width=1.0)
+    catch
+        @test true
+    end
 
 end

test/linear_perceptron_test.jl

@@ -73,6 +73,10 @@ end
     X = [1.0 1.0; 0.0 1.0; 1.0 0.0; 0.0 0.0]
     Y = [1.0 ; -1; 0.0; 0.0]
 
-    try model = Perceptrons.fit(X,Y) catch @test true end
+    try
+        model = Perceptrons.fit(X,Y)
+    catch
+        @test true
+    end
 
 end