private static OneArgumentModule Convolution(
int nbFilters,
int[] filterShape,
int[] strides,
bool[] paddings,
int[] dilations,
bool bias,
bool[] sharing,
uint reductionRank = 1,
string name = ""
)
{
var kernelInitializer = C.GlorotUniformInitializer(
C.DefaultParamInitScale,
C.SentinelValueForInferParamInitRank,
C.SentinelValueForInferParamInitRank);
var rank = filterShape.Length;
int[] kernelShape = new int[rank + 2];
for (int i = 0; i < filterShape.Length; i++)
{
kernelShape[i] = filterShape[i];
}
kernelShape[rank] = NDShape.InferredDimension;
kernelShape[rank + 1] = nbFilters;
int[] biasShape = new int[rank + 1];
for (int i = 0; i < rank; i++)
{
biasShape[i] = 1;
}
biasShape[rank] = nbFilters;
Parameter w = new Parameter(kernelShape, DataType.Float, kernelInitializer);
Parameter b = bias ? new Parameter(biasShape, DataType.Float, 0) : null;
Function _Convolve(Variable x)
{
var r = C.Convolution(w, x, strides, new BoolVector(sharing), new BoolVector(paddings), dilations, reductionRank, 0, name);
if (bias)
{
r += b;
}
return(r);
}
return(_Convolve);
}
C.Function create_capsule_layer(C.Function inputs, int num_capsule, int dim_capsule, int routings, string name)
{
var inputs_shape = inputs.Output.Shape.Dimensions;
var input_num_capsule = inputs_shape[0];
var input_dim_capsule = inputs_shape[1];
var W = new C.Parameter(
new int[] { num_capsule, dim_capsule, input_num_capsule, input_dim_capsule },
C.DataType.Float,
CC.GlorotUniformInitializer(),
computeDevice,
name: "W");
inputs = CC.Reshape(inputs, new int[] { 1, 1, input_num_capsule, input_dim_capsule }); // [1, 1, 1152, 8])
var inputs_hat = CC.ElementTimes(W, inputs);
inputs_hat = CC.ReduceSum(inputs_hat, new C.Axis(3));
inputs_hat = CC.Squeeze(inputs_hat);
C.Function outputs = null;
var zeros = new C.Constant(new int[] { num_capsule, 1, input_num_capsule }, C.DataType.Float, 0, computeDevice);
var b = CC.Combine(new C.VariableVector()
{
zeros
});
for (int i = 0; i < routings; i++)
{
var c = CC.Softmax(b, new C.Axis(0));
var batch_dot_result = CC.ElementTimes(c, inputs_hat);
batch_dot_result = CC.ReduceSum(batch_dot_result, new C.Axis(2));
batch_dot_result = CC.Squeeze(batch_dot_result);
outputs = squash(batch_dot_result, name: $"squashed_{i}", axis: 1);
if (i < (routings - 1))
{
outputs = CC.Reshape(outputs, new int[] { num_capsule, dim_capsule, 1 });
batch_dot_result = CC.ElementTimes(outputs, inputs_hat);
batch_dot_result = CC.ReduceSum(batch_dot_result, new C.Axis(1));
b = CC.Plus(b, batch_dot_result);
}
}
outputs = CC.Combine(new C.VariableVector()
{
outputs
}, name);
return(outputs);
}
public static OneArgumentModule Linear(int outputSize, bool biase = true, string name = "")
{
var initializer = C.GlorotUniformInitializer(
C.DefaultParamInitScale,
C.SentinelValueForInferParamInitRank,
C.SentinelValueForInferParamInitRank);
Parameter w = new Parameter(new int[] { outputSize, NDShape.InferredDimension }, DataType.Float, initializer);
Parameter b = null;
if (biase)
{
b = new Parameter(new int[] { outputSize }, DataType.Float, 0);
}
return(x => biase?C.Times(w, x) + b : C.Times(w, x));
}
