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,
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, 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 build_ann():
'''
builds a single layer network for mnist classification problem.
'''
F1 = 10
I1, I2 = 28, 28
eta = 0.1
dtype = 'float32'
W_fc1 = typed_randn(dtype, (F1, I1 * I2)) * eta
b_fc1 = typed_randn(dtype, (F1, )) * eta
# create an empty vertical network.
ann = ANN()
linear1 = Linear((-1, I1 * I2), dtype, W_fc1, b_fc1)
ann.layers.append(linear1)
ann.add_layer(functions.SoftMaxCrossEntropy, axis=1)
ann.add_layer(functions.Mean, axis=0)
return ann
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, use_msr=False, theta_period=2):
self.use_msr = use_msr
itype = 'float64'
nsite = np.prod(input_shape)
eta = 0.1
self.vec = eta * typed_randn(itype, input_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, 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,
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))
