def test_input_variable(self) -> None:
iv = fl.InputVariable(name="input_variable",
description="an input variable",
minimum=0,
maximum=1,
terms=[fl.Triangle("A")])
self.assertEqual(fl.PythonExporter().to_string(iv),
fl.PythonExporter().input_variable(iv))
self.assertEqual(
fl.PythonExporter().input_variable(iv), """\
fl.InputVariable(
name="input_variable",
description="an input variable",
enabled=True,
minimum=0,
maximum=1,
lock_range=False,
terms=[fl.Triangle("A", nan, nan, nan)]
)""")
iv.terms.append(fl.Triangle("Z"))
self.assertEqual(
fl.PythonExporter().input_variable(iv), """\
fl.InputVariable(
name="input_variable",
description="an input variable",
enabled=True,
minimum=0,
maximum=1,
lock_range=False,
terms=[
fl.Triangle("A", nan, nan, nan),
fl.Triangle("Z", nan, nan, nan)
]
)""")
def test_norm(self) -> None:
self.assertEqual(fl.PythonExporter().norm(None), "None")
norm = fl.AlgebraicProduct()
self.assertEqual(fl.PythonExporter().to_string(norm),
fl.PythonExporter().norm(norm))
self.assertEqual(fl.PythonExporter().norm(norm),
"fl.AlgebraicProduct()")
def test_rule_block(self) -> None:
rb = fl.RuleBlock(name="rb", description="a rule block",
rules=[fl.Rule.create("if a then z")])
self.assertEqual(fl.PythonExporter().to_string(rb),
fl.PythonExporter().rule_block(rb))
self.assertEqual(fl.PythonExporter().rule_block(rb), """\
fl.RuleBlock(
name="rb",
description="a rule block",
enabled=True,
conjunction=None,
disjunction=None,
implication=None,
activation=None,
rules=[fl.Rule.create("if a then z")]
)""")
rb.rules.append(fl.Rule.create("if b then y"))
self.assertEqual(fl.PythonExporter().rule_block(rb), """\
fl.RuleBlock(
name="rb",
description="a rule block",
enabled=True,
conjunction=None,
disjunction=None,
implication=None,
activation=None,
rules=[
fl.Rule.create("if a then z"),
fl.Rule.create("if b then y")
]
)""")
def test_empty_engine(self) -> None:
engine = fl.Engine(name="engine", description="an engine")
self.assertEqual(fl.PythonExporter().to_string(engine),
fl.PythonExporter().engine(engine))
self.assertEqual(second=fl.PythonExporter().engine(engine),
first="""\
import fuzzylite as fl
engine = fl.Engine(
name="engine",
description="an engine"
)
engine.input_variables = []
engine.output_variables = []
engine.rule_blocks = []
""")
def export(path: str) -> None:
import io
import time
fl.lib.decimals = 9
importer = fl.FllImporter()
exporters = [
fl.FllExporter(), fl.PythonExporter(), # fl.FldExporter()
]
with io.open(path, 'r') as file:
import_fll = file.read()
engine = importer.from_string(import_fll)
file_name = file.name[file.name.rfind('/'):file.name.rfind('.')]
for exporter in exporters:
start = time.time()
if isinstance(exporter, fl.FldExporter):
exporter.to_file_from_scope(
Path("/tmp/fl/" + file_name + ".fld"), engine, 100_000)
elif isinstance(exporter, fl.FllExporter):
exporter.to_file(Path("/tmp/fl/" + file_name + ".fll"), engine)
elif isinstance(exporter, fl.PythonExporter):
exporter.to_file(Path("/tmp/fl/" + file_name + ".py"), engine)
fl.lib.logger.info(str(path) + f".fld\t{time.time() - start}")
def test_output_variable(self) -> None:
ov = fl.OutputVariable(name="output_variable",
description="an output variable",
minimum=0.0,
maximum=1.0,
terms=[fl.Triangle("A")])
self.assertEqual(fl.PythonExporter().to_string(ov),
fl.PythonExporter().output_variable(ov))
self.assertEqual(
fl.PythonExporter().output_variable(ov), """\
fl.OutputVariable(
name="output_variable",
description="an output variable",
enabled=True,
minimum=0.000,
maximum=1.000,
lock_range=False,
aggregation=None,
defuzzifier=None,
lock_previous=False,
terms=[fl.Triangle("A", nan, nan, nan)]
)""")
ov.terms.append(fl.Triangle("Z"))
self.assertEqual(
fl.PythonExporter().output_variable(ov), """\
fl.OutputVariable(
name="output_variable",
description="an output variable",
enabled=True,
minimum=0.000,
maximum=1.000,
lock_range=False,
aggregation=None,
defuzzifier=None,
lock_previous=False,
terms=[
fl.Triangle("A", nan, nan, nan),
fl.Triangle("Z", nan, nan, nan)
]
)""")
def export(file_path: str) -> None:
import io
import time
import pathlib
import importlib
import numpy as np
np.seterr(divide="ignore", invalid="ignore")
fl.lib.floating_point_type = np.float64
path = pathlib.Path(file_path)
if path.suffix == ".fll":
with io.open(path, 'r') as file:
import_fll = file.read()
engine = fl.FllImporter().from_string(import_fll)
elif path.suffix == ".py":
package: List[str] = []
for parent in path.parents:
package.append(parent.name)
if parent.name == "fuzzylite":
break
module = ".".join(reversed(package)) + f".{path.stem}"
engine = importlib.import_module(module).engine # type: ignore
else:
raise Exception(f"unknown importer of files like {path}")
exporters = [fl.FllExporter(), fl.PythonExporter(), fl.FldExporter()]
file_name = path.stem
for exporter in exporters:
start = time.time()
target_path = Path(
"/tmp/fl/") / path.parent.parent.stem / path.parent.stem
target_path.mkdir(parents=True, exist_ok=True)
fl.lib.decimals = 3
fl.lib.logger.info(str(path) + f" -> {exporter.class_name}")
if isinstance(exporter, fl.FldExporter):
fl.lib.decimals = 9
exporter.to_file_from_scope(target_path / (file_name + ".fld"),
engine, 1024)
elif isinstance(exporter, fl.FllExporter):
exporter.to_file(target_path / (file_name + ".fll"), engine)
elif isinstance(exporter, fl.PythonExporter):
exporter.to_file(target_path / (file_name + ".py"), engine)
fl.lib.logger.info(
str(path) +
f" -> {exporter.class_name}\t{time.time() - start}")
def test_defuzzifier(self) -> None:
self.assertEqual(fl.PythonExporter().defuzzifier(None), "None")
defuzzifier: fl.Defuzzifier = fl.Centroid()
self.assertEqual(fl.PythonExporter().to_string(defuzzifier),
fl.PythonExporter().defuzzifier(defuzzifier))
self.assertEqual(fl.PythonExporter().defuzzifier(defuzzifier),
"fl.Centroid(100)")
defuzzifier = fl.WeightedAverage()
self.assertEqual(fl.PythonExporter().to_string(defuzzifier),
fl.PythonExporter().defuzzifier(defuzzifier))
self.assertEqual(fl.PythonExporter().defuzzifier(defuzzifier),
"fl.WeightedAverage(\"Automatic\")")
def test_object(self) -> None:
with self.assertRaisesRegex(
ValueError,
f"expected a fuzzylite object, but found 'object'"):
fl.PythonExporter().to_string(object())
def test_activation(self) -> None:
self.assertEqual(fl.PythonExporter().activation(None), "None")
norm = fl.General()
self.assertEqual(fl.PythonExporter().to_string(norm),
fl.PythonExporter().activation(norm))
self.assertEqual(fl.PythonExporter().activation(norm), "fl.General()")
def test_rule(self) -> None:
rule = fl.Rule.create("if a then z")
self.assertEqual(fl.PythonExporter().to_string(rule),
fl.PythonExporter().rule(rule))
self.assertEqual(fl.PythonExporter().rule(rule),
"fl.Rule.create(\"if a then z\", engine)")
def test_term(self) -> None:
term: fl.Term = fl.Triangle("A", 0.0, 1.0, 2.0, 0.5)
self.assertEqual(fl.PythonExporter().to_string(term),
fl.PythonExporter().term(term))
self.assertEqual(fl.PythonExporter().term(term),
"fl.Triangle(\"A\", 0.000, 1.000, 2.000, 0.500)")
term = fl.Discrete("B", [0.0, 0.0, 0.5, 1.0, 1.0, 0.0])
self.assertEqual(fl.PythonExporter().to_string(term),
fl.PythonExporter().term(term))
self.assertEqual(
fl.PythonExporter().term(term),
"fl.Discrete(\"B\", [0.000, 0.000, 0.500, 1.000, 1.000, 0.000])")
term = fl.Function("C", "x + 1")
self.assertEqual(fl.PythonExporter().to_string(term),
fl.PythonExporter().term(term))
self.assertEqual(fl.PythonExporter().term(term),
"fl.Function.create(\"C\", \"x + 1\", engine)")
term = fl.Linear("D", [0.0, 1.0, 2.0, -fl.inf, fl.inf])
self.assertEqual(fl.PythonExporter().to_string(term),
fl.PythonExporter().term(term))
self.assertEqual(
fl.PythonExporter().term(term),
"fl.Linear(\"D\", [0.000, 1.000, 2.000, -fl.inf, fl.inf], engine)")
def test_engine(self) -> None:
engine = fl.Engine(
name="engine",
description="an engine",
input_variables=[
fl.InputVariable(name="input_variable",
description="an input variable",
minimum=0,
maximum=1,
terms=[fl.Triangle("A")])
],
output_variables=[
fl.OutputVariable(name="output_variable",
description="an output variable",
minimum=0,
maximum=1,
terms=[fl.Triangle("A")])
],
rule_blocks=[
fl.RuleBlock(name="rb",
description="a rule block",
rules=[fl.Rule.create("if a then z")])
])
self.assertEqual(fl.PythonExporter().to_string(engine),
fl.PythonExporter().engine(engine))
self.assertEqual(second=fl.PythonExporter().engine(engine),
first="""\
import fuzzylite as fl
engine = fl.Engine(
name="engine",
description="an engine"
)
engine.input_variables = [
fl.InputVariable(
name="input_variable",
description="an input variable",
enabled=True,
minimum=0,
maximum=1,
lock_range=False,
terms=[fl.Triangle("A", nan, nan, nan)]
)
]
engine.output_variables = [
fl.OutputVariable(
name="output_variable",
description="an output variable",
enabled=True,
minimum=0,
maximum=1,
lock_range=False,
aggregation=None,
defuzzifier=None,
lock_previous=False,
terms=[fl.Triangle("A", nan, nan, nan)]
)
]
engine.rule_blocks = [
fl.RuleBlock(
name="rb",
description="a rule block",
enabled=True,
conjunction=None,
disjunction=None,
implication=None,
activation=None,
rules=[fl.Rule.create("if a then z", engine)]
)
]
""")
def test_defuzzifier(self) -> None:
self.assertEqual(fl.PythonExporter().defuzzifier(None), "None")
defuzzifier = fl.Centroid()
self.assertEqual(fl.PythonExporter().to_string(defuzzifier),
fl.PythonExporter().defuzzifier(defuzzifier))
self.assertEqual(fl.PythonExporter().defuzzifier(defuzzifier), "fl.Centroid(100)")
def test_term(self) -> None:
term = fl.Triangle("A", 0.0, 1.0, 2.0, 0.5)
self.assertEqual(fl.PythonExporter().to_string(term),
fl.PythonExporter().term(term))
self.assertEqual(fl.PythonExporter().term(term),
"fl.Triangle(\"A\", 0.000, 1.000, 2.000, 0.500)")
