unet.py
5.6 KB
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
# Copyright 2023 Xiaomi Corp. (authors: Fangjun Kuang)
import torch
class UNet(torch.nn.Module):
def __init__(self):
super().__init__()
self.conv = torch.nn.Conv2d(2, 16, kernel_size=5, stride=(2, 2), padding=0)
self.bn = torch.nn.BatchNorm2d(
16, track_running_stats=True, eps=1e-3, momentum=0.01
)
#
self.conv1 = torch.nn.Conv2d(16, 32, kernel_size=5, stride=(2, 2), padding=0)
self.bn1 = torch.nn.BatchNorm2d(
32, track_running_stats=True, eps=1e-3, momentum=0.01
)
self.conv2 = torch.nn.Conv2d(32, 64, kernel_size=5, stride=(2, 2), padding=0)
self.bn2 = torch.nn.BatchNorm2d(
64, track_running_stats=True, eps=1e-3, momentum=0.01
)
self.conv3 = torch.nn.Conv2d(64, 128, kernel_size=5, stride=(2, 2), padding=0)
self.bn3 = torch.nn.BatchNorm2d(
128, track_running_stats=True, eps=1e-3, momentum=0.01
)
self.conv4 = torch.nn.Conv2d(128, 256, kernel_size=5, stride=(2, 2), padding=0)
self.bn4 = torch.nn.BatchNorm2d(
256, track_running_stats=True, eps=1e-3, momentum=0.01
)
self.conv5 = torch.nn.Conv2d(256, 512, kernel_size=5, stride=(2, 2), padding=0)
self.up1 = torch.nn.ConvTranspose2d(512, 256, kernel_size=5, stride=2)
self.bn5 = torch.nn.BatchNorm2d(
256, track_running_stats=True, eps=1e-3, momentum=0.01
)
self.up2 = torch.nn.ConvTranspose2d(512, 128, kernel_size=5, stride=2)
self.bn6 = torch.nn.BatchNorm2d(
128, track_running_stats=True, eps=1e-3, momentum=0.01
)
self.up3 = torch.nn.ConvTranspose2d(256, 64, kernel_size=5, stride=2)
self.bn7 = torch.nn.BatchNorm2d(
64, track_running_stats=True, eps=1e-3, momentum=0.01
)
self.up4 = torch.nn.ConvTranspose2d(128, 32, kernel_size=5, stride=2)
self.bn8 = torch.nn.BatchNorm2d(
32, track_running_stats=True, eps=1e-3, momentum=0.01
)
self.up5 = torch.nn.ConvTranspose2d(64, 16, kernel_size=5, stride=2)
self.bn9 = torch.nn.BatchNorm2d(
16, track_running_stats=True, eps=1e-3, momentum=0.01
)
self.up6 = torch.nn.ConvTranspose2d(32, 1, kernel_size=5, stride=2)
self.bn10 = torch.nn.BatchNorm2d(
1, track_running_stats=True, eps=1e-3, momentum=0.01
)
# output logit is False, so we need self.up7
self.up7 = torch.nn.Conv2d(1, 2, kernel_size=4, dilation=2, padding=3)
def forward(self, x):
"""
Args:
x: (num_audio_channels, num_splits, 512, 1024)
Returns:
y: (num_audio_channels, num_splits, 512, 1024)
"""
x = x.permute(1, 0, 2, 3)
in_x = x
# in_x is (3, 2, 512, 1024) = (T, 2, 512, 1024)
x = torch.nn.functional.pad(x, (1, 2, 1, 2), "constant", 0)
conv1 = self.conv(x)
batch1 = self.bn(conv1)
rel1 = torch.nn.functional.leaky_relu(batch1, negative_slope=0.2)
x = torch.nn.functional.pad(rel1, (1, 2, 1, 2), "constant", 0)
conv2 = self.conv1(x) # (3, 32, 128, 256)
batch2 = self.bn1(conv2)
rel2 = torch.nn.functional.leaky_relu(
batch2, negative_slope=0.2
) # (3, 32, 128, 256)
x = torch.nn.functional.pad(rel2, (1, 2, 1, 2), "constant", 0)
conv3 = self.conv2(x) # (3, 64, 64, 128)
batch3 = self.bn2(conv3)
rel3 = torch.nn.functional.leaky_relu(
batch3, negative_slope=0.2
) # (3, 64, 64, 128)
x = torch.nn.functional.pad(rel3, (1, 2, 1, 2), "constant", 0)
conv4 = self.conv3(x) # (3, 128, 32, 64)
batch4 = self.bn3(conv4)
rel4 = torch.nn.functional.leaky_relu(
batch4, negative_slope=0.2
) # (3, 128, 32, 64)
x = torch.nn.functional.pad(rel4, (1, 2, 1, 2), "constant", 0)
conv5 = self.conv4(x) # (3, 256, 16, 32)
batch5 = self.bn4(conv5)
rel6 = torch.nn.functional.leaky_relu(
batch5, negative_slope=0.2
) # (3, 256, 16, 32)
x = torch.nn.functional.pad(rel6, (1, 2, 1, 2), "constant", 0)
conv6 = self.conv5(x) # (3, 512, 8, 16)
up1 = self.up1(conv6)
up1 = up1[:, :, 1:-2, 1:-2] # (3, 256, 16, 32)
up1 = torch.nn.functional.relu(up1)
batch7 = self.bn5(up1)
merge1 = torch.cat([conv5, batch7], axis=1) # (3, 512, 16, 32)
up2 = self.up2(merge1)
up2 = up2[:, :, 1:-2, 1:-2]
up2 = torch.nn.functional.relu(up2)
batch8 = self.bn6(up2)
merge2 = torch.cat([conv4, batch8], axis=1) # (3, 256, 32, 64)
up3 = self.up3(merge2)
up3 = up3[:, :, 1:-2, 1:-2]
up3 = torch.nn.functional.relu(up3)
batch9 = self.bn7(up3)
merge3 = torch.cat([conv3, batch9], axis=1) # (3, 128, 64, 128)
up4 = self.up4(merge3)
up4 = up4[:, :, 1:-2, 1:-2]
up4 = torch.nn.functional.relu(up4)
batch10 = self.bn8(up4)
merge4 = torch.cat([conv2, batch10], axis=1) # (3, 64, 128, 256)
up5 = self.up5(merge4)
up5 = up5[:, :, 1:-2, 1:-2]
up5 = torch.nn.functional.relu(up5)
batch11 = self.bn9(up5)
merge5 = torch.cat([conv1, batch11], axis=1) # (3, 32, 256, 512)
up6 = self.up6(merge5)
up6 = up6[:, :, 1:-2, 1:-2]
up6 = torch.nn.functional.relu(up6)
batch12 = self.bn10(up6) # (3, 1, 512, 1024) = (T, 1, 512, 1024)
up7 = self.up7(batch12)
up7 = torch.sigmoid(up7) # (3, 2, 512, 1024)
ans = up7 * in_x
return ans.permute(1, 0, 2, 3)