def addMAX_P(self):
operator = Operator('MAX_P', 1)
def func(node):
node.maxPooling = True
return node
operator.set_pheno_func(func)
self.operators.append(operator)
def addDOUB(self):
operator = Operator('DOUB', 1)
def func(node):
node.multiply_neuron_count(2)
return node
operator.set_pheno_func(func)
self.operators.append(operator)
def addSOFTPLUS(self):
operator = Operator('SOFTPLUS', 1)
def func(node):
node.set_activation('softplus')
return node
operator.set_pheno_func(func)
self.operators.append(operator)
def addTANH(self):
operator = Operator('TANH', 1)
def func(node):
node.set_activation('tanh')
return node
operator.set_pheno_func(func)
self.operators.append(operator)
def addHSIGMOID(self):
operator = Operator('HSIGMOID', 1)
def func(node):
node.set_activation('hard_sigmoid')
return node
operator.set_pheno_func(func)
self.operators.append(operator)
def addSOFTSIGN(self):
operator = Operator('SOFTSIGN', 1)
def func(node):
node.set_activation('softsign')
return node
operator.set_pheno_func(func)
self.operators.append(operator)
def addRELU(self):
operator = Operator('RELU', 1)
def func(node):
node.set_activation('relu')
return node
operator.set_pheno_func(func)
self.operators.append(operator)
def addFILTER_INC(self):
operator = Operator('FILTER_INC', 1)
def func(node):
node.filter_count *= 2
return node
operator.set_pheno_func(func)
self.operators.append(operator)
def addHALF(self):
operator = Operator('HALF', 1)
def func(node):
node.divide_neuron_count(2)
return node
operator.set_pheno_func(func)
self.operators.append(operator)
def addPOOL_SIZE_INC(self):
operator = Operator('POOL_SIZE_INC', 1)
def func(node):
if node.pool_size < constants.IMG_DIMENSION: # prevent out of bounds
node.pool_size += 1
return node
operator.set_pheno_func(func)
self.operators.append(operator)
def addPOOL_SIZE_DEC(self):
operator = Operator('POOL_SIZE_DEC', 1)
def func(node):
if node.pool_size > constants.POOL_SIZE_MIN: # make sure it always stays at least POOL_SIZE_MIN
node.pool_size -= 1
return node
operator.set_pheno_func(func)
self.operators.append(operator)
def addKER_SIZE_DEC(self):
operator = Operator('KER_SIZE_DEC', 1)
def func(node):
if node.kernel_size > constants.KERNEL_SIZE_MIN: # make sure kernel stays at least KERNEL_SIZE_MIN
node.kernel_size -= 2 # make sure it always stays uneven (e.g. 3, 5, 7 etc.) for convolution to work
return node
operator.set_pheno_func(func)
self.operators.append(operator)
def addFILTER_DEC(self):
operator = Operator('FILTER_DEC', 1)
def func(node):
if node.filter_count > constants.FILTER_COUNT_MIN: # make sure that it stays at least FILTER_COUNT_MIN
node.filter_count = int(node.filter_count / 2)
return node
operator.set_pheno_func(func)
self.operators.append(operator)
def addDROP_INC(self):
operator = Operator('DROP_INC', 1)
def func(node):
if node.dropout < 0.9: # make sure that it never reaches 100%
node.dropout += 0.1
return node
operator.set_pheno_func(func)
self.operators.append(operator)
def addDROP_DEC(self):
operator = Operator('DROP_DEC', 1)
def func(node):
if node.dropout > 0.1: # make sure that it never reaches 0%
node.dropout -= 0.1
return node
operator.set_pheno_func(func)
self.operators.append(operator)
def addPAR(self):
operator = Operator('PAR', 2)
def func(node, index):
next = Phenotype(index, node.neurons)
next.copy_inputs(node)
next.copy_outputs(node)
return node, next # return LEFT, RIGHT
operator.set_pheno_func(func)
self.operators.append(operator)
def addKER_SIZE_INC(self):
operator = Operator('KER_SIZE_INC', 1)
def func(node):
if node.kernel_size < constants.IMG_DIMENSION:
node.kernel_size += 2 # make sure kernel always stays uneven (e.g. 3, 5, 7 etc.) for convolution to work
if node.kernel_size > constants.IMG_DIMENSION: # addition could lead to out of bounds
node.kernel_size -= 2
return node
operator.set_pheno_func(func)
self.operators.append(operator)
def addSEQ(self):
operator = Operator('SEQ', 2)
def func(node, index):
next = Phenotype(index, node.neurons)
next.add_input(node)
next.copy_outputs(node)
for n in node.outputs:
n.inputs.remove(node)
node.outputs = []
node.add_output(next)
return node, next # return LEFT, RIGHT
operator.set_pheno_func(func)
self.operators.append(operator)
def parse_rule(sentence, scope, tnorm, snorm, cnorm):
"""
Parse a if-then string rule with variables and adjectives in scope dictionary
:param sentence: if-then rule with (mamdani/sugeno/tsukamoto) format
:param scope: scope dictionary use for parsing task
:param tnorm: norm use for and operator
:param snorm: norm use for or operator
:param cnorm: norm use for not operator
"""
assert isinstance(sentence, str), 'sentence must be a string'
from operators.operator import Operator
if ':' in sentence:
system_type, sentence, *empty_list = sentence.split(':')
else:
system_type = None
if_, then_ = sentence.split(THEN)
index = if_.index(IF)
if_ = if_[index + len(IF):]
antecedent = Operator.build_tree(if_, scope, tnorm, snorm, cnorm)
# or (EQUAL in then_ and not WITH in then_)
if system_type == 's' or (not IS in then_): # Sugeno Consequent
from rules.srule import SRule
index = then_.index(EQUAL)
consequent = then_[index + 1:]
if WITH in consequent:
consequent, weight, *rest = consequent.split(WITH)
weight = float(weight.strip())
else:
weight = 1
consequent = consequent.strip()
rule = SRule(antecedent, consequent, weight)
else: # Mamdani Consequent... predicate
then_ = then_.replace(',', ' , ')
then_ = then_.rstrip(';')
consequent, weight = _conclusion(then_.split(), scope)
if system_type == 't':
from rules.trule import TRule
return TRule(antecedent, consequent[0], weight)
from rules.mrule import MRule
rule = MRule(antecedent, consequent, weight)
return rule
def parse_rule(sentence, scope, tnorm, snorm, cnorm):
"""
Parse a if-then string rule with variables and adjectives in scope dictionary
:param sentence: if-then rule with (mamdani/sugeno/tsukamoto) format
:param scope: scope dictionary use for parsing task
:param tnorm: norm use for and operator
:param snorm: norm use for or operator
:param cnorm: norm use for not operator
"""
assert isinstance(sentence, str), 'sentence must be a string'
from operators.operator import Operator
if ':' in sentence:
system_type , sentence, *empty_list = sentence.split(':')
else:
system_type = None
if_, then_ = sentence.split(THEN)
index = if_.index(IF)
if_ = if_[index+len(IF):]
antecedent = Operator.build_tree(if_, scope, tnorm, snorm, cnorm)
# or (EQUAL in then_ and not WITH in then_)
if system_type == 's' or (not IS in then_): # Sugeno Consequent
from rules.srule import SRule
index = then_.index(EQUAL)
consequent = then_[index+1:]
if WITH in consequent:
consequent, weight, *rest = consequent.split(WITH)
weight = float(weight.strip())
else:
weight = 1
consequent = consequent.strip()
rule = SRule(antecedent, consequent, weight)
else: # Mamdani Consequent... predicate
then_ = then_.replace(',', ' , ')
then_ = then_.rstrip(';')
consequent, weight = _conclusion(then_.split(), scope)
if system_type == 't':
from rules.trule import TRule
return TRule(antecedent, consequent[0], weight)
from rules.mrule import MRule
rule = MRule(antecedent, consequent, weight)
return rule
def render_translation(self, sentence):
res = self.key
assert len(self._transforms) == len(sentence._transforms)
from operators.operator import Operator
for t, t_map in zip(reversed(self._transforms),
reversed(sentence._transforms)):
assert t['operator'] == t_map['operator'] and t[
'parameters'] == t_map['parameters']
if t['operator'] == 'raw':
break
op = Operator.from_name(t['operator'], t['parameters'])
res = op.postprocess(res, t['mapping'], self.language,
t_map['mapping'])
return res
def __init__(self):
self.operators = Operator.get_registered_operators()
