def __init__(self):
super().__init__()
self.name = 'check_attribute_value'
self.args.add_arg('actual_value', values.NoneValue())
self.args.add_arg('expected_value', values.NoneValue())
self.args.add_arg('func_name', values.NoneValue())
self.args.add_arg('arg_name', values.NoneValue())
def __init__(self):
super().__init__()
self.name = 'cumsum'
self.args.add_arg('a', values.NoneValue())
self.args.add_arg('axis', values.NoneValue())
self.args.add_arg('dtype', values.NoneValue())
self.args.add_arg('out', values.NoneValue())
def __init__(self):
super().__init__()
self.name = 'full'
self.args.add_arg('shape', values.NoneValue())
self.args.add_arg('fill_value', values.NoneValue())
self.args.add_arg('dtype', values.NoneValue())
self.args.add_arg('order', values.StrValue('C'))
def __init__(self):
super().__init__()
self.name = 'array'
self.args.add_arg('object', values.NoneValue())
self.args.add_arg('dtype', values.NoneValue())
self.args.add_arg('copy', values.BoolValue(True))
self.args.add_arg('order', values.StrValue('K'))
self.args.add_arg('subok', values.BoolValue(False))
self.args.add_arg('ndmin', values.NumberValue(0))
def vcall(self,
module: 'values.Field',
graph: 'graphs.Graph',
inst: 'values.Object',
args: 'functions.FunctionArgInput',
option: 'vevaluator.VEvalContext' = None,
line=-1):
funcArgs = self.args.merge_inputs(inst, args)
node = nodes.NodeCall(self, funcArgs, line)
if inst.in_container:
raise Exception('Invalid operation')
old_v = inst.get_value()
new_v = functions.generate_value_with_same_type(old_v)
# estimate a type contained
if old_v.has_constant_value():
new_v.internal_value = list(old_v.internal_value)
for v in funcArgs.inputs[1:]:
new_v.append(v)
# update value
inst.revise(new_v)
new_v.name = '@F.{}.{}'.format(line, self.name)
node.set_outputs([new_v])
graph.add_node(node)
return values.NoneValue()
def generate_copied_value(value: 'values.Value'):
assert(isinstance(value, values.Value))
if isinstance(value, values.NumberValue):
copied = values.NumberValue(value.internal_value)
copied.dtype = value.dtype
return copied
if isinstance(value, values.TensorValue):
copied = values.TensorValue()
copied.value = value.value
copied.shape = value.shape
copied.dtype = value.dtype
return copied
if isinstance(value, values.ListValue):
copied = values.ListValue()
copied.dtype = value.dtype
copied.vtype = value.vtype
if value.internal_value is not None:
copied.internal_value = value.internal_value.copy()
return copied
if isinstance(value, values.NoneValue):
copied = values.NoneValue()
return copied
if isinstance(value, values.BoolValue):
copied = values.BoolValue(value.internal_value)
return copied
if isinstance(value, values.StrValue):
copied = values.StrValue(value.internal_value)
return copied
if isinstance(value, values.RangeValue):
copied = values.RangeValue()
return copied
if isinstance(value, values.TupleValue):
if value.internal_value is not None:
copied = values.TupleValue(value.internal_value.copy())
else:
copied = values.TupleValue(value.internal_value)
copied.dtype = value.dtype
copied.vtype = value.vtype
return copied
if config.show_warnings:
print('Unknown type {} is copied'.format(value))
return values.Value()
def veval_ast_name_constant(astc: 'AstContext', local_field: 'values.Field',
graph: 'Graph'):
'''
Ex. True
'''
assert (isinstance(astc.nast, gast.gast.NameConstant))
lineprop = utils.LineProperty(astc.lineno, astc.filename)
ret = None
if astc.nast.value == True:
ret = values.ValueRef(values.BoolValue(True))
if astc.nast.value == False:
ret = values.ValueRef(values.BoolValue(False))
if astc.nast.value is None:
ret = values.ValueRef(values.NoneValue())
name = values.create_ref_value_name_with_constant(ret)
ret.name = name
ret.get_value().name = name
return ret
def vcall(self,
module: 'values.Field',
graph: 'graphs.Graph',
inst: 'values.Object',
args: 'functions.FunctionArgInput',
context: 'functions.VEvalContext' = None,
line=-1):
assert (inst is None)
funcArgs = self.args.merge_inputs(inst, args)
args = []
for value in funcArgs.get_value().inputs:
assert value.has_constant_value(
), "Arguments for elichika.flags were non-constant at %s" % line
args.append(value.internal_value)
if context is not None:
context.flags_cache.append((self.name, args))
return values.Object(values.NoneValue())
def __init__(self):
super().__init__()
self.name = 'ceil'
self.args.add_arg('x', values.NoneValue())
def __init__(self):
super().__init__()
self.name = 'check_attribute_scalar'
self.args.add_arg('value', values.NoneValue())
self.args.add_arg('func_name', values.NoneValue())
self.args.add_arg('arg_name', values.NoneValue())
def generate_value_with_same_type(value: 'values.Value', is_dummy_value = False, suffix_type = SuffixType.Unknown):
assert(isinstance(value, values.Value))
ret = None
if isinstance(value, values.TensorValue):
ret = values.TensorValue()
ret.shape = value.shape
ret.dtype = value.dtype
elif isinstance(value, values.NumberValue):
dtype = None
if value.internal_value is None:
dtype = value.dtype
elif isinstance(value.internal_value, int):
dtype = np.array(value.internal_value).dtype
elif isinstance(value.internal_value, float):
dtype = np.array(value.internal_value).dtype
ret = values.NumberValue(None)
ret.dtype = dtype
elif isinstance(value, values.StrValue):
ret = values.StrValue(None)
elif isinstance(value, values.BoolValue):
ret = values.BoolValue(None)
elif isinstance(value, values.ListValue):
ret = values.ListValue(None)
ret.dtype = value.dtype
ret.vtype = value.vtype
elif isinstance(value, values.NoneValue):
ret = values.NoneValue()
elif isinstance(value, values.TupleValue):
ret = values.TupleValue()
ret.dtype = value.dtype
ret.vtype = value.vtype
elif isinstance(value, values.RangeValue):
ret = values.RangeValue()
elif isinstance(value, values.UnknownValue):
ret = values.UnknownValue()
elif ret is None and isinstance(value, values.Value):
ret = values.Value()
else:
assert(False)
assert(ret is not None)
ret.is_dummy_value = is_dummy_value
if suffix_type == SuffixType.Unknown:
ret.name = value.name + '_st'
elif suffix_type == SuffixType.Unused:
ret.name = value.name + '_unused'
elif suffix_type == SuffixType.Dummy:
ret.name = value.name + '_dummy'
elif suffix_type == SuffixType.Input:
ret.name = value.name + '_in'
else:
assert(False)
return ret
def return_NStepLSTM():
list_tensor = values.ListValue()
list_tensor.vtype = values.TensorValue
return [values.TensorValue(), values.TensorValue(), list_tensor]
def return_NStepBiLSTM():
list_tensor = values.ListValue()
list_tensor.vtype = values.TensorValue
return [values.TensorValue(), values.TensorValue(), list_tensor]
chainer_links[chainer.links.Linear] = ChainerLinkDefinition(
args=[('self', values.NoneValue()), ('x', values.NoneValue()),
('n_batch_axes', values.NumberValue(1))],
estimate_shape=estimate_linear_shape)
chainer_links[chainer.links.Convolution2D] = ChainerLinkDefinition(
estimate_shape=estimate_convolution2D_shape)
chainer_links[chainer.links.ConvolutionND] = ChainerLinkDefinition(
estimate_shape=estimate_convolutionND_shape)
chainer_links[chainer.links.BatchNormalization] = ChainerLinkDefinition(
estimate_shape=estimate_batch_norm_shape)
chainer_links[chainer.links.NStepLSTM] = ChainerLinkDefinition(
args=[('self', values.NoneValue()), ('hx', values.NoneValue()),
('cx', values.NoneValue()), ('xs', values.NoneValue())],
estimate_shape=estimate_NStepLSTM_shape,
get_ret=return_NStepLSTM)
chainer_links[chainer.links.NStepBiLSTM] = ChainerLinkDefinition(
args=[('self', values.NoneValue()), ('hx', values.NoneValue()),
def __init__(self):
super().__init__()
self.name = 'list'
self.args.add_arg('value', values.ValueRef(values.NoneValue()))
