10000 Merge pull request #252 from DiffSharp/feature/avgpool · DiffSharp/DiffSharp@64d540b · GitHub
[go: up one dir, main page]
Skip to content

Commit 64d540b

Browse files
gbaydingbaydin
authored
Merge pull request #252 from DiffSharp/feature/avgpool
feature/avgpool - avgpool1d, avgpool2d, avgpool3d
2 parents 59282fc + 4ca81c2 commit 64d540b

File tree

10 files changed

+1359
-7
lines changed

10 files changed

+1359
-7
lines changed

‎src/DiffSharp.Backends.Reference/Reference.RawTensor.fs

Lines changed: 169 additions & 0 deletions
Large diffs are not rendered by default.

‎src/DiffSharp.Backends.Torch/Torch.RawTensor.fs

Lines changed: 50 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -740,6 +740,56 @@ type TorchRawTensor(tt: TorchTensor, shape: Shape, dtype: Dtype, device: Device)
740740
let resultt = tt.maxunpool3d(indices.TorchTensor, int64s outputSize, strides, padding)
741741
t1.MakeLike(resultt, shape=outputShape)
742742

743+
override t1.AvgPool1D(kernelSize, stride, padding) =
744+
let _batchSize, _channels, _inputSize, _outputSize, outputShape = Shape.checkCanAvgpool1d dtype t1.Shape kernelSize stride padding
745+
match dtype with
746+
| Dtype.Bool | Dtype.Integral -> opNotSupported "AvgPool1D" dtype
747+
| _ ->
748+
let resultt = tt.avg_pool1d(int64 kernelSize, stride=int64 stride, padding=int64 padding)
749+
let result = t1.MakeLike(resultt, shape=outputShape)
750+
result
751+
752+
override t1.AvgPool2D(kernelSize, stride, padding) =
753+
let _batchSize, _channels, _inputSize, _kernelSize, _outputSize, outputShape = Shape.checkCanAvgpool2d dtype t1.Shape kernelSize stride padding
754+
match dtype with
755+
| Dtype.Bool | Dtype.Integral -> opNotSupported "AvgPool2D" dtype
756+
| _ ->
757+
let resultt = tt.avg_pool2d(int64s kernelSize, strides=int64s stride, paddings=int64s padding)
758+
let result = t1.MakeLike(resultt, shape=outputShape)
759+
result
760+
761+
override t1.AvgPool3D(kernelSize, stride, padding) =
762+
let _batchSize, _channels, _inputSize, _kernelSize, _outputSize, outputShape = Shape.checkCanAvgpool3d dtype t1.Shape kernelSize stride padding
763+
match dtype with
764+
| Dtype.Bool | Dtype.Integral -> opNotSupported "AvgPool3D" dtype
765+
| _ ->
766+
let resultt = tt.avg_pool3d(int64s kernelSize, strides=int64s stride, paddings=int64s padding)
767+
let result = t1.MakeLike(resultt, shape=outputShape)
768+
result
769+
770+
override t1.AvgPoolReverse1D(originalInput, kernelSize, stride, padding) =
771+
let t1X = t1.UnsqueezeT(2)
772+
let originalInputX = originalInput.UnsqueezeT(2)
773+
let resulttX = t1X.AvgPoolReverse2D(originalInputX, [| 1; kernelSize |], [| 1; stride |], [| 0; padding |])
774+
let resultt = resulttX.SqueezeT(2)
775+
resultt
776+
777+
override t1.AvgPoolReverse2D(originalInput, kernelSize, stride, padding) =
778+
match dtype with
779+
| Dtype.Bool | Dtype.Integral -> opNotSupported "AvgPoolReverse2D" dtype
780+
| _ ->
781+
let resultt = tt.avg_pool2d_backward(originalInput.TorchTensor, int64s kernelSize, strides=int64s stride, paddings=int64s padding)
782+
let result = t1.MakeLike(resultt, shape=originalInput.Shape)
783+
result
784+
785+
override t1.AvgPoolReverse3D(originalInput, kernelSize, stride, padding) =
786+
match dtype with
787+
| Dtype.Bool | Dtype.Integral -> opNotSupported "AvgPoolReverse3D" dtype
788+
| _ ->
789+
let resultt = tt.avg_pool3d_backward(originalInput.TorchTensor, int64s kernelSize, strides=int64s stride, paddings=int64s padding)
790+
let result = t1.MakeLike(resultt, shape=originalInput.Shape)
791+
result
792+
743793
override t.SumT2Dim0() =
744794
let result = tt.sum([| 0L |], ``type``= tt.Type)
745795
let resultShape = [|t.Shape.[1]|]

‎src/DiffSharp.Core/DiffSharp.AvgPool.fs

Lines changed: 132 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,132 @@
1+
namespace DiffSharp
2+
3+
[<AutoOpen>]
4+
module AvgPoolExtensions =
5+
6+
type Tensor with
7+
/// <summary>Applies a 1D average pooling over an input signal composed of several input planes, returning the max indices along with the outputs.</summary>
8+
/// <param name="kernelSize">The size of the window to take a max over.</param>
9+
/// <param name="stride">The stride of the window. Default value is kernelSize.</param>
10+
/// <param name="padding">The implicit zero padding to be added on both sides.</param>
11+
member a.avgpool1d(kernelSize:int, ?stride:int, ?padding:int(* , ?ceil_mode: bool, ?count_include_pad: bool *)) =
12+
let stride = defaultArg stride kernelSize
13+
let padding = defaultArg padding 0
14+
//let ceil_mode = defaultArg ceil_mode false
15+
//let count_include_pad= defaultArg count_include_pad true
16+
Shape.checkCanAvgpool1d a.dtype a.shape kernelSize stride padding |> ignore
17+
Tensor.Op
18+
{ new UnaryOp("avgpool1d") with
19+
member _.fRaw(a) = a.AvgPool1D(kernelSize, stride, padding(* , ceil_mode, count_include_pad *))
20+
member t.ad_dfda(a, ad, f) = ad.avgpool1d(kernelSize, stride, padding(* , ceil_mode, count_include_pad *))
21+
member _.fd_dfda(a, f, fd) = fd.avgpoolReverse1d(a, kernelSize, stride, padding(* , ceil_mode, count_include_pad *))
22+
}
23+
a
24+
25+
member internal a.avgpoolReverse1d(originalInput:Tensor, kernelSize:int, ?stride:int, ?padding:int(* , ?ceil_mode: bool, ?count_include_pad: bool *)) =
26+
let stride = defaultArg stride kernelSize
27+
let padding = defaultArg padding 0
28+
//let ceil_mode = defaultArg ceil_mode false
29+
//let count_include_pad= defaultArg count_include_pad true
30+
Tensor.Op
31+
{ new UnaryOp("avgpoolReverse1d") with
32+
member _.fRaw(a) = a.AvgPoolReverse1D(originalInput.primalRaw, kernelSize, stride, padding(* , ceil_mode, count_include_pad *))
33+
member _.ad_dfda(a, ad, f) = ad.avgpoolReverse1d(originalInput, kernelSize, stride, padding(* , ceil_mode, count_include_pad *))
34+
member _.fd_dfda(a, f, fd) = fd.avgpool1d(kernelSize, stride, padding(* , ceil_mode, count_include_pad *))
35+
}
36+
a
37+
38+
/// <summary>Applies a 1D average pooling over an input signal composed of several input planes, returning the max indices along with the outputs.</summary>
39+
/// <param name="kernelSize">The size of the window to take a max over.</param>
40+
/// <param name="stride">The stride of the window. Default value is kernelSize.</param>
41+
/// <param name="padding">The implicit zero padding to be added on both sides.</param>
42+
/// <param name="kernelSizes">The sizes of the window to take a max over.</param>
43+
/// <param name="strides">The strides of the window. Default value is kernelSize.</param>
44+
/// <param name="paddings">The implicit zero paddings to be added on both sides.</param>
45+
member a.avgpool2d(?kernelSize:int, ?stride:int, ?padding:int, ?kernelSizes:seq<int>, ?strides:seq<int>, ?paddings:seq<int>(* , ?ceil_mode: bool, ?count_include_pad: bool *)) =
46+
let kernelSizes, strides, paddings = Shape.resolve2dMaxPoolSizes kernelSize kernelSizes stride strides padding paddings
47+
//let ceil_mode = defaultArg ceil_mode false
48+
//let count_include_pad= defaultArg count_include_pad true
49+
Shape.checkCanAvgpool2d a.dtype a.shape kernelSizes strides paddings |> ignore
50+
Tensor.Op
51+
{ new UnaryOp("avgpool2d") with
52+
member _.fRaw(a) = a.AvgPool2D(kernelSizes, strides, paddings(* , ceil_mode, count_include_pad *))
53+
member _.ad_dfda(a, ad, f) = ad.avgpool2d(kernelSizes=kernelSizes, strides=strides, paddings=paddings(* , ceil_mode=ceil_mode, count_include_pad=count_include_pad *))
54+
member _.fd_dfda(a, f, fd) = fd.avgpoolReverse2d(a, kernelSizes=kernelSizes, strides=strides, paddings=paddings(* , ceil_mode=ceil_mode, count_include_pad=count_include_pad *))
55+
}
56+
a
57+
58+
member internal a.avgpoolReverse2d(originalInput:Tensor, ?kernelSize:int, ?stride:int, ?padding:int, ?kernelSizes:seq<int>, ?strides:seq<int>, ?paddings:seq<int>(* , ?ceil_mode: bool, ?count_include_pad: bool *)) =
59+
let kernelSizes, strides, paddings = Shape.resolve2dMaxPoolSizes kernelSize kernelSizes stride strides padding paddings
60+
//let ceil_mode = defaultArg ceil_mode false
61+
//let count_include_pad= defaultArg count_include_pad true
62+
Tensor.Op
63+
{ new UnaryOp("avgpoolReverse2d") with
64+
member _.fRaw(a) = a.AvgPoolReverse2D(originalInput.primalRaw, kernelSizes, strides, paddings(* , ceil_mode, count_include_pad *))
65+
member _.ad_dfda(a, ad, f) = ad.avgpoolReverse2d(originalInput, kernelSizes=kernelSizes, strides=strides, paddings=paddings(* , ceil_mode=ceil_mode, count_include_pad=count_include_pad *))
66+
member _.fd_dfda(a, f, fd) = fd.avgpool2d(kernelSizes=kernelSizes, strides=strides, paddings=paddings(* , ceil_mode=ceil_mode, count_include_pad=count_include_pad *))
67+
}
68+
a
69+
70+
/// <summary>Applies a 3D average pooling over an input signal composed of several input planes, returning the max indices along with the outputs.</summary>
71+
/// <param name="kernelSize">The size of the window to take a max over.</param>
72+
/// <param name="stride">The stride of the window. Default value is kernelSize.</param>
73+
/// <param name="padding">The implicit zero padding to be added on both sides.</param>
74+
/// <param name="kernelSizes">The sizes of the window to take a max over.</param>
75+
/// <param name="strides">The strides of the window. Default value is kernelSize.</param>
76+
/// <param name="paddings">The implicit zero paddings to be added on both sides.</param>
77+
member a.avgpool3d(?kernelSize:int, ?stride:int, ?padding:int, ?kernelSizes:seq<int>, ?strides:seq<int>, ?paddings:seq<int>(* , ?ceil_mode: bool, ?count_include_pad: bool *)) =
78+
let kernelSizes, strides, paddings = Shape.resolve3dMaxPoolSizes kernelSize kernelSizes stride strides padding paddings
79+
//let ceil_mode = defaultArg ceil_mode false
80+
//let count_include_pad= defaultArg count_include_pad true
81+
Shape.checkCanAvgpool3d a.dtype a.shape kernelSizes strides paddings |> ignore
82+
Tensor.Op
83+
{ new UnaryOp("avgpool3d") with
84+
member _.fRaw(a) = a.AvgPool3D(kernelSizes, strides, paddings(* , ceil_mode, count_include_pad *))
85+
member _.ad_dfda(a, ad, f) = ad.avgpool3d(kernelSizes=kernelSizes, strides=strides, paddings=paddings(* , ceil_mode=ceil_mode, count_include_pad=count_include_pad *))
86+
member _.fd_dfda(a, f, fd) = fd.avgpoolReverse3d(a, kernelSizes=kernelSizes, strides=strides, paddings=paddings(* , ceil_mode=ceil_mode, count_include_pad=count_include_pad *))
87+
}
88+
a
89+
90+
member internal a.avgpoolReverse3d(originalInput:Tensor, ?kernelSize:int, ?stride:int, ?padding:int, ?kernelSizes:seq<int>, ?strides:seq<int>, ?paddings:seq<int>(* , ?ceil_mode: bool, ?count_include_pad: bool *)) =
91+
let kernelSizes, strides, paddings = Shape.resolve3dMaxPoolSizes kernelSize kernelSizes stride strides padding paddings
92+
//let ceil_mode = defaultArg ceil_mode false
93+
//let count_include_pad= defaultArg count_include_pad true
94+
Tensor.Op
95+
{ new UnaryOp("avgpoolReverse3d") with
96+
member _.fRaw(a) = a.AvgPoolReverse3D(originalInput.primalRaw, kernelSizes, strides, paddings(* , ceil_mode, count_include_pad *))
97+
member _.ad_dfda(a, ad, f) = ad.avgpoolReverse3d(originalInput, kernelSizes=kernelSizes, strides=strides, paddings=paddings(* , ceil_mode=ceil_mode, count_include_pad=count_include_pad *))
98+
member _.fd_dfda(a, f, fd) = fd.avgpool3d(kernelSizes=kernelSizes, strides=strides, paddings=paddings(* , ceil_mode=ceil_mode, count_include_pad=count_include_pad *))
99+
}
100+
a
101+
102+
type dsharp with
103+
/// <summary>Applies a 1D average pooling over an input signal composed of several input planes, returning the max indices along with the outputs.</summary>
104+
/// <param name="input">The input tensor.</param>
105+
/// <param name="kernelSize">The size of the window to take a max over.</param>
106+
/// <param name="stride">The stride of the window. Default value is kernelSize.</param>
107+
/// <param name="padding">The implicit zero padding to be added on both sides.</param>
108+
static member avgpool1d(input: Tensor, kernelSize:int, ?stride:int, ?padding:int(* , ?ceil_mode: bool, ?count_include_pad: bool *)) =
109+
input.avgpool2d(kernelSize=kernelSize, ?stride=stride, ?padding=padding(* , ?ceil_mode=ceil_mode, ?count_include_pad=count_include_pad *))
110+
111+
/// <summary>Applies a 2D average pooling over an input signal composed of several input planes, returning the max indices along with the outputs.</summary>
112+
/// <param name="input">The input tensor.</param>
113+
/// <param name="kernelSize">The size of the window to take a max over.</param>
114+
/// <param name="stride">The stride of the window. Default value is kernelSize.</param>
115+
/// <param name="padding">The implicit zero padding to be added on both sides.</param>
116+
/// <param name="kernelSizes">The sizes of the window to take a max over.</param>
117+
/// <param name="strides">The strides of the window. Default value is kernelSize.</param>
118+
/// <param name="paddings">The implicit zero paddings to be added on both sides.</param>
119+
static member avgpool2d(input: Tensor, ?kernelSize:int, ?stride:int, ?padding:int, ?kernelSizes:seq<int>, ?strides:seq<int>, ?paddings:seq<int>(* , ?ceil_mode: bool, ?count_include_pad: bool *)) =
120+
input.avgpool2d(?kernelSize=kernelSize, ?stride=stride, ?padding=padding, ?kernelSizes=kernelSizes, ?strides=strides, ?paddings=paddings(* , ?ceil_mode=ceil_mode, ?count_include_pad=count_include_pad *))
121+
122+
/// <summary>Applies a 2D average pooling over an input signal composed of several input planes, returning the max indices along with the outputs.</summary>
123+
/// <param name="input">The input tensor.</param>
124+
/// <param name="kernelSize">The size of the window to take a max over.</param>
125+
/// <param name="stride">The stride of the window. Default value is kernelSize.</param>
126+
/// <param name="padding">The implicit zero padding to be added on both sides.</param>
127+
/// <param name="kernelSizes">The sizes of the window to take a max over.</param>
128+
/// <param name="strides">The strides of the window. Default value is kernelSize.</param>
129+
/// <param name="paddings">The implicit zero paddings to be added on both sides.</param>
130+
static member avgpool3d(input: Tensor, ?kernelSize:int, ?stride:int, ?padding:int, ?kernelSizes:seq<int>, ?strides:seq<int>, ?paddings:seq<int>(* , ?ceil_mode: bool, ?count_include_pad: bool *)) =
131+
input.avgpool3d(?kernelSize=kernelSize, ?stride=stride, ?padding=padding, ?kernelSizes=kernelSizes, ?strides=strides, ?paddings=paddings(* , ?ceil_mode=ceil_mode, ?count_include_pad=count_include_pad *))
132+

‎src/DiffSharp.Core/DiffSharp.Core.fsproj

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,7 @@
1818
<Compile Include="DiffSharp.Compose.fs" />
1919
<Compile Include="DiffSharp.Shorten.fs" />
2020
<Compile Include="DiffSharp.Numerical.fs" />
21+
<Compile Include="DiffSharp.AvgPool.fs" />
2122
<Compile Include="Distributions.fs" />
2223
<Compile Include="Data.fs" />
2324
<Compile Include="Model.fs" />

‎src/DiffSharp.Core/RawTensor.fs

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -454,6 +454,27 @@ type RawTensor() =
454454
/// Returns the 3D maxunpool of a tensor using the given indices for locations of maximums
455455
abstract MaxUnpool3D: indices: RawTensor * outputSize: int[] -> RawTensor
456456

457+
/// Returns the 1D avgpool of a tensor
458+
abstract AvgPool1D: kernelSize: int * stride: int * padding: int (* * ceil_mode: bool * count_include_pad: bool *) -> RawTensor
459+
460+
/// Returns the 2D avgpool of a tensor
461+
abstract AvgPool2D: kernelSize: int[] * stride: int[] * padding: int[] (* * ceil_mode: bool * count_include_pad: bool *) -> RawTensor
462+
463+
/// Returns the 2D avgpool of a tensor
464+
abstract AvgPool3D: kernelSize: int[] * stride: int[] * padding: int[] (* * ceil_mode: bool * count_include_pad: bool *) -> RawTensor
465+
466+
/// <summary>Returns the reverse mode of a 1D avgpool of a tensor, apportioning each part of the adjoint equally to each corresponding input</summary>
467+
/// <remarks>The originalInput parameter is only used for shape information</remarks>
468+
abstract AvgPoolReverse1D: originalInput: RawTensor * kernelSize: int * stride: int * padding: int (* * ceil_mode: bool * count_include_pad: bool *) -> RawTensor
469+
470+
/// <summary>Returns the reverse mode of a 2D avgpool of a tensor, apportioning each part of the adjoint equally to each corresponding input</summary>
471+
/// <remarks>The originalInput parameter is only used for shape information</remarks>
472+
abstract AvgPoolReverse2D: originalInput: RawTensor * kernelSize: int[] * stride: int[] * padding: int[] (* * ceil_mode: bool * count_include_pad: bool *) -> RawTensor
473+
474+
/// <summary>Returns the reverse mode of a 3D avgpool of a tensor, apportioning each part of the adjoint equally to each corresponding input</summary>
475+
/// <remarks>The originalInput parameter is only used for shape information</remarks>
476+
abstract AvgPoolReverse3D: originalInput: RawTensor * kernelSize: int[] * stride: int[] * padding: int[] (* * ceil_mode: bool * count_include_pad: bool *) -> RawTensor
477+
457478
/// Returns the 1D convolution of the tensor
458479
abstract Conv1D: kernel: RawTensor * stride: int * padding: int -> RawTensor
459480

0 commit comments

Comments
 (0)
0