source: framspy/FramsticksLib.py @ 1199

Last change on this file since 1199 was 1199, checked in by Maciej Komosinski, 18 months ago

Cosmetic

File size: 13.3 KB
Line 
1from typing import List  # to be able to specify a type hint of list(something)
2import json
3import sys, os
4import argparse
5import numpy as np
6import frams
7
8
9class FramsticksLib:
10        """Communicates directly with Framsticks library (.dll or .so or .dylib).
11        You can perform basic operations like mutation, crossover, and evaluation of genotypes.
12        This way you can perform evolution controlled by python as well as access and manipulate genotypes.
13        You can even design and use in evolution your own genetic representation implemented entirely in python,
14        or access and control the simulation and simulated creatures step by step.
15
16        Should you want to modify or extend this class, first see and test the examples in frams-test.py.
17
18        You need to provide one or two parameters when you run this class: the path to Framsticks where .dll/.so/.dylib resides
19        and, optionally, the name of the Framsticks dll/so/dylib (if it is non-standard). See::
20                FramsticksLib.py -h"""
21
22        PRINT_FRAMSTICKS_OUTPUT: bool = False  # set to True for debugging
23        DETERMINISTIC: bool = False  # set to True to have the same results in each run
24
25        GENOTYPE_INVALID = "/*invalid*/"  # this is how genotype invalidity is represented in Framsticks
26        EVALUATION_SETTINGS_FILE = [  # all files MUST be compatible with the standard-eval expdef. The order they are loaded in is important!
27                "eval-allcriteria.sim",  # a good trade-off in performance sampling period ("perfperiod") for vertpos and velocity
28                # "deterministic.sim",  # turns off random noise (added for robustness) so that each evaluation yields identical performance values (causes "overfitting")
29                # "sample-period-2.sim", # short performance sampling period so performance (e.g. vertical position) is sampled more often
30                # "sample-period-longest.sim",  # increased performance sampling period so distance and velocity are measured rectilinearly
31        ]
32
33
34        # This function is not needed because in python, "For efficiency reasons, each module is only imported once per interpreter session."
35        # @staticmethod
36        # def getFramsModuleInstance():
37        #       """If some other party needs access to the frams module to directly access or modify Framsticks objects,
38        #       use this function to avoid importing the "frams" module multiple times and avoid potentially initializing
39        #       it many times."""
40        #       return frams
41
42        def __init__(self, frams_path, frams_lib_name, sim_settings_files):
43                if frams_lib_name is None:
44                        frams.init(frams_path)  # could add support for setting alternative directories using -D and -d
45                else:
46                        frams.init(frams_path, "-L" + frams_lib_name)  # could add support for setting alternative directories using -D and -d
47
48                print('Available objects:', dir(frams))
49                print()
50
51                print('Performing a basic test 1/2... ', end='')
52                simplest = self.getSimplest("1")
53                assert simplest == "X" and type(simplest) is str
54                print('OK.')
55                print('Performing a basic test 2/2... ', end='')
56                assert self.isValid(["X[0:0],", "X[0:0]", "X[1:0]"]) == [False, True, False]
57                print('OK.')
58                if not self.DETERMINISTIC:
59                        frams.Math.randomize()
60                frams.Simulator.expdef = "standard-eval"  # this expdef (or fully compatible) must be used by EVALUATION_SETTINGS_FILE
61                if sim_settings_files is not None:
62                        self.EVALUATION_SETTINGS_FILE = sim_settings_files
63                print('Using settings:', self.EVALUATION_SETTINGS_FILE)
64                assert isinstance(self.EVALUATION_SETTINGS_FILE, list)  # ensure settings file(s) are provided as a list
65               
66                for simfile in self.EVALUATION_SETTINGS_FILE:
67                        ec = frams.MessageCatcher.new()  # catch potential errors, warnings, messages - just to detect if there are ERRORs
68                        ec.store = 2; # store all, because they are caught by MessageCatcher and will not appear on console (which we want)
69                        frams.Simulator.ximport(simfile, 4 + 8 + 16)
70                        ec.close()
71                        print(ec.messages) # output all caught messages
72                        if ec.error_count._value() > 0:
73                                raise ValueError("Problem while importing file '%s'" % simfile) # make missing files or incorrect paths fatal because they would not stop Framsticks from further processing, and error messages are easy to overlook in output
74
75
76        def getSimplest(self, genetic_format) -> str:
77                return frams.GenMan.getSimplest(genetic_format).genotype._string()
78
79
80        def evaluate(self, genotype_list: List[str]):
81                """
82                Returns:
83                        List of dictionaries containing the performance of genotypes evaluated using self.EVALUATION_SETTINGS_FILE.
84                        Note that for whatever reason (e.g. incorrect genotype), the dictionaries you will get may be empty or
85                        partially empty and may not have the fields you expected, so handle such cases properly.
86                """
87                assert isinstance(genotype_list, list)  # because in python, str has similar capabilities as list and here it would pretend to work too, so to avoid any ambiguity
88
89                if not self.PRINT_FRAMSTICKS_OUTPUT:
90                        ec = frams.MessageCatcher.new()  # mute potential errors, warnings, messages
91
92                frams.GenePools[0].clear()
93                for g in genotype_list:
94                        frams.GenePools[0].add(g)
95                frams.ExpProperties.evalsavefile = ""  # no need to store results in a file - we will get evaluations directly from Genotype's "data" field
96                frams.Simulator.init()
97                frams.Simulator.start()
98
99                # step = frams.Simulator.step  # cache reference to avoid repeated lookup in the loop (just for performance)
100                # while frams.Simulator.running._int():  # standard-eval.expdef sets running to 0 when the evaluation is complete
101                #       step()
102                frams.Simulator.eval("while(Simulator.running) Simulator.step();")  # fastest
103                # Timing for evaluating a single simple creature 100x:
104                # - python step without caching: 2.2s
105                # - python step with caching   : 1.6s
106                # - pure FramScript and eval() : 0.4s
107
108                if not self.PRINT_FRAMSTICKS_OUTPUT:
109                        if ec.error_count._value() > 0:  # errors are important and should not be ignored, at least display how many
110                                print("[ERROR]", ec.error_count, "error(s) and", ec.warning_count-ec.error_count, "warning(s) while evaluating", len(genotype_list), "genotype(s)")
111                        ec.close()
112
113                results = []
114                for g in frams.GenePools[0]:
115                        serialized_dict = frams.String.serialize(g.data[frams.ExpProperties.evalsavedata._value()])
116                        evaluations = json.loads(serialized_dict._string())  # Framsticks native ExtValue's get converted to native python types such as int, float, list, str.
117                        # now, for consistency with FramsticksCLI.py, add "num" and "name" keys that are missing because we got data directly from Genotype, not from the file produced by standard-eval.expdef's function printStats(). What we do below is what printStats() does.
118                        result = {"num": g.num._value(), "name": g.name._value(), "evaluations": evaluations}
119                        results.append(result)
120
121                return results
122
123
124        def mutate(self, genotype_list: List[str]) -> List[str]:
125                """
126                Returns:
127                        The genotype(s) of the mutated source genotype(s). self.GENOTYPE_INVALID for genotypes whose mutation failed (for example because the source genotype was invalid).
128                """
129                assert isinstance(genotype_list, list)  # because in python, str has similar capabilities as list and here it would pretend to work too, so to avoid any ambiguity
130
131                mutated = []
132                for g in genotype_list:
133                        mutated.append(frams.GenMan.mutate(frams.Geno.newFromString(g)).genotype._string())
134                assert len(genotype_list) == len(mutated), "Submitted %d genotypes, received %d validity values" % (len(genotype_list), len(mutated))
135                return mutated
136
137
138        def crossOver(self, genotype_parent1: str, genotype_parent2: str) -> str:
139                """
140                Returns:
141                        The genotype of the offspring. self.GENOTYPE_INVALID if the crossing over failed.
142                """
143                return frams.GenMan.crossOver(frams.Geno.newFromString(genotype_parent1), frams.Geno.newFromString(genotype_parent2)).genotype._string()
144
145
146        def dissimilarity(self, genotype_list: List[str], method: int) -> np.ndarray:
147                """
148                        :param method: -1 = genetic Levenshtein distance; 0, 1, 2 = phenetic dissimilarity (SimilMeasureGreedy, SimilMeasureHungarian, SimilMeasureDistribution)
149                        :return: A square array with dissimilarities of each pair of genotypes.
150                """
151                assert isinstance(genotype_list, list)  # because in python, str has similar capabilities as list and here it would pretend to work too, so to avoid any ambiguity
152
153                # if you want to override what EVALUATION_SETTINGS_FILE sets, you can do it below:
154                # frams.SimilMeasureHungarian.simil_partgeom = 1
155                # frams.SimilMeasureHungarian.simil_weightedMDS = 1
156
157                n = len(genotype_list)
158                square_matrix = np.zeros((n, n))
159
160                if method in (0, 1, 2):  # Framsticks phenetic dissimilarity methods
161                        frams.SimilMeasure.simil_type = method
162                        genos = []  # prepare an array of Geno objects so that we don't need to convert raw strings to Geno objects all the time in loops
163                        for g in genotype_list:
164                                genos.append(frams.Geno.newFromString(g))
165                        frams_evaluateDistance = frams.SimilMeasure.evaluateDistance  # cache function reference for better performance in loops
166                        for i in range(n):
167                                for j in range(n):  # maybe calculate only one triangle if you really need a 2x speedup
168                                        square_matrix[i][j] = frams_evaluateDistance(genos[i], genos[j])._double()
169                elif method == -1:
170                        import Levenshtein
171                        for i in range(n):
172                                for j in range(n):  # maybe calculate only one triangle if you really need a 2x speedup
173                                        square_matrix[i][j] = Levenshtein.distance(genotype_list[i], genotype_list[j])
174                else:
175                        raise Exception("Don't know what to do with dissimilarity method = %d" % method)
176
177                for i in range(n):
178                        assert square_matrix[i][i] == 0, "Not a correct dissimilarity matrix, diagonal expected to be 0"
179                non_symmetric_diff = square_matrix - square_matrix.T
180                non_symmetric_count = np.count_nonzero(non_symmetric_diff)
181                if non_symmetric_count > 0:
182                        non_symmetric_diff_abs = np.abs(non_symmetric_diff)
183                        max_pos1d = np.argmax(non_symmetric_diff_abs)  # location of the largest discrepancy
184                        max_pos2d_XY = np.unravel_index(max_pos1d, non_symmetric_diff_abs.shape)  # 2D coordinates of the largest discrepancy
185                        max_pos2d_YX = max_pos2d_XY[1], max_pos2d_XY[0]  # 2D coordinates of the largest discrepancy mirror
186                        worst_guy_XY = square_matrix[max_pos2d_XY]  # this distance and the other below (its mirror) are most different
187                        worst_guy_YX = square_matrix[max_pos2d_YX]
188                        print("[WARN] Dissimilarity matrix: expecting symmetry, but %g out of %d pairs were asymmetrical, max difference was %g (%g %%)" %
189                              (non_symmetric_count / 2,
190                               n * (n - 1) / 2,
191                               non_symmetric_diff_abs[max_pos2d_XY],
192                               non_symmetric_diff_abs[max_pos2d_XY] * 100 / ((worst_guy_XY + worst_guy_YX) / 2)))  # max diff is not necessarily max %
193                return square_matrix
194
195
196        def isValid(self, genotype_list: List[str]) -> List[bool]:
197                assert isinstance(genotype_list, list)  # because in python, str has similar capabilities as list and here it would pretend to work too, so to avoid any ambiguity
198                valid = []
199                for g in genotype_list:
200                        valid.append(frams.Geno.newFromString(g).is_valid._int() == 1)
201                assert len(genotype_list) == len(valid), "Tested %d genotypes, received %d validity values" % (len(genotype_list), len(valid))
202                return valid
203
204
205def parseArguments():
206        parser = argparse.ArgumentParser(description='Run this program with "python -u %s" if you want to disable buffering of its output.' % sys.argv[0])
207        parser.add_argument('-path', type=ensureDir, required=True, help='Path to the Framsticks library (.dll or .so or .dylib) without trailing slash.')
208        parser.add_argument('-lib', required=False, help='Library name. If not given, "frams-objects.dll" (or .so or .dylib) is assumed depending on the platform.')
209        parser.add_argument('-simsettings', required=False, help='The name of the .sim file with settings for evaluation, mutation, crossover, and similarity estimation. If not given, "eval-allcriteria.sim" is assumed by default. Must be compatible with the "standard-eval" expdef.')
210        parser.add_argument('-genformat', required=False, help='Genetic format for the demo run, for example 4, 9, or S. If not given, f1 is assumed.')
211        return parser.parse_args()
212
213
214def ensureDir(string):
215        if os.path.isdir(string):
216                return string
217        else:
218                raise NotADirectoryError(string)
219
220
221if __name__ == "__main__":
222        # A demo run.
223
224        # TODO ideas:
225        # - check_validity with three levels (invalid, corrected, valid)
226        # - a pool of binaries running simultaneously, balance load - in particular evaluation
227
228        parsed_args = parseArguments()
229        framsLib = FramsticksLib(parsed_args.path, parsed_args.lib, parsed_args.simsettings)
230
231        print("Sending a direct command to Framsticks library that calculates \"4\"+2 yields", frams.Simulator.eval("return \"4\"+2;"))
232
233        simplest = framsLib.getSimplest('1' if parsed_args.genformat is None else parsed_args.genformat)
234        print("\tSimplest genotype:", simplest)
235        parent1 = framsLib.mutate([simplest])[0]
236        parent2 = parent1
237        MUTATE_COUNT = 10
238        for x in range(MUTATE_COUNT):  # example of a chain of 10 mutations
239                parent2 = framsLib.mutate([parent2])[0]
240        print("\tParent1 (mutated simplest):", parent1)
241        print("\tParent2 (Parent1 mutated %d times):" % MUTATE_COUNT, parent2)
242        offspring = framsLib.crossOver(parent1, parent2)
243        print("\tCrossover (Offspring):", offspring)
244        print('\tDissimilarity of Parent1 and Offspring:', framsLib.dissimilarity([parent1, offspring], 1)[0, 1])
245        print('\tPerformance of Offspring:', framsLib.evaluate([offspring]))
246        print('\tValidity of Parent1, Parent 2, and Offspring:', framsLib.isValid([parent1, parent2, offspring]))
Note: See TracBrowser for help on using the repository browser.