.. _persistence:

Persistence
====================================
Rules and fuzzy partitions can be saved and loaded using plain text. The specification for the rule file format is the same the print format of the rules.
We can extract the rules from a model using the ``ex_fuzzy.eval_tools.eval_fuzzy_model`` method, which can can return the rules in string format if the ``return_rules`` parameter is set to ``True``::



    import pandas as pd

    from sklearn import datasets
    from sklearn.model_selection import train_test_split

    import sys

    import ex_fuzzy.fuzzy_sets as fs
    import ex_fuzzy.evolutionary_fit as GA
    import ex_fuzzy.utils as  utils
    import ex_fuzzy.eval_tools as eval_tools
    import ex_fuzzy.persistence as persistence
    import ex_fuzzy.vis_rules as vis_rules

    n_gen = 5
    n_pop = 30
    nRules = 15
    nAnts = 4
    vl = 3
    fz_type_studied = fs.FUZZY_SETS.t1

    # Import some data to play with
    iris = datasets.load_iris()
    X = pd.DataFrame(iris.data, columns=iris.feature_names)
    y = iris.target

    # Split the data into a training set and a test set
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=0)

    # We create a FRBC with the precomputed partitions and the specified fuzzy set type, 
    fl_classifier = GA.BaseFuzzyRulesClassifier(nRules=nRules, linguistic_variables=precomputed_partitions, nAnts=nAnts, 
                                                n_linguist_variables=vl, fuzzy_type=fz_type_studied)
    fl_classifier.fit(X_train, y_train, n_gen=n_gen, pop_size=n_pop, checkpoints=1)

    str_rules = eval_tools.eval_fuzzy_model(fl_classifier, X_train, y_train, X_test, y_test, 
                            plot_rules=True, print_rules=True, plot_partitions=True, return_rules=True)

    # Save the rules as a plain text file
    with open('rules_iris_t1.txt', 'w') as f:
        f.write(str_rules)



The rules can be loaded from a file using the ``load_rules`` method of the ``FuzzyModel`` class::

    # Load the rules from a file
    mrule_base = persistence.load_fuzzy_rules(str_rules, precomputed_partitions)

    fl_classifier = GA.FuzzyRulesClassifier(precomputed_rules=mrule_base)

If we already created the ``FuzzyRulesClassifier`` object, we can load the rules using the ``load_master_rule_base`` method::

    fl_classifier.load_master_rule_base(mrule_base)

You can also save the best rulebase found each x steps of the genetic tuning if you set the ``checkpoint`` parameter to that x number of steps.

For the fuzzy partitions, a separate text file is needed. Each file is comprised of a section per variable, introduced as: "$$$ Linguistic variable:", after the :, we introduce the name of the variable. Each of the subsequent lpines contains the info per each of the fuzzy sets used to partitionate that variable. Those lines follow the scheme: Name, Domain, trapezoidal or gaussian membership (trap|gaus), and the parameters of the fuzzy membership. The separator between different fields is always the ,. When using a t2 partition, the parameters of the other membership function appear after the previous one. This is an example for the Iris dataset::

    $$$ Linguistic variable: sepal length (cm)
    Very Low;4.3,7.9;trap;4.3,4.3,5.0,5.36
    Low;4.3,7.9;trap;5.04,5.2,5.6,5.779999999999999
    Medium;4.3,7.9;trap;5.44,5.6,6.05,6.2749999999999995
    High;4.3,7.9;trap;5.85,6.05,6.5,6.68
    Very High;4.3,7.9;trap;6.34,6.7,7.9,7.9

    $$$ Linguistic variable: sepal width (cm)
    Very Low;2.0,4.4;trap;2.0,2.0,2.7,2.88
    Low;2.0,4.4;trap;2.72,2.8,2.95,2.995
    Medium;2.0,4.4;trap;2.91,2.95,3.1,3.1900000000000004
    High;2.0,4.4;trap;3.02,3.1,3.3083333333333345,3.405833333333335
    Very High;2.0,4.4;trap;3.221666666666667,3.4166666666666683,4.4,4.4

You can load this file using the ``load_fuzzy_variables`` function from the persistence module::

    # Load the saved fuzzy partitions from a file
    with open('iris_partitions.txt', 'r') as f:
        loaded_partitions = persistence.load_fuzzy_variables(f.read())