Hugging Face's logo

Spaces:
zdou0830
/
desco
Sleeping

App Files Community
1
desco
File size: 4,645 Bytes 
749745d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
 
// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#pragma once
#include "cpu/vision.h"

#ifdef WITH_CUDA
#include "cuda/vision.h"
#endif


// Interface for Python
int deform_conv_forward(

    at::Tensor input, 

    at::Tensor weight,

    at::Tensor offset, 

    at::Tensor output,

    at::Tensor columns, 

    at::Tensor ones, 

    int kW,

    int kH, 

    int dW, 

    int dH, 

    int padW, 

    int padH,

    int dilationW, 

    int dilationH, 

    int group,

    int deformable_group, 

    int im2col_step)
{
  if (input.device().is_cuda()) {
#ifdef WITH_CUDA
    return deform_conv_forward_cuda(
        input, weight, offset, output, columns, ones,
        kW, kH, dW, dH, padW, padH, dilationW, dilationH,
        group, deformable_group, im2col_step
    );
#else
    AT_ERROR("Not compiled with GPU support");
#endif
  }
  AT_ERROR("Not implemented on the CPU");
}


int deform_conv_backward_input(

    at::Tensor input, 

    at::Tensor offset,

    at::Tensor gradOutput, 

    at::Tensor gradInput,

    at::Tensor gradOffset, 

    at::Tensor weight,

    at::Tensor columns, 

    int kW, 

    int kH, 

    int dW,

    int dH, 

    int padW, 

    int padH, 

    int dilationW,

    int dilationH, 

    int group,

    int deformable_group, 

    int im2col_step)
{
  if (input.device().is_cuda()) {
#ifdef WITH_CUDA
    return deform_conv_backward_input_cuda(
        input, offset, gradOutput, gradInput, gradOffset, weight, columns,
        kW, kH, dW, dH, padW, padH, dilationW, dilationH, 
        group, deformable_group, im2col_step
    );
#else
    AT_ERROR("Not compiled with GPU support");
#endif
  }
  AT_ERROR("Not implemented on the CPU");
}


int deform_conv_backward_parameters(

    at::Tensor input, 

    at::Tensor offset, 

    at::Tensor gradOutput,

    at::Tensor gradWeight,  // at::Tensor gradBias,

    at::Tensor columns, 

    at::Tensor ones, 

    int kW, 

    int kH, 

    int dW, 

    int dH,

    int padW, 

    int padH, 

    int dilationW, 

    int dilationH, 

    int group,

    int deformable_group, 

    float scale, 

    int im2col_step)
{
  if (input.device().is_cuda()) {
#ifdef WITH_CUDA
    return deform_conv_backward_parameters_cuda(
        input, offset, gradOutput, gradWeight, columns, ones,
        kW, kH, dW, dH, padW, padH, dilationW, dilationH,
        group, deformable_group, scale, im2col_step
    );
#else
    AT_ERROR("Not compiled with GPU support");
#endif
  }
  AT_ERROR("Not implemented on the CPU");
}


void modulated_deform_conv_forward(

    at::Tensor input, 

    at::Tensor weight, 

    at::Tensor bias, 

    at::Tensor ones,

    at::Tensor offset, 

    at::Tensor mask, 

    at::Tensor output, 

    at::Tensor columns,

    int kernel_h, 

    int kernel_w, 

    const int stride_h, 

    const int stride_w,

    const int pad_h, 

    const int pad_w, 

    const int dilation_h,

    const int dilation_w, 

    const int group, 

    const int deformable_group,

    const bool with_bias)
{
  if (input.device().is_cuda()) {
#ifdef WITH_CUDA
    return modulated_deform_conv_cuda_forward(
        input, weight, bias, ones, offset, mask, output, columns,
        kernel_h, kernel_w, stride_h, stride_w, 
        pad_h, pad_w, dilation_h, dilation_w,
        group, deformable_group, with_bias
    );
#else
    AT_ERROR("Not compiled with GPU support");
#endif
  }
  AT_ERROR("Not implemented on the CPU");
}


void modulated_deform_conv_backward(

    at::Tensor input, 

    at::Tensor weight, 

    at::Tensor bias, 

    at::Tensor ones,

    at::Tensor offset, 

    at::Tensor mask, 

    at::Tensor columns,

    at::Tensor grad_input, 

    at::Tensor grad_weight, 

    at::Tensor grad_bias,

    at::Tensor grad_offset, 

    at::Tensor grad_mask, 

    at::Tensor grad_output,

    int kernel_h, 

    int kernel_w, 

    int stride_h, 

    int stride_w, 

    int pad_h,

    int pad_w, 

    int dilation_h, 

    int dilation_w, 

    int group, 

    int deformable_group,

    const bool with_bias)
{
  if (input.device().is_cuda()) {
#ifdef WITH_CUDA
    return modulated_deform_conv_cuda_backward(
        input, weight, bias, ones, offset, mask, columns, 
        grad_input, grad_weight, grad_bias, grad_offset, grad_mask, grad_output,
        kernel_h, kernel_w, stride_h, stride_w, pad_h, pad_w, dilation_h, dilation_w,
        group, deformable_group, with_bias
    );
#else
    AT_ERROR("Not compiled with GPU support");
#endif
  }
  AT_ERROR("Not implemented on the CPU");
}