Rename and refactor convolution and pooling operators. (#168)

neild0 · rxwei · commit 2c7a1909bc42 · 2019-06-04T17:28:16.000-07:00
- Change method `Tensor.convolved2D(withFilter:strides:padding:)` to a top-level function named **`conv2D(_:filter:strides:padding:)`**, taking the original `self` as a first argument.
- Change method `Tensor.convolved3D(withFilter:strides:padding:)` to a top-level function named **`conv3D(_:filter:strides:padding:)`**, taking the original `self` as a first argument.
- Change method `Tensor.maxPooled2D(kernelSize:strides:padding:)` to a top-level function named **`maxPool2D(_:filterSize:strides:padding:)`**, taking the original `self` as a first argument.
- Change method `Tensor.maxPooled3D(kernelSize:strides:padding:)` to a top-level function named **`maxPool3D(_:filterSize:strides:padding:)`**, taking the original `self` as a first argument.
- Change method `Tensor.avgPooled2D(kernelSize:strides:padding:)` to a top-level function named **`avgPool2D(_:filterSize:strides:padding:)`**, taking the original `self` as a first argument.
- Change method `Tensor.avgPooled3D(kernelSize:strides:padding:)` to a top-level function named **`avgPool3D(_:filterSize:strides:padding:)`**, taking the original `self` as a first argument.
diff --git a/Sources/TensorFlow/Layers/Convolutional.swift b/Sources/TensorFlow/Layers/Convolutional.swift
@@ -60,9 +60,9 @@ public struct Conv1D<Scalar: TensorFlowFloatingPoint>: Layer {
     /// - Returns: The output `[batchCount, newWidth, outputChannels]`.
     @differentiable
     public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {
-        let conv2D = input.expandingShape(at: 1).convolved2D(
-            withFilter: filter.expandingShape(at: 0), strides: (1, 1, stride, 1), padding: padding)
-        return activation(conv2D.squeezingShape(at: 1) + bias)
+        let conv = conv2D(input.expandingShape(at: 1), filter: filter.expandingShape(at: 0),
+                          strides: (1, 1, stride, 1), padding: padding)
+        return activation(conv.squeezingShape(at: 1) + bias)
     }
 }
 
@@ -178,9 +178,8 @@ public struct Conv2D<Scalar: TensorFlowFloatingPoint>: Layer {
     /// - Returns: The output.
     @differentiable
     public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {
-        return activation(input.convolved2D(withFilter: filter,
-                                            strides: (1, strides.0, strides.1, 1),
-                                            padding: padding) + bias)
+        return activation(conv2D(input, filter: filter, strides: (1, strides.0, strides.1, 1),
+                                 padding: padding) + bias)
     }
 }
 
@@ -294,9 +293,9 @@ public struct Conv3D<Scalar: TensorFlowFloatingPoint>: Layer {
     /// - Returns: The output.
     @differentiable
     public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {
-        return activation(input.convolved3D(withFilter: filter,
-                                            strides: (1, strides.0, strides.1, strides.2, 1),
-                                            padding: padding) + bias)
+        return activation(conv3D(input, filter: filter,
+                                 strides: (1, strides.0, strides.1, strides.2, 1),
+                                 padding: padding) + bias)
     }
 }
 
@@ -419,9 +418,9 @@ public struct TransposedConv2D: Layer {
           strides.1 + (filter.shape[1] * paddingIndex)
         let c = filter.shape[2]
         let newShape = Tensor<Int32>([Int32(batchSize), Int32(w), Int32(h), Int32(c)])
-        return activation(input.conv2DBackpropInput(shape: newShape, filter: filter,
-                                                    strides: (1, strides.0, strides.1, 1),
-                                                    padding: padding) + bias)
+        return activation(conv2DBackpropInput(input, shape: newShape, filter: filter,
+                                              strides: (1, strides.0, strides.1, 1),
+                                              padding: padding) + bias)
     }
 }
 
diff --git a/Sources/TensorFlow/Layers/Pooling.swift b/Sources/TensorFlow/Layers/Pooling.swift
@@ -44,9 +44,8 @@ public struct MaxPool1D<Scalar: TensorFlowFloatingPoint>: Layer {
     /// - Returns: The output.
     @differentiable
     public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {
-        return input.expandingShape(at: 1).maxPooled2D(
-            kernelSize: (1, 1, poolSize, 1), strides: (1, 1, stride, 1), padding: padding
-        ).squeezingShape(at: 1)
+        return maxPool2D(input.expandingShape(at: 1), filterSize: (1, 1, poolSize, 1),
+                         strides: (1, 1, stride, 1), padding: padding).squeezingShape(at: 1)
     }
 }
 
@@ -78,8 +77,7 @@ public struct MaxPool2D<Scalar: TensorFlowFloatingPoint>: Layer {
     /// - Returns: The output.
     @differentiable
     public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {
-        return input.maxPooled2D(
-            kernelSize: poolSize, strides: strides, padding: padding)
+        return maxPool2D(input, filterSize: poolSize, strides: strides, padding: padding)
     }
 }
 
@@ -125,7 +123,7 @@ public struct MaxPool3D<Scalar: TensorFlowFloatingPoint>: Layer {
     /// - Returns: The output.
     @differentiable
     public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {
-        return input.maxPooled3D(kernelSize: poolSize, strides: strides, padding: padding)
+        return maxPool3D(input, filterSize: poolSize, strides: strides, padding: padding)
     }
 }
 
@@ -185,9 +183,8 @@ public struct AvgPool1D<Scalar: TensorFlowFloatingPoint>: Layer {
     /// - Returns: The output.
     @differentiable
     public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {
-        return input.expandingShape(at: 1).averagePooled2D(
-            kernelSize: (1, 1, poolSize, 1), strides: (1, 1, stride, 1), padding: padding
-        ).squeezingShape(at: 1)
+        return avgPool2D(input.expandingShape(at: 1), filterSize: (1, 1, poolSize, 1),
+                         strides: (1, 1, stride, 1), padding: padding).squeezingShape(at: 1)
     }
 }
 
@@ -219,7 +216,7 @@ public struct AvgPool2D<Scalar: TensorFlowFloatingPoint>: Layer {
     /// - Returns: The output.
     @differentiable
     public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {
-        return input.averagePooled2D(kernelSize: poolSize, strides: strides, padding: padding)
+        return avgPool2D(input, filterSize: poolSize, strides: strides, padding: padding)
     }
 }
 
@@ -265,7 +262,7 @@ public struct AvgPool3D<Scalar: TensorFlowFloatingPoint>: Layer {
     /// - Returns: The output.
     @differentiable
     public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {
-        return input.averagePooled3D(kernelSize: poolSize, strides: strides, padding: padding)
+        return avgPool3D(input, filterSize: poolSize, strides: strides, padding: padding)
     }
 }
 
diff --git a/Sources/TensorFlow/Operators/NN.swift b/Sources/TensorFlow/Operators/NN.swift

Original file line number	Diff line number	Diff line change
`@@ -60,9 +60,9 @@ public struct Conv1D<Scalar: TensorFlowFloatingPoint>: Layer {`
`60`	`60`	/// - Returns: The output `[batchCount, newWidth, outputChannels]`.
`61`	`61`	`@differentiable`
`62`	`62`	`public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {`
`63`		`- let conv2D = input.expandingShape(at: 1).convolved2D(`
`64`		`- withFilter: filter.expandingShape(at: 0), strides: (1, 1, stride, 1), padding: padding)`
`65`		`- return activation(conv2D.squeezingShape(at: 1) + bias)`
	`63`	`+ let conv = conv2D(input.expandingShape(at: 1), filter: filter.expandingShape(at: 0),`
	`64`	`+ strides: (1, 1, stride, 1), padding: padding)`
	`65`	`+ return activation(conv.squeezingShape(at: 1) + bias)`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`@@ -178,9 +178,8 @@ public struct Conv2D<Scalar: TensorFlowFloatingPoint>: Layer {`
`178`	`178`	`/// - Returns: The output.`
`179`	`179`	`@differentiable`
`180`	`180`	`public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {`
`181`		`- return activation(input.convolved2D(withFilter: filter,`
`182`		`- strides: (1, strides.0, strides.1, 1),`
`183`		`- padding: padding) + bias)`
	`181`	`+ return activation(conv2D(input, filter: filter, strides: (1, strides.0, strides.1, 1),`
	`182`	`+ padding: padding) + bias)`
`184`	`183`	`}`
`185`	`184`	`}`
`186`	`185`
`@@ -294,9 +293,9 @@ public struct Conv3D<Scalar: TensorFlowFloatingPoint>: Layer {`
`294`	`293`	`/// - Returns: The output.`
`295`	`294`	`@differentiable`
`296`	`295`	`public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {`
`297`		`- return activation(input.convolved3D(withFilter: filter,`
`298`		`- strides: (1, strides.0, strides.1, strides.2, 1),`
`299`		`- padding: padding) + bias)`
	`296`	`+ return activation(conv3D(input, filter: filter,`
	`297`	`+ strides: (1, strides.0, strides.1, strides.2, 1),`
	`298`	`+ padding: padding) + bias)`
`300`	`299`	`}`
`301`	`300`	`}`
`302`	`301`
`@@ -419,9 +418,9 @@ public struct TransposedConv2D: Layer {`
`419`	`418`	`strides.1 + (filter.shape[1] * paddingIndex)`
`420`	`419`	`let c = filter.shape[2]`
`421`	`420`	`let newShape = Tensor<Int32>([Int32(batchSize), Int32(w), Int32(h), Int32(c)])`
`422`		`- return activation(input.conv2DBackpropInput(shape: newShape, filter: filter,`
`423`		`- strides: (1, strides.0, strides.1, 1),`
`424`		`- padding: padding) + bias)`
	`421`	`+ return activation(conv2DBackpropInput(input, shape: newShape, filter: filter,`
	`422`	`+ strides: (1, strides.0, strides.1, 1),`
	`423`	`+ padding: padding) + bias)`
`425`	`424`	`}`
`426`	`425`	`}`
`427`	`426`
Original file line number	Diff line number	Diff line change
`@@ -44,9 +44,8 @@ public struct MaxPool1D<Scalar: TensorFlowFloatingPoint>: Layer {`
`44`	`44`	`/// - Returns: The output.`
`45`	`45`	`@differentiable`
`46`	`46`	`public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {`
`47`		`- return input.expandingShape(at: 1).maxPooled2D(`
`48`		`- kernelSize: (1, 1, poolSize, 1), strides: (1, 1, stride, 1), padding: padding`
`49`		`- ).squeezingShape(at: 1)`
	`47`	`+ return maxPool2D(input.expandingShape(at: 1), filterSize: (1, 1, poolSize, 1),`
	`48`	`+ strides: (1, 1, stride, 1), padding: padding).squeezingShape(at: 1)`
`50`	`49`	`}`
`51`	`50`	`}`
`52`	`51`
`@@ -78,8 +77,7 @@ public struct MaxPool2D<Scalar: TensorFlowFloatingPoint>: Layer {`
`78`	`77`	`/// - Returns: The output.`
`79`	`78`	`@differentiable`
`80`	`79`	`public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {`
`81`		`- return input.maxPooled2D(`
`82`		`- kernelSize: poolSize, strides: strides, padding: padding)`
	`80`	`+ return maxPool2D(input, filterSize: poolSize, strides: strides, padding: padding)`
`83`	`81`	`}`
`84`	`82`	`}`
`85`	`83`
`@@ -125,7 +123,7 @@ public struct MaxPool3D<Scalar: TensorFlowFloatingPoint>: Layer {`
`125`	`123`	`/// - Returns: The output.`
`126`	`124`	`@differentiable`
`127`	`125`	`public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {`
`128`		`- return input.maxPooled3D(kernelSize: poolSize, strides: strides, padding: padding)`
	`126`	`+ return maxPool3D(input, filterSize: poolSize, strides: strides, padding: padding)`
`129`	`127`	`}`
`130`	`128`	`}`
`131`	`129`
`@@ -185,9 +183,8 @@ public struct AvgPool1D<Scalar: TensorFlowFloatingPoint>: Layer {`
`185`	`183`	`/// - Returns: The output.`
`186`	`184`	`@differentiable`
`187`	`185`	`public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {`
`188`		`- return input.expandingShape(at: 1).averagePooled2D(`
`189`		`- kernelSize: (1, 1, poolSize, 1), strides: (1, 1, stride, 1), padding: padding`
`190`		`- ).squeezingShape(at: 1)`
	`186`	`+ return avgPool2D(input.expandingShape(at: 1), filterSize: (1, 1, poolSize, 1),`
	`187`	`+ strides: (1, 1, stride, 1), padding: padding).squeezingShape(at: 1)`
`191`	`188`	`}`
`192`	`189`	`}`
`193`	`190`
`@@ -219,7 +216,7 @@ public struct AvgPool2D<Scalar: TensorFlowFloatingPoint>: Layer {`
`219`	`216`	`/// - Returns: The output.`
`220`	`217`	`@differentiable`
`221`	`218`	`public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {`
`222`		`- return input.averagePooled2D(kernelSize: poolSize, strides: strides, padding: padding)`
	`219`	`+ return avgPool2D(input, filterSize: poolSize, strides: strides, padding: padding)`
`223`	`220`	`}`
`224`	`221`	`}`
`225`	`222`
`@@ -265,7 +262,7 @@ public struct AvgPool3D<Scalar: TensorFlowFloatingPoint>: Layer {`
`265`	`262`	`/// - Returns: The output.`
`266`	`263`	`@differentiable`
`267`	`264`	`public func callAsFunction(_ input: Tensor<Scalar>) -> Tensor<Scalar> {`
`268`		`- return input.averagePooled3D(kernelSize: poolSize, strides: strides, padding: padding)`
	`265`	`+ return avgPool3D(input, filterSize: poolSize, strides: strides, padding: padding)`
`269`	`266`	`}`
`270`	`267`	`}`
`271`	`268`