def __init__(self):
super(Net, self).__init__()
self.szp = SparseZeroPad2d(1)
self.bn = nn.BatchNorm1d(3)
self.cv1 = spconv.SparseConv2d(3, 3, 5, 5)
self.ss1 = SparseScale2d(5)
self.cv2 = spconv.SparseConv2d(3, 3, 5, 5)
self.ss2 = SparseScale2d(5)
self.mp = spconv.SparseMaxPool2d(2, 2)
self.td = spconv.ToDense()
self.net = spconv.SparseSequential(
SparseZeroPad2d(1),
nn.BatchNorm1d(3),
spconv.SparseConv2d(3, 32, 3, 1),
nn.ReLU(),
spconv.SparseConv2d(32, 64, 3, 1),
nn.ReLU(),
spconv.SparseMaxPool2d(2, 2),
spconv.ToDense(),
)
self.fc1 = nn.Linear(10816, 128)
self.fc2 = nn.Linear(128, 10)
self.dropout1 = nn.Dropout2d(0.25)
self.dropout2 = nn.Dropout2d(0.5)
def __init__(self):
super(Net, self).__init__()
self.net = spconv.SparseSequential(
nn.BatchNorm1d(1),
spconv.SparseConv2d(1, 32, 3, 1),
nn.ReLU(),
spconv.SparseConv2d(32, 64, 3, 1),
nn.ReLU(),
spconv.SparseMaxPool2d(2, 2),
spconv.ToDense(),
)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
self.dropout1 = nn.Dropout2d(0.25)
self.dropout2 = nn.Dropout2d(0.5)
def __init__(self, in_planes, pointwise_layers=2):
super(Pointwise2DForZ, self).__init__()
self.log = logging.getLogger(__name__)
layers = []
n_layers = pointwise_layers
if not isinstance(n_layers, int) or n_layers < 2:
raise ValueError("n_layers must be integer >= 2")
increment = int(round(float(in_planes) / float(n_layers - 1)))
out = in_planes
for i in range(n_layers):
if i == (n_layers - 1):
out = 1
elif i == 0:
out = in_planes
else:
out -= increment
self.log.debug(
"appending layer {0} -> {1} planes, kernel size of {2}, padding of {3}"
.format(in_planes, out, 1, 0))
layers.append(spconv.SparseConv2d(in_planes, out, 1, 1, 0))
layers.append(nn.BatchNorm1d(out))
layers.append(nn.ReLU())
in_planes = out
layers.append(spconv.ToDense())
self.network = spconv.SparseSequential(*layers)
def __init__(self,
in_planes,
kernel_size=3,
n_layers=2,
pointwise_layers=0,
pointwise_factor=0.8,
todense=True):
super(SparseConv2DForZ, self).__init__()
self.log = logging.getLogger(__name__)
layers = []
if pointwise_layers > 0:
if n_layers == 1:
raise ValueError(
"n_layers must be > 1 if using pointwise convolution")
increment = int(
round(
int(round(in_planes * pointwise_factor)) /
float(n_layers - 1)))
else:
increment = int(round(float(in_planes) / float(n_layers)))
if kernel_size % 2 != 1:
raise ValueError("Kernel size must be an odd integer")
if not isinstance(n_layers, int) or n_layers < 1:
raise ValueError("n_layers must be integer >= 1")
out = in_planes
reset_kernel = False
orig_kernel = kernel_size
for i in range(n_layers):
if i == (n_layers - 1):
out = 1
else:
out -= increment
if i == 0 and pointwise_layers > 0:
if pointwise_factor > 0:
out = int(round(pointwise_factor * in_planes))
pd = int((kernel_size - 1) / 2)
if pointwise_layers > 0:
pd = 0
kernel_size = 1
pointwise_layers -= 1
if pointwise_layers == 0:
reset_kernel = True
self.log.debug(
"appending layer {0} -> {1} planes, kernel size of {2}, padding of {3}"
.format(in_planes, out, kernel_size, pd))
layers.append(
spconv.SparseConv2d(in_planes, out, kernel_size, 1, pd))
if reset_kernel:
kernel_size = orig_kernel
reset_kernel = False
if i != (n_layers - 1):
layers.append(nn.BatchNorm1d(out))
layers.append(nn.ReLU())
in_planes = out
if kernel_size > 1:
kernel_size -= 2
if todense:
layers.append(spconv.ToDense())
self.network = spconv.SparseSequential(*layers)
def __init__(self):
super(PrecondNet, self).__init__()
self.layers = spconv.SparseSequential(
spconv.SparseConv2d(1, 64, 1),
nn.PReLU(),
spconv.SparseConv2d(64, 256, 2, padding=(1, 0)),
nn.PReLU(),
spconv.SparseConv2d(256, 512, 2, padding=(1, 0)),
nn.PReLU(),
spconv.SparseConv2d(512, 256, 2, padding=(0, 1)),
nn.PReLU(),
spconv.SparseConv2d(256, 64, 2, padding=(0, 1)),
nn.PReLU(),
spconv.SparseConv2d(64, 1, 1),
)
def _version3(self,
nin,
nout,
n,
size,
to_dense,
size_factor=3,
pad_factor=0.0,
stride_factor=1,
dil_factor=1,
expansion_factor=0,
n_expansion=0,
pointwise_factor=0,
dropout=0,
trainable_weights=False):
self.alg = []
self.out_size = size
self.dropout = dropout
self.log = logging.getLogger(__name__)
self.log.debug(
"Initializing convolution block with nin {0}, nout {1}, size {2}".
format(nin, nout, size))
self.ndim = len(size) - 1
if pointwise_factor > 0:
n_contraction = n - 1 - n_expansion
if n_contraction < 1:
raise ValueError("n_contraction too large, must be < n - 1")
else:
n_contraction = n - n_expansion
if n_contraction < 1:
raise ValueError("n_contraction too large, must be < n")
nframes = [nin]
if pointwise_factor > 0:
nframes.append(nin - int(floor((nin - nout) * pointwise_factor)))
if n_expansion > 0:
nframes += _get_frame_expansion(nframes[-1], expansion_factor,
n_expansion)
if n_contraction > 0:
nframes += _get_frame_contraction(nframes[-1], nout, n_contraction)
for i in range(n):
if pointwise_factor > 0:
if n > 1:
decay_factor = 1. - (i - 1) / (n - 1)
else:
decay_factor = 1.
else:
if n > 1:
decay_factor = 1. - i / (n - 1)
else:
decay_factor = 1.
fs = int(ceil(size_factor * decay_factor))
if fs < 2:
fs = 2
st = int(round(stride_factor * i / (n - 1)))
if st < 1:
st = 1
dil = int(round(dil_factor**i))
pd = int(
round(pad_factor * ((fs - 1) / 2.) * dil_factor *
decay_factor))
if i == 0 and pointwise_factor > 0:
pd, fs, dil, st = 0, 1, 1, 1
self.alg.append(
spconv.SparseConv2d(nframes[i], nframes[i + 1], fs, st, pd,
dil, 1, trainable_weights))
# self.alg.append(spconv.SubMConv2d(nframes[i], nframes[i + 1], fs, st, pd, dil, 1, trainable_weights))
self.log.debug(
"added pointwise convolution, frames: {0} -> {1}".format(
nframes[i], nframes[i + 1]))
else:
self.alg.append(
spconv.SparseConv2d(nframes[i], nframes[i + 1], fs, st, pd,
dil, 1, trainable_weights))
self.log.debug(
"added regular convolution, frames: {0} -> {1}".format(
nframes[i], nframes[i + 1]))
self.log.debug(
"filter size: {0}, stride: {1}, pad: {2}, dil: {3}".format(
fs, st, pd, dil))
self.alg.append(nn.BatchNorm1d(nframes[i + 1]))
self.alg.append(nn.ReLU())
if self.dropout:
self.alg.append(nn.Dropout(self.dropout))
arg_dict = {
DIM: self.ndim,
NIN: nframes[i],
NOUT: nframes[i + 1],
FS: [fs] * 4,
STR: [st] * 4,
PAD: [pd] * 4,
DIL: [dil] * 4
}
self.out_size = ModelValidation.calc_output_size(
arg_dict, self.out_size, "cur", "prev", self.ndim)
self.log.debug("Loop {0}, output size is {1}".format(
i, self.out_size))
if to_dense:
self.alg.append(spconv.ToDense())
self.func = spconv.SparseSequential(*self.alg)
def _version1(self,
nin,
nout,
n,
size,
to_dense,
size_factor=3,
pad_factor=0.0,
stride_factor=1,
dil_factor=1,
pointwise_factor=0,
depth_factor=0,
dropout=0,
trainable_weights=False):
assert (n > 0)
self.alg = []
self.out_size = size
self.dropout = dropout
self.log = logging.getLogger(__name__)
self.log.debug(
"Initializing convolution block with nin {0}, nout {1}, size {2}".
format(nin, nout, size))
self.ndim = len(size) - 1
if nin != nout:
if pointwise_factor > 0:
nframes = [
nin, nin - int(floor((nin - nout) * pointwise_factor))
]
if n > 1:
diff = float(nin - nout) / n
for i in range(n - 1):
val = int(floor(nframes[-1] - diff))
if val > nout:
nframes += [val]
else:
nframes += [nout]
elif depth_factor > 0:
nframes = [nin, int(nin * depth_factor)]
if n > 1:
diff = float(nframes[-1] - nout) / (n - 1)
for i in range(n - 1):
val = int(floor(nframes[-1] - diff))
if val > nout:
nframes += [val]
else:
nframes += [nout]
else:
diff = float(nin - nout) / n
nframes = [int(floor(nin - diff * i)) for i in range(n + 1)]
else:
nframes = [nin] * (n + 1)
for i in range(n):
if pointwise_factor > 0:
if n > 1:
decay_factor = 1. - (i - 1) / (n - 1)
else:
decay_factor = 1.
else:
if n > 1:
decay_factor = 1. - i / (n - 1)
else:
decay_factor = 1.
fs = int(floor(size_factor / (i + 1.)))
if fs < 2:
fs = 2
st = int(round(stride_factor * i / (n - 1)))
if st < 1:
st = 1
dil = int(round(dil_factor**i))
pd = int(round(pad_factor * (fs - 1) * dil_factor * decay_factor))
if i == 0 and pointwise_factor > 0:
pd, fs, dil, st = 0, 1, 1, 1
self.alg.append(
spconv.SparseConv2d(nframes[i], nframes[i + 1], fs, st, pd,
dil, 1, trainable_weights))
# self.alg.append(spconv.SubMConv2d(nframes[i], nframes[i + 1], fs, st, pd, dil, 1, trainable_weights))
self.log.debug(
"added pointwise convolution, frames: {0} -> {1}".format(
nframes[i], nframes[i + 1]))
else:
self.alg.append(
spconv.SparseConv2d(nframes[i], nframes[i + 1], fs, st, pd,
dil, 1, trainable_weights))
self.log.debug(
"added regular convolution, frames: {0} -> {1}".format(
nframes[i], nframes[i + 1]))
self.log.debug(
"filter size: {0}, stride: {1}, pad: {2}, dil: {3}".format(
fs, st, pd, dil))
self.alg.append(nn.BatchNorm1d(nframes[i + 1]))
self.alg.append(nn.ReLU())
if self.dropout:
self.alg.append(nn.Dropout(self.dropout))
arg_dict = {
DIM: self.ndim,
NIN: nframes[i],
NOUT: nframes[i + 1],
FS: [fs] * 4,
STR: [st] * 4,
PAD: [pd] * 4,
DIL: [dil] * 4
}
self.out_size = ModelValidation.calc_output_size(
arg_dict, self.out_size, "cur", "prev", self.ndim)
self.log.debug("Loop {0}, output size is {1}".format(
i, self.out_size))
if to_dense:
self.alg.append(spconv.ToDense())
self.func = spconv.SparseSequential(*self.alg)
def __init__(self,
nin,
nout,
n,
size,
expansion_factor=10.,
size_factor=3,
pad_factor=0.0,
stride_factor=1,
dil_factor=1,
dropout=0,
trainable_weights=False):
super(ExtractedFeatureConv, self).__init__()
assert (n > 1)
self.alg = []
self.out_size = size
self.dropout = dropout
self.log = logging.getLogger(__name__)
self.log.debug(
"Initializing convolution block with nin {0}, nout {1}, size {2}".
format(nin, nout, size))
self.ndim = len(size) - 1
nframes = [nin, int(round(nin * expansion_factor))]
diff = float(nframes[1] - nout) / (n - 1)
nframes += [int(floor(nframes[1] - diff * i)) for i in range(n - 1)]
for i in range(n):
decay_factor = 1. - (i - 1) / (n - 1)
fs = int(floor(size_factor / (i + 1.)))
if fs < 2:
fs = 2
st = int(round(stride_factor * i / (n - 1)))
if st < 1:
st = 1
dil = int(round(dil_factor**i))
pd = int(round(pad_factor * (fs - 1) * dil_factor * decay_factor))
self.alg.append(
spconv.SparseConv2d(nframes[i], nframes[i + 1], fs, st, pd,
dil, 1, trainable_weights))
self.log.debug(
"added regular convolution, frames: {0} -> {1}".format(
nframes[i], nframes[i + 1]))
self.log.debug(
"filter size: {0}, stride: {1}, pad: {2}, dil: {3}".format(
fs, st, pd, dil))
self.alg.append(nn.BatchNorm1d(nframes[i + 1]))
self.alg.append(nn.ReLU())
if self.dropout:
self.alg.append(nn.Dropout(self.dropout))
arg_dict = {
DIM: self.ndim,
NIN: nframes[i],
NOUT: nframes[i + 1],
FS: [fs] * 4,
STR: [st] * 4,
PAD: [pd] * 4,
DIL: [dil] * 4
}
self.out_size = ModelValidation.calc_output_size(
arg_dict, self.out_size, "cur", "prev", self.ndim)
self.log.debug("Loop {0}, output size is {1}".format(
i, self.out_size))
self.alg.append(spconv.ToDense())
self.network = spconv.SparseSequential(*self.alg)
def __init__(self,
in_planes,
out_planes=2,
kernel_size=3,
n_conv=1,
n_point=3,
conv_position=3,
pointwise_factor=0.8,
batchnorm=True):
"""
@type out_planes: int
"""
super(SparseConv2DForEZ, self).__init__()
self.log = logging.getLogger(__name__)
layers = []
n_layers = n_conv + n_point
if n_conv > 0:
if conv_position < 1:
raise ValueError("conv position must be >= 1 if n_conv > 0")
if n_point > 0:
if n_layers == 1:
raise ValueError(
"n_layers must be > 1 if using pointwise convolution")
increment = int(
round(
int(round(in_planes * pointwise_factor - out_planes)) /
float(n_layers - 1)))
else:
increment = int(
round(float(in_planes - out_planes) / float(n_layers)))
if kernel_size % 2 != 1:
raise ValueError("Kernel size must be an odd integer")
if not isinstance(n_layers, int) or n_layers < 1:
raise ValueError("n_layers must be integer >= 1")
out = copy(in_planes)
inp = copy(in_planes)
curr_kernel = copy(kernel_size)
if n_conv > 0:
conv_positions = [
i for i in range(conv_position - 1, conv_position - 1 + n_conv)
]
else:
conv_positions = []
for i in range(n_layers):
if i == (n_layers - 1):
out = copy(out_planes)
else:
out -= increment
if i == 0 and n_point > 0:
if pointwise_factor > 0:
out = int(round(pointwise_factor * in_planes))
if not i in conv_positions:
curr_kernel = 1
else:
curr_kernel = kernel_size - int((i + 1 - conv_position) * 2)
if curr_kernel < 3:
curr_kernel = 3
if curr_kernel % 2 == 0:
raise ValueError("error: kernel size is even")
pd = int((curr_kernel - 1) / 2)
self.log.debug(
"appending layer {0} -> {1} planes, kernel size of {2}, padding of {3}"
.format(inp, out, curr_kernel, pd))
layers.append(spconv.SparseConv2d(inp, out, curr_kernel, 1, pd))
if i != (n_layers - 1):
if batchnorm:
layers.append(nn.BatchNorm1d(out))
layers.append(nn.ReLU())
inp = out
layers.append(spconv.ToDense())
self.network = spconv.SparseSequential(*layers)