def __init__(self, input_shape, num_features=[12], itype='float64',use_conv=True,version='linear'):
self.num_features, self.itype = num_features, itype
nsite=np.prod(input_shape)
eta=0.2
super(WangLei, self).__init__(itype, do_shape_check=True)
stride = nsite
if not use_conv:
num_feature_hidden=num_features[0]*nsite
self.layers.append(Linear(input_shape, itype, weight=eta*typed_randn(self.itype, (num_feature_hidden, nsite)),
bias=eta*typed_randn(self.itype, (num_feature_hidden,))))
else:
self.layers.append(functions.Reshape(input_shape, itype=itype, output_shape=(1,)+input_shape))
self.add_layer(SPConv, weight=eta*typed_randn(self.itype, (self.num_features[0], 1, nsite)),
bias=eta*typed_randn(self.itype, (num_features[0],)), boundary='P', strides=(stride,))
self.add_layer(functions.Reshape, output_shape=(num_features[0], nsite//stride))
self.add_layer(functions.Log2cosh)
self.add_layer(functions.Sum, axis=-1)
self.add_layer(functions.Exp)
if version=='const-linear':
self.add_layer(Linear, weight=np.array([[-1,-1,1,1]],itype=itype, order='F'),
bias=np.zeros((1,),itype=itype),var_mask=(0,0))
elif version=='linear':
for nfi, nfo in zip(num_features, num_features[1:]+[1]):
self.add_layer(Linear, weight=eta*typed_randn(self.itype, (nfo, nfi)),
bias=eta*typed_randn(self.itype, (nfo,)),var_mask=(1,1))
elif version=='rbm':
pass
else:
raise ValueError('version %s not exist'%version)
self.add_layer(functions.Reshape, output_shape=())
def __init__(self,
input_shape,
num_feature_hidden,
itype='complex128',
sign_func=None):
self.num_feature_hidden, self.itype = num_feature_hidden, itype
nsite = np.prod(input_shape)
eta = 0.1
super(RBM, self).__init__(itype, do_shape_check=False)
self.layers.append(
functions.Reshape(input_shape,
itype=itype,
output_shape=(1, ) + input_shape))
self.add_layer(
SPConv,
weight=eta * typed_randn(self.itype,
(self.num_feature_hidden, 1, nsite)),
bias=eta * typed_randn(self.itype, (num_feature_hidden, )),
boundary='P')
self.add_layer(functions.Log2cosh)
self.add_layer(functions.Reshape,
output_shape=(self.num_feature_hidden * nsite, ))
self.add_layer(functions.Sum, axis=0)
self.add_layer(functions.Exp)
self._get_sign = sign_func
def __init__(self, input_shape, num_feature_hidden, with_linear=False, use_msr=False, theta_period=2):
self.num_feature_hidden = num_feature_hidden
self.use_msr = use_msr
dtype = 'float64'
self.with_linear = with_linear
nsite=np.prod(input_shape)
eta=0.1
super(Roger, self).__init__(dtype, do_shape_check=False)
self.layers.append(functions.Reshape(input_shape, itype=dtype, output_shape=(1,)+input_shape))
self.add_layer(SPConv, weight=eta*typed_randn(dtype, (self.num_feature_hidden, 1, nsite)),
bias=eta*typed_randn(dtype, (num_feature_hidden,)), boundary='P')
self.add_layer(functions.Log2cosh)
self.add_layer(functions.Reshape, output_shape=(num_feature_hidden, nsite) if with_linear else (num_feature_hidden*nsite,))
self.add_layer(functions.Sum, axis=-1)
self.add_layer(functions.Exp)
if with_linear:
self.add_layer(Linear, weight=eta*typed_randn(dtype, (128, self.num_feature_hidden)),
bias=0*typed_randn(dtype, (128,)))
self.add_layer(functions.ReLU)
self.add_layer(Linear, weight=eta*typed_randn(dtype, (64, 128)),
bias=0*typed_randn(dtype, (64,)))
self.add_layer(functions.ReLU)
self.add_layer(Linear, weight=eta*typed_randn(dtype, (32, 64)),
bias=0*typed_randn(dtype, (32,)))
self.add_layer(functions.ReLU)
self.add_layer(Linear, weight=eta*typed_randn(dtype, (1, 32)),
bias=0*typed_randn(dtype, (1,)))
self.add_layer(functions.Reshape, output_shape=())
if use_msr and theta_period!=2:
raise ValueError()
self.thnn = PSNN(input_shape, period=theta_period, batch_wise=False, output_mode='theta', use_msr=use_msr)
def __init__(self, input_shape, NF=4, K=2, num_features=[12], eta0=0.2, eta1=0.2,
itype='complex128',version='linear', dtype0='complex128', dtype1='complex128', stride=None):
self.num_features = num_features
if stride is None:
if any([n%4!=0 for n in input_shape]):
stride=2
else:
stride=1
self.stride = stride
nsite=np.prod(input_shape)
eta=eta0
super(WangLei4, self).__init__()
D = len(input_shape)
ishape = (1,)+input_shape
self.layers.append(functions.Reshape(input_shape, itype=itype, output_shape=ishape))
eta=eta1
dtype = dtype0
self.add_layer(functions.Log)
#self.add_layer(SPConv, weight=eta*typed_randn(self.itype, (NF,1)+(K,)*D),
# bias=eta*typed_randn(self.itype, (NF,)), boundary='P', strides=(stride,)*D)
self.add_layer(SPConv, weight=eta*typed_randn(dtype, (NF,1)+(K,)*D),
bias=eta*typed_randn(dtype, (NF,)), boundary='P', strides=(stride,)*D)
self.add_layer(functions.Exp)
dtype = dtype1
if version=='linear':
self.add_layer(functions.Reshape, output_shape=(np.prod(self.layers[-1].output_shape),))
self.add_layer(Linear, weight=eta*typed_randn(dtype, (num_features[0], self.layers[-1].output_shape[-1])),
bias=eta*typed_randn(dtype, (num_features[0],)),var_mask=(1,1))
elif version=='conv':
stride= 1
imgsize = self.layers[-1].output_shape[-D:]
self.add_layer(SPConv, weight=eta*typed_randn(dtype, (self.num_features[0], NF)+imgsize),
bias=eta*typed_randn(dtype, (num_features[0],)), boundary='P', strides=(stride,)*D)
self.add_layer(functions.Reshape, output_shape=(num_features[0], np.prod(imgsize)//stride**D))
self.add_layer(functions.Power,order=3)
#self.add_layer(functions.Log2cosh)
self.add_layer(functions.Mean, axis=-1)
if version=='const-linear':
self.add_layer(Linear, weight=np.array([[-1,-1,1,1]],dtype=itype, order='F'),
bias=np.zeros((1,),dtype=itype),var_mask=(0,0))
elif version=='linear' or version=='conv':
for i,(nfi, nfo) in enumerate(zip(num_features, num_features[1:]+[1])):
if i!=0:
self.add_layer(functions.ReLU)
self.add_layer(Linear, weight=eta*typed_randn(dtype, (nfo, nfi)),
bias=eta*typed_randn(dtype, (nfo,)),var_mask=(1,1))
elif version=='rbm':
pass
else:
raise ValueError('version %s not exist'%version)
self.add_layer(functions.Reshape, output_shape=())
def __init__(self,
input_shape,
num_feature_hidden,
mlp_shape,
use_msr=False,
theta_period=2):
self.num_feature_hidden = num_feature_hidden
self.use_msr = use_msr
dtype = 'float64'
nsite = np.prod(input_shape)
eta = 0.1
super(RTheta_MLP_EXP, self).__init__(dtype, do_shape_check=False)
self.layers.append(
functions.Reshape(input_shape,
itype=dtype,
output_shape=(1, ) + input_shape))
self.add_layer(SPConv,
weight=eta *
typed_randn(dtype, (self.num_feature_hidden, 1, nsite)),
bias=eta * typed_randn(dtype, (num_feature_hidden, )),
boundary='P')
self.add_layer(functions.Log2cosh)
self.add_layer(functions.Reshape,
output_shape=(num_feature_hidden, nsite))
self.add_layer(functions.Sum, axis=-1)
self.add_layer(functions.Exp)
self.add_layer(Linear,
weight=eta *
typed_randn(dtype,
(mlp_shape[0], self.num_feature_hidden)),
bias=0 * typed_randn(dtype, (mlp_shape[0], )))
self.add_layer(functions.ReLU)
for i in range(len(mlp_shape) - 1):
self.add_layer(Linear,
weight=eta *
typed_randn(dtype,
(mlp_shape[i + 1], mlp_shape[i])),
bias=0.1 * typed_randn(dtype, (mlp_shape[i + 1], )))
self.add_layer(functions.ReLU)
self.add_layer(Linear,
weight=eta * typed_randn(dtype, (1, mlp_shape[-1])),
bias=0 * typed_randn(dtype, (1, )))
# self.add_layer(functions.ReLU)
self.add_layer(functions.Exp)
self.add_layer(functions.Reshape, output_shape=())
if use_msr and theta_period != 2:
raise ValueError()
self.thnn = PSNN(input_shape,
period=theta_period,
batch_wise=False,
output_mode='theta',
use_msr=use_msr)
def __init__(self,
input_shape,
num_feature_hidden,
with_linear=False,
use_msr=False,
theta_period=2,
itype='float64'):
self.num_feature_hidden = num_feature_hidden
self.use_msr = use_msr
self.with_linear = with_linear
nsite = np.prod(input_shape)
eta = 0.1
super(WangLei2, self).__init__(itype, do_shape_check=False)
self.layers.append(
functions.Reshape(input_shape,
itype=itype,
output_shape=(1, ) + input_shape))
self.add_layer(SPConv,
weight=eta *
typed_randn(itype, (self.num_feature_hidden, 1, nsite)),
bias=eta * typed_randn(itype, (num_feature_hidden, )),
boundary='P')
self.add_layer(functions.Log2cosh)
self.add_layer(functions.Reshape,
output_shape=(num_feature_hidden,
nsite) if with_linear else
(num_feature_hidden * nsite, ))
self.add_layer(functions.Sum, axis=-1)
self.add_layer(functions.Exp)
if with_linear:
#self.add_layer(Linear, weight=eta*typed_randn(itype, (1, self.num_feature_hidden)),
# bias=0*typed_randn(itype, (1,)))
self.add_layer(Linear,
weight=np.array([[1, 1, -1, -1]], dtype=itype),
bias=0 * typed_randn(itype, (1, )),
var_mask=(0, 0))
self.add_layer(functions.Reshape, output_shape=())
if use_msr and theta_period != 2:
raise ValueError()
if use_msr:
self.thnn = psnn_msr(nsite=input_shape[0])
else:
self.thnn = PSNN(input_shape,
period=theta_period,
batch_wise=False,
output_mode='theta')
def __init__(self, input_shape, nfs, itype='complex128'):
assert (len(nfs) == 4)
eta = 1
nsite = np.prod(input_shape)
self.nfs, self.itype = nfs, itype
DIM = len(input_shape)
POOLING_MODE = 'max-abs'
super(ConvWF, self).__init__(itype=itype, do_shape_check=False)
self.layers.append(
functions.Reshape(input_shape,
itype=itype,
output_shape=(1, ) + input_shape))
self.add_layer(SPConv,
weight=typed_randn(itype,
(self.nfs[0], 1, nsite)) * eta,
bias=typed_randn(itype, (nfs[0], )) * eta,
boundary='P')
self.add_layer(functions.Pooling,
kernel_shape=(2, ) * DIM,
mode=POOLING_MODE)
self.add_layer(functions.ReLU)
self.add_layer(
SPConv,
weight=typed_randn(itype, (self.nfs[1], self.nfs[0], nsite)) * eta,
bias=typed_randn(itype, (nfs[1], )) * eta,
boundary='P')
self.add_layer(functions.Pooling,
kernel_shape=(2, ) * DIM,
mode=POOLING_MODE)
self.add_layer(functions.ReLU)
nf1_ = np.prod(self.layers[-1].output_shape)
self.add_layer(functions.Reshape, output_shape=(nf1_, ))
self.add_layer(Apdot,
weight=typed_randn(itype, (nfs[3], nfs[1])) * eta,
bias=typed_randn(itype, (nfs[3], )) * eta)
self.add_layer(Linear,
weight=typed_randn(itype, (1, nfs[3])) * eta,
bias=typed_randn(itype, (1, )) * eta)
self.add_layer(functions.Reshape, output_shape=())
self._shapes = None
def __init__(self, input_shape, nonlinear_list, powerlist=None, num_features=[4,4,4], eta0=0.2, eta1=0.2, NP=1, NC=1, K=None,\
itype='complex128',dtype0='complex128', dtype1='complex128', momentum=0., isym = False,
usesum=False,poly_order=10, do_BN=False,is_unitary=False, **kwargs):
if K is None:
K = np.prod(input_shape)
self.num_features = num_features
self.do_BN = do_BN
self.poly_order = poly_order
self.eta0, self.eta1 = eta0, eta1
self.isym = isym
nsite = np.prod(input_shape)
D = len(input_shape)
ishape = input_shape
def _is_unitary(inl):
if is_unitary is True:
return True
elif is_unitary is False:
return False
else:
return is_unitary[inl]
super(WangLei6, self).__init__(**kwargs)
# preprocessing
if powerlist is not None:
plnn = ParallelNN(axis=0)
for power in powerlist:
plnn.layers.append(
functions.ConvProd(ishape,
itype,
powers=power,
boundary='P',
strides=(1, ) * D))
if isym:
plnn.layers.append(
ANN(layers=[
functions.Reverse(ishape, itype, axis=-1),
functions.ConvProd(ishape,
itype,
powers=power,
boundary='P',
strides=(1, ) * D)
]))
self.layers.append(plnn)
nfo = len(plnn.layers)
else:
nfo = 1
inl = -1
# product layers.
dtype = dtype0
eta = eta0
if NP != 0: self.add_layer(functions.Log, otype='complex128')
for inl in range(NP):
nfi, nfo = nfo, num_features[inl]
self.add_layer(SPConv,
weight=eta * typed_uniform(dtype,
(nfo, nfi) + (K, ) * D),
bias=eta * typed_uniform(dtype, (nfo, )),
boundary='P',
strides=(1, ) * D,
is_unitary=_is_unitary(inl))
self.use_nonlinear(nonlinear_list[inl])
if NP != 0: self.add_layer(functions.Exp)
if self.num_layers == 0:
self.layers.append(
functions.Reshape(ishape,
itype=itype,
output_shape=(1, ) + ishape))
# convolution layers.
eta = eta1
dtype = self.layers[-1].otype
for nfi, nfo in zip([nfo] + num_features[NP:NP + NC - 1],
num_features[NP:NP + NC]):
inl = inl + 1
self.add_layer(SPConv,
weight=eta *
typed_uniform(dtype, (nfo, nfi) + input_shape),
bias=eta * typed_uniform(dtype, (nfo, )),
boundary='P',
strides=(1, ) * D,
is_unitary=_is_unitary(inl))
self.use_nonlinear(nonlinear_list[inl])
self.add_layer(functions.Filter, axes=(-1, ), momentum=momentum)
inl = inl + 1
self.use_nonlinear(nonlinear_list[inl])
# linear layers.
if usesum:
self.add_layer(functions.Mean, axis=-1)
inl = inl + 1
self.use_nonlinear(nonlinear_list[inl])
else:
for i, (nfi, nfo) in enumerate(
zip(num_features[NP + NC - 1:],
num_features[NP + NC:] + [1])):
self.add_layer(Linear,
weight=eta * typed_uniform(dtype, (nfo, nfi)),
bias=eta * typed_uniform(dtype, (nfo, )),
var_mask=(1, 1),
is_unitary=_is_unitary(inl))
if do_BN:
self.add_layer(functions.BatchNorm,
axis=None,
label='BN-%s' % i)
self.add_layer(pfunctions.Poly,
params=np.array([0, 1.], dtype=dtype1),
kernel='polynomial',
factorial_rescale=True)
inl = inl + 1
self.use_nonlinear(nonlinear_list[inl])
print(check_numdiff(self))
def __init__(self,
input_shape,
itype,
powerlist,
num_features=[12],
fixbias=False,
version='conv',
stride=1,
eta=0.2,
usesum=False,
nonlinear='x^3',
momentum=0.,
poly_order=10,
with_exp=False,
factorial_rescale=False,
nonlinear_mask=[False, False],
**kwargs):
self.num_features = num_features
nsite = np.prod(input_shape)
D = len(input_shape)
ishape = (1, ) + input_shape
super(WangLei3, self).__init__(layers=[
functions.Reshape(input_shape, itype=itype, output_shape=ishape)
],
**kwargs)
NF = len(powerlist)
plnn = ParallelNN(axis=1)
for power in powerlist:
plnn.layers.append(
functions.ConvProd(input_shape=ishape,
itype=itype,
powers=power,
boundary='P',
strides=(stride, ) * D))
self.layers.append(plnn)
if version == 'linear':
self.add_layer(functions.Reshape,
output_shape=(np.prod(
self.layers[-1].output_shape), ))
self.add_layer(
Linear,
weight=eta * typed_uniform(
self.itype,
(num_features[0], self.layers[-1].output_shape[-1])),
bias=(0 if fixbias else eta) *
typed_uniform(self.itype, (num_features[0], )),
var_mask=(1, 0 if fixbias else 1))
elif version == 'conv':
stride = 1
imgsize = self.layers[-1].output_shape[-D:]
self.add_layer(SPConv,
weight=eta *
typed_uniform(self.itype,
(self.num_features[0], NF) + imgsize),
bias=(0 if fixbias else eta) *
typed_uniform(self.itype, (num_features[0], )),
boundary='P',
strides=(stride, ) * D,
var_mask=(1, 0 if fixbias else 1))
self.add_layer(functions.Reshape,
output_shape=(num_features[0],
np.prod(imgsize) // stride**D))
if nonlinear == 'x^3':
self.add_layer(functions.Power, order=3)
elif nonlinear == 'x^5':
self.add_layer(functions.Power, order=5)
elif nonlinear == 'relu':
self.add_layer(functions.ReLU)
elif nonlinear == 'sinh':
self.add_layer(functions.Sinh)
elif nonlinear == 'log2cosh':
self.add_layer(functions.Log2cosh)
elif nonlinear == 'mobius':
self.add_layer(layers.Mobius,
params=np.array([0, 1, 1e20], dtype=itype),
var_mask=[True, True, False])
elif nonlinear == 'softmax':
self.add_layer(functions.SoftMax, axis=-1)
elif nonlinear == 'sin':
self.add_layer(functions.Sin)
elif nonlinear in layers.Poly.kernel_dict:
self.add_layer(layers.Poly,
params=eta *
typed_uniform(itype, (poly_order, )),
kernel=nonlinear,
factorial_rescale=factorial_rescale)
else:
raise Exception
#self.add_layer(functions.Filter, axes=(-1,), momentum=momentum)
self.add_layer(functions.Mean, axis=-1)
if nonlinear_mask[0]:
self.add_layer(functions.Sinh,
params=eta *
typed_uniform(itype, (poly_order, )),
kernel='legendre',
factorial_rescale=factorial_rescale)
#self.add_layer(layers.Poly, params=eta*typed_uniform(itype, (poly_order,)), kernel='legendre', factorial_rescale=factorial_rescale)
if version == 'const-linear':
self.add_layer(Linear,
weight=np.array([[-1, -1, 1, 1]],
dtype=itype,
order='F'),
bias=np.zeros((1, ), dtype=itype),
var_mask=(0, 0))
elif version == 'linear' or version == 'conv':
if usesum:
self.add_layer(functions.Mean, axis=-1)
else:
for i, (nfi, nfo) in enumerate(
zip(num_features, num_features[1:] + [1])):
self.add_layer(Linear,
weight=eta *
typed_uniform(self.itype, (nfo, nfi)),
bias=(0 if fixbias else eta) *
typed_uniform(self.itype, (nfo, )),
var_mask=(1, 0 if fixbias else 1))
#self.add_layer(layers.Poly, params=eta*typed_uniform(itype,(10,)))
elif version == 'rbm':
pass
else:
raise ValueError('version %s not exist' % version)
if with_exp:
self.add_layer(functions.Exp)
self.add_layer(functions.Reshape, output_shape=())
if nonlinear_mask[1]:
self.add_layer(layers.Poly,
params=eta * typed_uniform(itype, (poly_order, )),
kernel='legendre',
factorial_rescale=factorial_rescale)
def __init__(self,
input_shape,
period,
kernel='cos',
nf=4,
batch_wise=False,
output_mode='theta',
use_msr=False):
self.period = period
self.batch_wise = batch_wise
if batch_wise:
num_batch = input_shape[0]
site_shape = input_shape[1:]
else:
num_batch = 1
site_shape = input_shape
nsite = np.prod(site_shape)
eta = 0.1
super(PSNN, self).__init__('float64' if output_mode ==
'theta' else 'complex128')
dtype = 'float64'
self.layers.append(
functions.Reshape(input_shape,
itype='float64',
output_shape=(num_batch, 1) + site_shape))
if use_msr:
weight = np.array([[[np.pi / 2, 0]]])
bias = np.array([np.pi / 2])
var_mask = (0, 0)
else:
weight = eta * typed_randn('float64', (nf, 1, nsite))
bias = eta * typed_randn('float64', (nf, ))
var_mask = (1, 1)
self.add_layer(SPConv,
weight=weight,
bias=bias,
strides=(period, ),
boundary='P',
var_mask=var_mask)
self.add_layer(functions.Reshape,
output_shape=(num_batch, nf, nsite // period))
#self.add_layer(functions.Cos)
self.add_layer(functions.Sum, axis=-1)
self.add_layer(functions.ReLU)
self.add_layer(Linear,
weight=eta * typed_randn(dtype, (1, nf)),
bias=0 * typed_randn(dtype, (1, )))
if output_mode != 'theta':
if kernel == 'exp':
self.add_layer(functions.TypeCast, otype='complex128')
self.add_layer(functions.Mul, alpha=1j)
self.add_layer(functions.Exp)
self.add_layer(functions.TypeCast, otype='float64')
elif kernel == 'cos':
self.add_layer(functions.Cos)
if output_mode == 'loss':
self.add_layer(functions.SquareLoss)
self.add_layer(functions.Mean, axis=0)
if not batch_wise:
self.add_layer(functions.Reshape, output_shape=())
def __init__(self,
input_shape,
num_features1=[12],
num_features2=[],
itype='float64',
version='basic',
eta=0.2,
use_conv=False,
preprocessing=False):
self.num_features1, self.num_features2 = num_features1, num_features2
nsite = np.prod(input_shape)
super(CaiZi, self).__init__()
# create amplitude network
if not preprocessing:
net1 = ANN(layers=[
functions.Reshape(
input_shape, itype=itype, output_shape=(1, ) + input_shape)
])
NF = 1
else:
# preprocessing
plnn = ParallelNN(axis=0)
for power in [[1, 1], [1, 0, 1]]:
plnn.layers.append(
functions.ConvProd(input_shape,
itype,
powers=power,
boundary='P',
strides=(1, )))
NF = 2
net1 = ANN(layers=[plnn])
for i, (nfi, nfo) in enumerate(
zip([np.prod(input_shape)] + num_features1,
num_features1 + [1])):
if use_conv[0] and i == 0:
net1.add_layer(SPConv,
weight=eta *
typed_randn(self.itype, (nfo, NF, nsite)),
bias=eta * typed_randn(self.itype, (nfo, )))
net1.add_layer(functions.Transpose, axes=(1, 0))
else:
net1.add_layer(Linear,
weight=eta *
typed_randn(self.itype, (nfo, nfi)),
bias=eta * typed_randn(self.itype, (nfo, )))
if version == 'basic':
net1.add_layer(functions.Tanh)
elif version == 'sigmoid':
net1.add_layer(functions.Sigmoid)
else:
raise
if use_conv[0]:
net1.add_layer(functions.Mean, axis=0)
net1.add_layer(functions.Reshape, output_shape=())
# create sign network
net2 = ANN(layers=[
functions.Reshape(
input_shape, itype=itype, output_shape=(1, ) + input_shape)
])
for i, (nfi, nfo) in enumerate(
zip([np.prod(input_shape)] + num_features2,
num_features2 + [1])):
if use_conv[1] and i == 0:
net2.add_layer(SPConv,
weight=eta *
typed_randn(self.itype, (nfo, 1, nsite)),
bias=eta * typed_randn(self.itype, (nfo, )))
net2.add_layer(functions.Transpose, axes=(1, 0))
else:
net2.add_layer(Linear,
weight=eta *
typed_randn(self.itype, (nfo, nfi)),
bias=eta * typed_randn(self.itype, (nfo, )))
net2.add_layer(functions.Mul, alpha=np.pi)
net2.add_layer(functions.Cos)
if use_conv[1]:
net2.add_layer(functions.Mean, axis=0)
net2.add_layer(functions.Reshape, output_shape=())
# construct whole network
self.layers.append(ParallelNN(layers=[net1, net2]))
self.add_layer(functions.Prod, axis=0)
print(check_numdiff(self))
def __init__(self, input_shape, K=2, num_features=[4,4,4], eta0=0.2, eta1=0.2, NP=1, NC=1,\
itype='complex128',dtype0='complex128', dtype1='complex128', momentum=0.,
stride=None, usesum=False, nonlinear='x^3',poly_order=10):
self.num_features, self.itype = num_features, itype
if stride is None:
if any([n % 4 != 0 for n in input_shape]):
stride = 2
else:
stride = 1
self.stride = stride
nsite = np.prod(input_shape)
super(WangLei5, self).__init__(itype, do_shape_check=False)
D = len(input_shape)
ishape = (1, ) + input_shape
self.layers.append(
functions.Reshape(input_shape, itype=itype, output_shape=ishape))
imgsize = self.layers[-1].output_shape[-D:]
# product layers.
dtype = dtype0
eta = eta0
self.add_layer(functions.Log)
for nfi, nfo in zip([1] + num_features[:NP - 1], num_features[:NP]):
self.add_layer(SPConv,
weight=eta * typed_uniform(dtype,
(nfo, nfi) + (K, ) * D),
bias=eta * typed_uniform(dtype, (nfo, )),
boundary='P',
strides=(stride, ) * D)
imgsize = self.layers[-1].output_shape[-D:]
self.add_layer(functions.Exp)
# convolution layers.
eta = eta1
dtype = dtype1
stride = 1
for nfi, nfo in zip(num_features[NP - 1:NP + NC - 1],
num_features[NP:NP + NC]):
self.add_layer(SPConv,
weight=eta * typed_uniform(dtype,
(nfo, nfi) + imgsize),
bias=eta * typed_uniform(dtype, (nfo, )),
boundary='P',
strides=(stride, ) * D)
imgsize = self.layers[-1].output_shape[-D:]
self.add_layer(functions.Reshape,
output_shape=(nfo, np.prod(imgsize) // stride**D))
# non-linear function
if nonlinear == 'x^3':
self.add_layer(functions.Power, order=3)
elif nonlinear == 'x^5':
self.add_layer(functions.Power, order=5)
elif nonlinear == 'relu':
self.add_layer(functions.ReLU)
elif nonlinear == 'sinh':
self.add_layer(functions.Sinh)
elif nonlinear in layers.Poly.kernel_dict:
self.add_layer(layers.Poly,
params=eta0 * typed_uniform('complex128',
(poly_order, )),
kernel=nonlinear)
else:
raise Exception
self.add_layer(functions.Filter, axes=(-1, ), momentum=momentum)
# linear layers.
if usesum:
self.add_layer(functions.Mean, axis=-1)
else:
for i, (nfi, nfo) in enumerate(
zip(num_features[NP + NC - 1:],
num_features[NP + NC:] + [1])):
if i != 0:
self.add_layer(functions.ReLU)
self.add_layer(Linear,
weight=eta * typed_uniform(dtype, (nfo, nfi)),
bias=eta * typed_uniform(dtype, (nfo, )),
var_mask=(1, 1))
self.add_layer(functions.Reshape, output_shape=())
