Skip to content

Commit c40e177

Browse files
author
Глеб Брыкин
authored
Add files via upload
1 parent 5c5f4be commit c40e177

1 file changed

Lines changed: 192 additions & 0 deletions

File tree

‎Implementation/src/MKL/Ops/Backward/dAvgPool2d.cs‎

Lines changed: 192 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,192 @@
1+
//***************************************************************************************************
2+
//* (C) ColorfulSoft corp., 2020 - 2021. All rights reserved.
3+
//* The code is available under the Apache-2.0 license. Read the License for details.
4+
//***************************************************************************************************
5+
6+
//-> Latest commit: Brykin Gleb, 21.03.2021
7+
8+
using System;
9+
using System.Threading;
10+
using System.Threading.Tasks;
11+
using System.Runtime.CompilerServices;
12+
13+
namespace System
14+
{
15+
16+
namespace AI
17+
{
18+
19+
internal static partial class MKL
20+
{
21+
22+
#region avg_pool2d
23+
24+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
25+
public static void dAvgPool2d(Half[] dx, int[] x_shape, System.Tuple<int, int> kernel_size, System.Tuple<int, int> stride, System.Tuple<int, int> padding, System.Tuple<int, int> dilation, Half[] dy, int[] y_shape)
26+
{
27+
int x_width = x_shape[3];
28+
int x_height = x_shape[2];
29+
int x_channel = x_shape[1];
30+
int x_batch = x_shape[0];
31+
int y_width = y_shape[3];
32+
int y_height = y_shape[2];
33+
int y_channel = y_shape[1];
34+
int y_batch = y_shape[0];
35+
int stride_x = stride.Item2;
36+
int stride_y = stride.Item1;
37+
int padding_x = padding.Item2;
38+
int padding_y = padding.Item1;
39+
int dilation_x = dilation.Item2;
40+
int dilation_y = dilation.Item1;
41+
int kernel_width = kernel_size.Item2;
42+
int kernel_height = kernel_size.Item1;
43+
int norm = kernel_width * kernel_height;
44+
for(int b = 0; b < x_batch; b++)
45+
{
46+
Parallel.For(0, x_channel, (int c) =>
47+
{
48+
for(int ox = 0; ox < y_width; ox++)
49+
{
50+
var ix_ = ox * stride_x - padding_x;
51+
for(int oy = 0; oy < y_height; oy++)
52+
{
53+
var iy_ = oy * stride_y - padding_y;
54+
Half grad = dy[((oy * y_width + ox) * y_channel + c) * y_batch + b] / norm;
55+
for(int fx = 0; fx < kernel_width; fx++)
56+
{
57+
var ix = ix_ + fx * dilation_x;
58+
if((ix >= x_width) || (ix < 0))
59+
{
60+
continue;
61+
}
62+
for(int fy = 0; fy < kernel_height; fy++)
63+
{
64+
var iy = iy_ + fy * dilation_y;
65+
if((iy >= x_height) || (iy < 0))
66+
{
67+
continue;
68+
}
69+
dx[((iy * x_width + ix) * x_channel + c) * x_batch + b] += grad;
70+
}
71+
}
72+
}
73+
}
74+
});
75+
}
76+
}
77+
78+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
79+
public static void dAvgPool2d(float[] dx, int[] x_shape, System.Tuple<int, int> kernel_size, System.Tuple<int, int> stride, System.Tuple<int, int> padding, System.Tuple<int, int> dilation, float[] dy, int[] y_shape)
80+
{
81+
int x_width = x_shape[3];
82+
int x_height = x_shape[2];
83+
int x_channel = x_shape[1];
84+
int x_batch = x_shape[0];
85+
int y_width = y_shape[3];
86+
int y_height = y_shape[2];
87+
int y_channel = y_shape[1];
88+
int y_batch = y_shape[0];
89+
int stride_x = stride.Item2;
90+
int stride_y = stride.Item1;
91+
int padding_x = padding.Item2;
92+
int padding_y = padding.Item1;
93+
int dilation_x = dilation.Item2;
94+
int dilation_y = dilation.Item1;
95+
int kernel_width = kernel_size.Item2;
96+
int kernel_height = kernel_size.Item1;
97+
int norm = kernel_width * kernel_height;
98+
for(int b = 0; b < x_batch; b++)
99+
{
100+
Parallel.For(0, x_channel, (int c) =>
101+
{
102+
for(int ox = 0; ox < y_width; ox++)
103+
{
104+
var ix_ = ox * stride_x - padding_x;
105+
for(int oy = 0; oy < y_height; oy++)
106+
{
107+
var iy_ = oy * stride_y - padding_y;
108+
float grad = dy[((oy * y_width + ox) * y_channel + c) * y_batch + b] / norm;
109+
for(int fx = 0; fx < kernel_width; fx++)
110+
{
111+
var ix = ix_ + fx * dilation_x;
112+
if((ix >= x_width) || (ix < 0))
113+
{
114+
continue;
115+
}
116+
for(int fy = 0; fy < kernel_height; fy++)
117+
{
118+
var iy = iy_ + fy * dilation_y;
119+
if((iy >= x_height) || (iy < 0))
120+
{
121+
continue;
122+
}
123+
dx[((iy * x_width + ix) * x_channel + c) * x_batch + b] += grad;
124+
}
125+
}
126+
}
127+
}
128+
});
129+
}
130+
}
131+
132+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
133+
public static void dAvgPool2d(double[] dx, int[] x_shape, System.Tuple<int, int> kernel_size, System.Tuple<int, int> stride, System.Tuple<int, int> padding, System.Tuple<int, int> dilation, double[] dy, int[] y_shape)
134+
{
135+
int x_width = x_shape[3];
136+
int x_height = x_shape[2];
137+
int x_channel = x_shape[1];
138+
int x_batch = x_shape[0];
139+
int y_width = y_shape[3];
140+
int y_height = y_shape[2];
141+
int y_channel = y_shape[1];
142+
int y_batch = y_shape[0];
143+
int stride_x = stride.Item2;
144+
int stride_y = stride.Item1;
145+
int padding_x = padding.Item2;
146+
int padding_y = padding.Item1;
147+
int dilation_x = dilation.Item2;
148+
int dilation_y = dilation.Item1;
149+
int kernel_width = kernel_size.Item2;
150+
int kernel_height = kernel_size.Item1;
151+
int norm = kernel_width * kernel_height;
152+
for(int b = 0; b < x_batch; b++)
153+
{
154+
Parallel.For(0, x_channel, (int c) =>
155+
{
156+
for(int ox = 0; ox < y_width; ox++)
157+
{
158+
var ix_ = ox * stride_x - padding_x;
159+
for(int oy = 0; oy < y_height; oy++)
160+
{
161+
var iy_ = oy * stride_y - padding_y;
162+
double grad = dy[((oy * y_width + ox) * y_channel + c) * y_batch + b] / norm;
163+
for(int fx = 0; fx < kernel_width; fx++)
164+
{
165+
var ix = ix_ + fx * dilation_x;
166+
if((ix >= x_width) || (ix < 0))
167+
{
168+
continue;
169+
}
170+
for(int fy = 0; fy < kernel_height; fy++)
171+
{
172+
var iy = iy_ + fy * dilation_y;
173+
if((iy >= x_height) || (iy < 0))
174+
{
175+
continue;
176+
}
177+
dx[((iy * x_width + ix) * x_channel + c) * x_batch + b] += grad;
178+
}
179+
}
180+
}
181+
}
182+
});
183+
}
184+
}
185+
186+
#endregion
187+
188+
}
189+
190+
}
191+
192+
}

0 commit comments

Comments
 (0)