def __init__(self, name='logparabola'):
self.ref = Parameter(name, 'ref', 1, alwaysfrozen=True)
self.c1 = Parameter(name, 'c1', 1)
self.c2 = Parameter(name, 'c2', 1)
self.ampl = Parameter(name, 'ampl', 1, 0)
ArithmeticModel.__init__(self, name,
(self.ref, self.c1, self.c2, self.ampl))
def test_spider():
from session import Session
from condition import Condition
from spider import Spider
from parameter import Parameter
from datetime import datetime
s = Session()
c = Condition()
# parameter = Parameter(param=str(c), sess=s)
spider = Spider(sess=s)
# page: 每页几条; order: 排序标准; direction: 顺序 (asc - 正序 desc - 倒序)
print(
spider.tree_content(param=Parameter(param=str(
c.district('西藏自治区').date(datetime(1991, 1, 1), datetime(
2018, 9, 15))),
sess=s)))
for i in spider.content_list(param=Parameter(param=str(
c.district('西藏自治区').date(datetime(1991, 1, 1),
datetime(2018, 9, 15))),
sess=s),
page=20,
order='法院层级',
direction='asc'):
print(i)
def getParameters(aParams, aTypes, aOffset):
if aParams == []:
return []
if aParams[0] in aTypes:
t = aTypes[aParams[0]]
elif aParams[0][0] == '@' and aParams[0][1:] in aTypes:
t = aTypes[aParams[0][1:]]
else: # Type not known, assume TDesC8
t = aTypes.get(
aParams[1],
Type(aParams[0], 'TDesC8', 'TPtrC8', 'TPtrC8', aParams[1],
'AsString', 'PutString', 'PutString', '', True, False, False,
'_L8("\\x0")', '_L8("\\xff")', 'UnknownType_instance', '',
''))
newOffset = aOffset
if t.iSize != 'n': # Not of 'infinite' size
newOffset += int(t.iSize)
if len(aParams) > 2 and aParams[
2] == '*': # Is 'array', delimited by other parameter.
return [Parameter(t, aParams[0], aOffset, aParams[3])] + getParameters(
aParams[4:], aTypes, newOffset)
else:
return [Parameter(t, aParams[0], aOffset)] + getParameters(
aParams[2:], aTypes, newOffset)
def compile(self, network):
if self.output is not None:
raise Exception("Layer " + self.name + " is already compiled!")
if self.parameters is None:
self.W = tf.Variable(tf.random_normal(
[self.input_layers[0].get_size(), self.size],
mean=0.0,
stddev=(self.weights_init_stddev /
sqrt(self.input_layers[0].get_size()))),
name=(network.name + "_" + self.name + "_W"))
self.b = tf.Variable(tf.random_normal(
[self.size], mean=0.0, stddev=self.bias_init_stddev),
name=(network.name + "_" + self.name + "_b"))
self.parameters = [
Parameter(self.W, trainable=True, regularizable=True),
Parameter(self.b)
]
else:
self.W = self.parameters[0].tf_variable
self.b = self.parameters[1].tf_variable
self.output = self.activation_fn(
tf.matmul(self.input_layers[0].get_output(), self.W) + self.b,
name=(network.name + "_" + self.name))
def __init__(self, name='integrate1d'):
tol = numpy.finfo(float).eps
self.epsabs = Parameter(name, 'epsabs', tol, alwaysfrozen=True)
self.epsrel = Parameter(name, 'epsrel', 0, alwaysfrozen=True)
self.maxeval = Parameter(name, 'maxeval', 10000, alwaysfrozen=True)
ArithmeticModel.__init__(self, name,
(self.epsabs, self.epsrel, self.maxeval))
def __init__(self):
# Parameters
self.charging_current_limit = 5
self.gyro_limit = 0.15
self.min_number_of_values_over_limit = 25
self.array_length = 90
self.min_trip_length = 300 # s
self.trip_started = False
self.max_time_between_movement = 280 # s
self.max_avg_speed = 30 # km/h
# Declaring variables
self.charging_currents = Parameter(
self.array_length, self.charging_current_limit,
self.min_number_of_values_over_limit)
self.gyroscopes = Parameter(self.array_length, self.gyro_limit,
self.min_number_of_values_over_limit)
self.start_times = []
self.end_times = []
# Declaring temporary variable for trips
self.tmp_start_time = 0
# Defining positions of variables in DB
self.time_db = 0
# latGPS_db = 3
# lenGPS_db = 4
self.charging_current_db = 26
self.gyro_x_db = 13
self.gyro_y_db = 14
self.gyro_z_db = 15
def __init__(self, D=None, R=None):
if D is None:
raise(ValueError, 'Distributions must be given')
else:
self.D = D
if R is None:
raise(ValueError, 'Correlation matrix must be specified')
else:
self.R = R
self.std = Parameter(order=5, distribution='normal',shape_parameter_A = 0.0, shape_parameter_B = 1.0)
#
# R0 = fictive matrix of correlated normal intermediate variables
#
# 1) Check the type of correlated marginals
# 2) Use Effective Quadrature for solving Legendre
# 3) Calculate the fictive matrix
inf_lim = -8.0
sup_lim = - inf_lim
p1 = Parameter(distribution = 'uniform', lower = inf_lim, upper = sup_lim, order = 31)
myBasis = Basis('Tensor grid')
Pols = Polyint([p1, p1], myBasis)
p = Pols.quadraturePoints
w = Pols.quadratureWeights * (sup_lim - inf_lim)**2
p1 = p[:,0]
p2 = p[:,1]
R0 = np.eye((len(self.D)))
for i in range(len(self.D)):
for j in range(i+1, len(self.D), 1):
if self.R[i,j] == 0:
R0[i,j] = 0.0
else:
tp11 = -(np.array(self.D[i].getiCDF(self.std.getCDF(points=p1))) - self.D[i].mean ) / np.sqrt( self.D[i].variance )
tp22 = -(np.array(self.D[j].getiCDF(self.std.getCDF(points=p2))) - self.D[j].mean)/np.sqrt( self.D[j].variance )
rho_ij = self.R[i,j]
bivariateNormalPDF = (1.0 / (2.0 * np.pi * np.sqrt(1.0-rho_ij**2)) * np.exp(-1.0/(2.0*(1.0 - rho_ij**2)) * (p1**2 - 2.0 * rho_ij * p1 * p2 + p2**2 )))
coefficientsIntegral = np.flipud(tp11*tp22 * w)
def check_difference(rho_ij):
bivariateNormalPDF = (1.0 / (2.0 * np.pi * np.sqrt(1.0-rho_ij**2)) * np.exp(-1.0/(2.0*(1.0 - rho_ij**2)) * (p1**2 - 2.0 * rho_ij * p1 * p2 + p2**2 )))
diff = np.dot(coefficientsIntegral, bivariateNormalPDF)
return diff - self.R[i,j]
rho = optimize.newton(check_difference, self.R[i,j])
R0[i,j] = rho
R0[j,i] = R0[i,j]
self.A = np.linalg.cholesky(R0)
print 'The Cholesky decomposition of fictive matrix R0 is:'
print self.A
print 'The fictive matrix is:'
print R0
def __init_default_params(self):
self.add_param(Parameter('spark.sql.shuffle.partitions', IntRangeDomain(10, 2000, 50)))\
.add_param(Parameter('spark.executor.memory',
IntRangeDomain(self._get_min_executor_mem(), # min executor memory
self._get_max_executor_mem(), # max executor memory
512)))\
.add_param(Parameter('spark.driver.memory',
IntRangeDomain(256, self._get_max_driver_memory(), 256))) \
.add_param(Parameter('spark.executor.cores', IntRangeDomain(2, self.num_cores, 1)))
def __init__(self, name='box2d'):
self.xlow = Parameter(name, 'xlow', 0)
self.xhi = Parameter(name, 'xhi', 0)
self.ylow = Parameter(name, 'ylow', 0)
self.yhi = Parameter(name, 'yhi', 0)
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(
self, name, (self.xlow, self.xhi, self.ylow, self.yhi, self.ampl))
self.cache = 0
def __init__(self, scene):
self.batch = pyglet.graphics.Batch()
self.translate = Parameter(default=Vector3(0,0,0))
self.rotate= Parameter(default=Vector3(0,0,0))
self.scale= Parameter(default=Vector3(1,1,1))
self.shader = Shader(self.vertex_shader, self.fragment_shader)
scene.objects.append( self )
def _get_parameter(parameter_name, fixed_attributes,
uri_parameters) -> Parameter:
if fixed_attributes is not None and parameter_name in fixed_attributes:
return Parameter(parameter_name, fixed_attributes[parameter_name],
None, None, True)
elif any(parameter["Name"] == parameter_name
for parameter in uri_parameters):
for parameter in uri_parameters:
if parameter["Name"] == parameter_name:
return Parameter(parameter_name, parameter["ExampleValue"],
parameter["Type"], parameter["Format"],
False)
else:
return Parameter(parameter_name, 'attribute', None, None, False)
def __init__(self, name='polynom1d'):
pars = []
for i in xrange(9):
pars.append(Parameter(name, 'c%d' % i, 0, frozen=True))
pars[0].val = 1
pars[0].frozen = False
for p in pars:
setattr(self, p.name, p)
self.offset = Parameter(name, 'offset', 0, frozen=True)
pars.append(self.offset)
ArithmeticModel.__init__(self, name, pars)
def read_config(self):
self.gscale_options = tuple(self.cfg["gscale"]["options"])
for p in self.cfg["resp_params"].keys():
assert p in list(ParamEnum.__members__)
screen_name = self.cfg["resp_params"][p]["screen_name"]
min_ = self.cfg["resp_params"][p]["min"]
max_ = self.cfg["resp_params"][p]["max"]
fmt = self.cfg["resp_params"][p]["format"]
step = self.cfg["resp_params"][p]["step"]
default = self.cfg["resp_params"][p]["default"]
units = self.cfg["resp_params"][p]["units"]
measured = self.cfg["resp_params"][p]["measured"]
options = None
try:
options = tuple(self.cfg["resp_params"][p]["options"])
print(options)
except KeyError:
pass
min_ = tuple(float(v) for v in min_.split(",")) if (isinstance(min_, str) and "," in min_) else float(min_)
max_ = tuple(float(v) for v in max_.split(",")) if (isinstance(max_, str) and "," in max_) else float(max_)
step = tuple(float(v) for v in step.split(",")) if (isinstance(step, str) and "," in step) else float(step)
default = tuple(float(v) for v in default.split(",")) if (
isinstance(default, str) and "," in default) else float(default)
fmt = tuple(f for f in fmt.split(",")) if "," in fmt else fmt
self.params[p] = Parameter(name=p, screen_name=screen_name, units=units, min_=min_, max_=max_, step=step,
fmt=fmt, default=default, measured=measured)
if options is not None:
self.params[p].options = options
self.params[p].value_as_index = True
if ParamEnum.ier.name in self.params.keys():
options = self.params[ParamEnum.ier.name].options
self.params[ParamEnum.ier.name].options = tuple((f"{v.split(':')[0].rjust(3)}:{v.split(':')[1].rjust(3)}" for v in options))
print(self.params[ParamEnum.ier.name].options)
for m in self.cfg["modes"].keys():
assert m in list(OpModEnum.__members__)
self.modes[m] = OpMode(name=m)
for p in self.cfg['modes'][m].keys():
if self.cfg['modes'][m][p]['adjustable']:
self.modes[m].adjustable_params.append(p)
self.params['mode'] = Parameter(name='mode')
self.params['mode'].value = OpModEnum.vcv.value #VCV by default upon starting
self.update_adjustable()
self.params[ParamEnum.gscale.name] = Parameter(name=ParamEnum.gscale.name)
def __init__(self, in_dim, out_dim, with_bias=True):
super(Linear, self).__init__()
self.in_dim = in_dim
self.out_dim = out_dim
w = FloatTensor(out_dim, in_dim)
w = xavier_normal(w)
w_grad = FloatTensor(out_dim, in_dim).zero_()
self.w = Parameter(w, w_grad)
self.bias = None
if with_bias:
bias = FloatTensor(out_dim).zero_()
bias_grad = FloatTensor(out_dim).zero_()
self.bias = Parameter(bias, bias_grad)
def __init__(self, name, parts):
self.parts = tuple(parts)
allpars = []
for part in self.parts:
for p in part.pars:
if p in allpars:
# If we already have a reference to this parameter, store
# a hidden, linked proxy instead
pnew = Parameter(p.modelname, p.name, 0.0, hidden=True)
pnew.link = p
p = pnew
allpars.append(p)
Model.__init__(self, name, allpars)
for part in self.parts:
try:
self.is_discrete = self.is_discrete or part.is_discrete
except:
warning(
"Could not determine whether the model is discrete.\n" +
"This probably means that you have restored a session saved with a previous version of Sherpa.\n"
+
"Falling back to assuming that the model is continuous.\n")
self.is_discrete = False
def test_parameter_points():
p = Parameter('test')
p.update(0, 10)
p.update(1, 11)
p.update(2, 12)
assert p.points() == [(0, 10), (1, 11), (2, 12)]
def vandermonde(eta, p):
"""
Internal function to variable_projection
Calculates the Vandermonde matrix using polynomial basis functions
:param eta: ndarray, the affine transformed projected values of inputs in active subspace
:param p: int, the maximum degree of polynomials
:return:
* **V (numpy array)**: The resulting Vandermode matrix
* **Polybasis (Poly object)**: An instance of Poly object containing the polynomial basis derived
"""
_, n = eta.shape
listing = []
for i in range(0, n):
listing.append(p)
Object = Basis('Total order', listing)
#Establish n Parameter objects
params = []
P = Parameter(order=p, lower=-1, upper=1, param_type='Uniform')
for i in range(0, n):
params.append(P)
#Use the params list to establish the Poly object
Polybasis = Poly(params, Object)
V = Polybasis.getPolynomial(eta)
V = V.T
return V, Polybasis
def new_demo(test=False):
import pygame
from demo.game import Game
if test is False:
game = Game(640, 480, None)
else:
def _render(game):
while True:
game.draw()
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_9:
game.increase_fps()
elif event.key == pygame.K_0:
game.decrease_fps()
pygame.init()
DISPLAYSURF = pygame.display.set_mode((640, 480), 0, 32)
pygame.display.set_caption('Demo')
game = Game(640, 480, DISPLAYSURF)
t = Thread(target=lambda: _render(game))
t.start()
parameter = Parameter(lr=1e-3)
parameter.gamma = 0.9
parameter.iteration_num = 300000
parameter.num_history_frames = 1
parameter.network_type = 'mlp'
parameter.update_method = 'rmsprop'
parameter.rho = 0.95
parameter.async_update_interval = 5
parameter.input_scale = 1.0
return game, parameter
def __init__(self, cur_pressure: deque, cur_flow: deque, total_flow: deque,
p_max: deque, p_avg: deque, peep: deque, fio2: deque,
f_max: deque, user_set_param: deque, data_msg: deque):
QThread.__init__(self)
self.logger = logging.getLogger('gui')
try:
os.unlink(SOCKET_ADDRESS)
except OSError:
if os.path.exists(SOCKET_ADDRESS):
raise
self.dq_cp = cur_pressure
self.dq_cf = cur_flow
self.dq_tv = total_flow
self.dq_p_max = p_max
self.dq_p_avg = p_avg
self.dq_peep = peep
self.dq_fio2 = fio2
self.dq_f_max = f_max
self.buf_rx = deque(maxlen=BUF_RX_SIZE)
self.parsed_data = ""
self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
self.socket.bind(SOCKET_ADDRESS)
#self.socket = socket.socket()
#self.socket.bind(('', 5040))
self.stop = Event()
self.connection = None
self.socket.listen(1)
self.socket.setblocking(True)
self.operation_mode = OpMode.VCV
self.user_set_param: deque = user_set_param
self.data_msg: deque = data_msg
self.params = dict()
for p in PARAM_NAMES:
self.params[p] = Parameter(name=p)
def initialize(self):
parameters = []
configure_parameters = self.configure.get(self.name)
if type(configure_parameters) is list:
parameters.extend(configure_parameters)
else:
parameters.append(configure_parameters)
files = listdir(self.path)
for parameterName in parameters:
##for example cpu.shares then it will start with cpu, we only configure these files.
if parameterName in files:
##we pass the path fo the file under this subsystem to Parameter class
fileName = self.path + "/" + parameterName
parameter = Parameter(name=parameterName,
path=fileName,
configure=self.configure)
self.subParameters[parameterName] = parameter
else:
log.error("can not find file parameter %s", parameterName)
##TODO we can't find a file mathed with parameter log error message here
pass
##read initial values
for parameter in self.subParameters.values():
parameter.read()
def create_parameter_record(self, filter_tag='', filter_name=''):
"""This is VAS only.
It will not unless you have a parameter system same like ours.
"""
query = "SELECT * FROM SYS_TABLE_P"
if filter_tag and filter_name:
query += " WHERE Tag LIKE '%{0}% AND \
ucText LIKE '%{1}%'".format(filter_tag, filter_name)
elif filter_tag:
query += " WHERE Tag LIKE '%{0}%'".format(filter_tag)
elif filter_name:
query += " WHERE ucText LIKE '%{0}%'".format(filter_name)
query += " ORDER BY PID;"
logging.debug("Query: %s", query)
self.execute(query)
if self.rowcount():
logging.debug("Found %s matching parameters", self.rowcount())
params = ParameterRecord()
for rec in self.fetchall():
params.push(
Parameter(rec['ID'], rec['TEXTID'], rec['HELPID'],
rec['SPSID'], rec['PID'], rec['Tag'],
rec['ucText'], int(rec['siValue']),
int(rec['siMin']), int(rec['siMax']),
int(rec['siDef']), rec['uiMul'], rec['ucRight'],
rec['ucSection'], rec['ucGroup'], rec['ucUnit'],
rec['ucHelpText'], rec['LastUser'],
rec['LastAccess'], rec['UpdateEnable'],
rec['ChangedByPLC'], rec['ChangedByHMI']))
return params
else:
return None
def __init__(cls):
'''Method init'''
cls.accountName = os.getenv('ACCOUNT_NAME')
print('cls.accountName ',cls.accountName)
#cls.accountKey = os.getenv('ACCOUNT_KEY')
print('cls.accountKey ', cls.accountKey )
cls.config = Parameter(cls.accountName, cls.accountKey).get_parameters()
def test_parameter_update():
p = Parameter('test')
p.update(0, 10)
p.update(1, 11)
p.update(2, 12)
assert p.t_series == [0, 1, 2]
assert p.v_series == [10, 11, 12]
def __init__(self, name='polynom2d'):
self.c = Parameter(name, 'c', 1)
self.cx1 = Parameter(name, 'cx1', 0)
self.cx2 = Parameter(name, 'cx2', 0)
self.cy1 = Parameter(name, 'cy1', 0)
self.cy2 = Parameter(name, 'cy2', 0)
self.cx1y1 = Parameter(name, 'cx1y1', 0)
self.cx1y2 = Parameter(name, 'cx1y2', 0)
self.cx2y1 = Parameter(name, 'cx2y1', 0)
self.cx2y2 = Parameter(name, 'cx2y2', 0)
ArithmeticModel.__init__(
self, name, (self.c, self.cy1, self.cy2, self.cx1, self.cx1y1,
self.cx1y2, self.cx2, self.cx2y1, self.cx2y2))
self.cache = 0
def __init__(self, scene, filepath, *args, **kwargs):
super(Ptc, self).__init__(scene, *args, **kwargs)
self.visible = Parameter(default=True,
title='Visible',
update=self.update_visibility)
self.filepath = filepath
self.filename = '' # after frame conversion
self.frame = None
self.vbo_vert_data = None
self.vbo_col_data = None
self.ptc_loaded = False
# object-specific parameters
self.decimate = Parameter(default=1.0,
vmin=0.0,
vmax=1.0,
title='Decimate')
self.num_particles = Parameter(default=0, title='Num particles: ')
self.attributes = Parameter(default='',
title='',
update=self.read_ptc_attrs_data)
self.attr_stats = Parameter(default='', title='')
self.histogram = Parameter(default=Histogram(), title='')
self.show_statistics = Parameter(default=True, title='Update Stats')
# create VBOs
self.init_buffers()
# load ptc, store in self.verts/self.cols, update VBOs if loaded
self.frame = scene.frame.value
self.read_ptc_attrs_data()
def main():
param = Parameter()
dataset = fetch_dataset(param, False)
logger.info(len(dataset))
locations = []
for i in range(len(dataset)):
locations.append(dataset.__getitem__(i)['locations'])
with open(str(Path.home() / '.tmp/high-level/training.json'), 'w') as file:
json.dump(locations, file, indent=2)
def court(self,
condition: Condition,
district: str,
start_court: str = None):
"""
:param condition:
:param district:
:param start_court: start_court will only be available for level 2
:return: Court name, court level, court indicator, count
"""
level_count = {'高级法院': 0, '中级法院': 0, '基层法院': 0}
condition = condition.district(district)
info = self.tree_content(
Parameter(param=str(condition), sess=self.sess))['法院层级']
satisfy = True
for item in info['ParamList']:
if item['IntValue'] > 200:
satisfy = False
if item['Key'] in level_count:
level_count[item['Key']] = item['IntValue']
if satisfy:
for k, v in level_count.items():
if v > 0:
yield None, k, True, v
else:
start = start_court is None
if start and level_count['高级法院'] > 0:
yield None, 1, True, level_count['高级法院']
middle = self.court_tree_content(condition,
parval=district)['中级法院']
for d in sorted(middle['ParamList'],
key=lambda item: item['IntValue'],
reverse=False):
mid_court = d['Key']
if not start:
if mid_court == start_court:
start = True
if start:
if 0 < d['IntValue'] < 200:
yield mid_court, 2, False, d['IntValue']
else:
base = self.court_tree_content(
condition.court(mid_court, 2, False),
parval=mid_court)['基层法院']
if d['IntValue'] - base['IntValue'] > 0:
yield mid_court, 2, True, d['IntValue'] - base[
'IntValue']
for g in sorted(base['ParamList'],
key=lambda item: item['IntValue'],
reverse=False):
base_court = g['Key']
if g['IntValue'] > 0:
yield base_court, 3, False, g['IntValue']
def __init__(self, D=None, R=None):
if D is None:
raise(ValueError, 'Distributions must be given')
else:
self.D = D
if R is None:
raise(ValueError, 'Correlation Matrix must be specified')
else:
self.R = R
self.std = Parameter(order=3, distribution='normal', shape_parameter_A = 0., shape_parameter_B = 1.)
def __init__(self,
identifier: str = 'Property',
unit: str = '/',
absolute: bool = True,
latex: Optional[str] = None,
val: Optional[Union[float, Iterable[float]]] = None,
ref: Optional[Union[float, Iterable[float]]] = None,
comment: Optional[str] = None,
calc: Optional[Callable[..., float]] = None) -> None:
super().__init__(identifier=identifier,
unit=unit,
absolute=absolute,
latex=latex,
val=val,
ref=ref,
comment=comment)
# reference temperature gases: 15C, solids: 20C or 25C, liquids: 20C
T_Celsius = 20.
self.T = Parameter(identifier='T', unit='K', absolute=True)
self.T.ref = C2K(T_Celsius)
self.T['operational'] = Range(C2K(-40.), C2K(200.))
self.T.accuracy = Range('-1', '+1')
self.p = Parameter(identifier='p', unit='Pa', absolute=True)
self.p.ref = atm()
self.p['operational'] = Range(0. + self.p.ref, 100e5 + self.p.ref)
self.p.accuracy = Range('-1%FS', '+1%FS')
self.x = Parameter(identifier='x', unit='/', absolute=True)
self.x['operational'] = Range(0., 1.)
self.x.ref = 0.
self.accuracy = Range('-1%', '1%')
self.repeatability = Range('-0.1', '+0.1', '95%')
if calc is None:
calc = lambda T, p, x: 1.
self.calc = calc
self.regression_coefficients: Optional[Iterable[float]] = None
def __init__(self, name='tablemodel'):
# these attributes should remain somewhat private
# as not to conflict with user defined parameter names
self.__x = None
self.__y = None
self.__filtered_y = None
self.filename = None
self.method = linear_interp # interpolation method
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(self, name, (self.ampl, ))
