Incorrect force push

Author: Avik Pal

test/activation.jl

@@ -82,9 +82,9 @@ end
 
   xs = rand(5,5)
 
-  @test all(sum(softmax(xs), dims = 1) .≈ 1)
+  @test all(sum(softmax(xs), dims = 1) .≈ Float32(1))
 
-  @test sum(softmax(vec(xs))) ≈ 1
+  @test sum(softmax(vec(xs))) ≈ Float32(1)
 
   @testset "elu" begin
       @test elu(42) == 42

test/conv.jl

@@ -6,37 +6,40 @@ using NNlib: conv, ∇conv_filter, ∇conv_data, ∇maxpool, maxpool, depthwisec
     w = reshape(Float32[1:9;], 3, 3, 1, 1)
 
     @test dropdims(conv(x, w, pad=1), dims=(3,4)) ≈ Float32.([
-        29.0   99.0  207.0  263.0
-        62.0  192.0  372.0  446.0
-        83.0  237.0  417.0  485.0
-        75.0  198.0  330.0  365.0])
+        29   99  207  263
+        62  192  372  446
+        83  237  417  485
+        75  198  330  365])
 
     x = reshape(Float64[1:20;], 5, 4, 1, 1)
     w = reshape(Float64[1:4;], 2, 2, 1, 1)
 
-    @test dropdims(conv(x, w), dims = (3,4)) == [
-        29 79 129;
-        39 89 139;
-        49 99 149;
-        59 109 159.]
+    @test dropdims(conv(x, w), dims = (3,4)) ≈ Float32.([
+        29  79 129;
+        39  89 139;
+        49  99 149;
+        59 109 159
+    ])
 
-    @test dropdims(conv(x, w; stride=2), dims = (3,4)) == [
+    @test dropdims(conv(x, w; stride=2), dims = (3,4)) ≈ Float32.([
         29 129;
-        49 149.]
+        49 149
+    ])
 
-    @test dropdims(conv(x, w; pad=1), dims = (3,4)) == [
-        1.0   9.0   29.0   49.0   48.0;
-        4.0  29.0   79.0  129.0  115.0;
-        7.0  39.0   89.0  139.0  122.0;
-        10.0  49.0   99.0  149.0  129.0;
-        13.0  59.0  109.0  159.0  136.0;
-        10.0  40.0   70.0  100.0   80.0
-    ]
+    @test dropdims(conv(x, w; pad=1), dims = (3,4)) ≈ Float32.([
+        1    9   29   49   48;
+        4   29   79  129  115;
+        7   39   89  139  122;
+        10  49   99  149  129;
+        13  59  109  159  136;
+        10  40   70  100   80
+    ])
 
-    @test dropdims(conv(x, w; dilation=2), dims = (3,4)) == [
-        48 98;
+    @test dropdims(conv(x, w; dilation=2), dims = (3,4)) ≈ Float32.([
+        48  98;
         58 108;
-        68 118.]
+        68 118
+    ])
 
 	# NaN tests for dilation forward pass
 
@@ -99,7 +102,7 @@ end
         W = copy(permutedims(w[:,:,:,i:i],[1,2,4,3]));
         DY = copy(dy[:,:,2i-1:2i,:]);
         res = ∇conv_data(DY,X,W)
-        @test dropdims(z[:,:,i:i,:], dims=(3,4)) == dropdims(res, dims=(3,4))
+        @test dropdims(z[:,:,i:i,:], dims=(3,4)) ≈ Float32.(dropdims(res, dims=(3,4)))
     end
 
     z = ∇depthwiseconv_filter(dy, x, w)
@@ -108,7 +111,7 @@ end
         W = copy(permutedims(w[:,:,:,i:i],[1,2,4,3]))
         DY = copy(dy[:,:,2i-1:2i,:])
         res = ∇conv_filter(DY,X,W)
-        @test dropdims(z[:,:,:,i:i]; dims=(4)) == dropdims(res; dims=(3))
+        @test dropdims(z[:,:,:,i:i]; dims=(4)) ≈ Float32.(dropdims(res; dims=(3)))
     end
 
     @test size(∇depthwiseconv_filter(rand(2,2,4,1), x, w)) == size(w)
@@ -125,17 +128,20 @@ end
 
 	x = reshape(Float32[1:16;], 4, 4, 1, 1)
 
-	@test dropdims(maxpool(x, (2,2)), dims = (3,4)) == Float32.([6.0 14.0; 8.0 16.0])
+	@test dropdims(maxpool(x, (2,2)), dims = (3,4)) ≈ Float32.([
+        6.0 14.0;
+        8.0 16.0
+    ])
 
     x = reshape(Float64[1:20;], 5, 4, 1, 1)
 
-    @test dropdims(maxpool(x, (2,2)), dims = (3,4)) == [7 17; 9 19]
-    @test dropdims(maxpool(x, (2,2); stride=(2,2)), dims = (3,4)) == [7 17; 9 19]
-    @test dropdims(maxpool(x, (2,2); pad=(1,1)), dims = (3,4)) == [
-        1.0  11.0  16.0;
-        3.0  13.0  18.0;
-        5.0  15.0  20.0;
-    ]
+    @test dropdims(maxpool(x, (2,2)), dims = (3,4)) ≈ Float32.([7 17; 9 19])
+    @test dropdims(maxpool(x, (2,2); stride=(2,2)), dims = (3,4)) ≈ Float32.([7 17; 9 19])
+    @test dropdims(maxpool(x, (2,2); pad=(1,1)), dims = (3,4)) ≈ Float32.([
+        1  11  16;
+        3  13  18;
+        5  15  20;
+    ])
 
     # for gradients, check only size
     # correctness of gradients is cross-checked with CUDNN.jl

test/runtests.jl

@@ -10,14 +10,14 @@ xs = [-100_000, -100_000.]
 @test logsoftmax(xs) ≈ log.([0.5, 0.5])
 
 xs = rand(5)
-@test softmax(xs) ≈ exp.(xs) ./ sum(exp.(xs))
-@test logsoftmax(xs) ≈ log.(softmax(xs))
-@test logsigmoid.(xs) ≈ log.(sigmoid.(xs))
+@test softmax(xs) ≈ Float32.(exp.(xs) ./ sum(exp.(xs)))
+@test logsoftmax(xs) ≈ Float32.(log.(softmax(xs)))
+@test logsigmoid.(xs) ≈ Float32.(log.(sigmoid.(xs)))
 
 xs = rand(5,10)
-@test softmax(xs) ≈ exp.(xs) ./ sum(exp.(xs), dims = 1)
-@test logsoftmax(xs) ≈ log.(softmax(xs))
-@test logsigmoid.(xs) ≈ log.(sigmoid.(xs))
+@test softmax(xs) ≈ Float32.(exp.(xs) ./ sum(exp.(xs), dims = 1))
+@test logsoftmax(xs) ≈ Float32.(log.(softmax(xs)))
+@test logsigmoid.(xs) ≈ Float32.(log.(sigmoid.(xs)))
 
 for T in [:Float32, :Float64]
   @eval @test logsigmoid.($T[-100_000, 100_000.]) ≈ $T[-100_000, 0.]