compiled-knowledge 4.0.0a15__cp312-cp312-win_amd64.whl → 4.0.0a17__cp312-cp312-win_amd64.whl

ck/pgm_compiler/support/circuit_table/{circuit_table_py.py → _circuit_table_py.py}

@@ -129,7 +129,7 @@ def sum_out(table: CircuitTable, rv_idxs: Iterable[int]) -> CircuitTable:
     def _result_rows() -> Iterator[Tuple[TableInstance, CircuitNode]]:
         for group, to_add in groups.items():
             _node: CircuitNode = circuit.optimised_add(to_add)
-            if not _node.is_zero():
+            if not _node.is_zero:
                 yield group, _node
 
     return CircuitTable(circuit, remaining_rv_idxs, _result_rows())
@@ -148,7 +148,7 @@ def sum_out_all(table: CircuitTable) -> CircuitTable:
         node = next(iter(table.rows.values()))
     else:
         node: CircuitNode = circuit.optimised_add(table.rows.values())
-        if node.is_zero():
+        if node.is_zero:
             return CircuitTable(circuit, ())
 
     return CircuitTable(circuit, (), [((), node)])
@@ -185,7 +185,7 @@ def product(x: CircuitTable, y: CircuitTable) -> CircuitTable:
 
     # Special case: y == 0 or 1, and has no random variables.
     if y_rv_idxs == ():
-        if len(y) == 1 and y.top().is_one():
+        if len(y) == 1 and y.top().is_one:
             return x
         elif len(y) == 0:
             return CircuitTable(circuit, x_rv_idxs)
@@ -225,7 +225,7 @@ def product(x: CircuitTable, y: CircuitTable) -> CircuitTable:
         # Rows with constant node values of one are optimised out.
         for _x_instance, _x_node in x.rows.items():
             _co = tuple(_x_instance[i] for i in co_from_x_map)
-            if _x_node.is_one():
+            if _x_node.is_one:
                 # Multiplying by one.
                 # Iterate over matching y rows.
                 for _yo, _y_node in y_index.get(_co, ()):
@@ -257,7 +257,7 @@ def _product_no_common_rvs(x: CircuitTable, y: CircuitTable) -> CircuitTable:
 
     def _result_rows() -> Iterator[Tuple[TableInstance, CircuitNode]]:
         for x_instance, x_node in x.rows.items():
-            if x_node.is_one():
+            if x_node.is_one:
                 for y_instance, y_node in y.rows.items():
                     instance = x_instance + y_instance
                     yield instance, y_node

ck/pgm_compiler/support/clusters.py

@@ -180,11 +180,11 @@ def optimal_prefix(clusters: Clusters) -> None:
 
 class Clusters:
     """
-    Holds the state of a connection graph while eliminating variables
-    to identify clusters a PGM graph.
+    A Clusters object holds the state of a connection graph while
+    eliminating variables to construct clusters for a PGM graph.
 
-    The clusters can either be in-progress, `len(Clusters.uneliminated) > 0`,
-    or be completed, `len(Clusters.uneliminated) == 0`.
+    The Clusters object can either be "in-progress" where `len(Clusters.uneliminated) > 0`,
+    or be "completed" where `len(Clusters.uneliminated) == 0`.
 
     See Adnan Darwiche, 2009, Modeling and Reasoning with Bayesian Networks, p164.
     """
@@ -229,6 +229,9 @@ class Clusters:
     @property
     def eliminated(self) -> List[int]:
         """
+        Get the list of eliminated random variables (as random variable
+        indices, in elimination order).
+
         Assumes:
             * The returned list will not be modified by the caller.
 
@@ -240,6 +243,8 @@ class Clusters:
     @property
     def uneliminated(self) -> Set[int]:
         """
+        Get the set of uneliminated random variables (as random variable indices).
+
         Assumes:
             * The returned set will not be modified by the caller.
 
@@ -285,6 +290,8 @@ class Clusters:
 
     def max_cluster_size(self) -> int:
         """
+        Calculate the maximum cluster size over all clusters.
+
         Returns:
             the maximum `len(cluster)` over all clusters.
         """
@@ -292,6 +299,11 @@ class Clusters:
 
     def max_cluster_weighted_size(self, rv_log_sizes: Sequence[float]) -> float:
         """
+        Calculate the maximum cluster weighted size over all clusters.
+
+        Args:
+            rv_log_sizes: is an array of random variable sizes, such that
+                for a random variable `rv`, `rv_log_sizes[rv.idx] = log2(len(rv))`.
         Returns:
             the maximum `sum(rv_log_sizes[rv_idx] for rv_idx in cluster)` over all clusters.
         """

ck/pgm_compiler/support/factor_tables.py

@@ -348,7 +348,7 @@ def _make_factor_table(
                 mul_vars[instance[inst_index]]
                 for inst_index, mul_vars in zip(inst_to_mul, mul_rvs_vars)
             )
-            if not node.is_one():
+            if not node.is_one:
                 to_mul += (node,)
             if len(to_mul) == 0:
                 yield instance, circuit.one

ck/pgm_compiler/support/join_tree.py

@@ -15,6 +15,11 @@ from ck.utils.np_extras import NDArrayFloat64
 
 @dataclass
 class JoinTree:
+    """
+    This is a recursive data structure representing a join-tree.
+    Each node in the join-tree is represented by a JoinTree object.
+    """
+
     # The PGM that this join tree is for.
     pgm: PGM
 
@@ -40,6 +45,12 @@ class JoinTree:
 
     def max_cluster_weighted_size(self, rv_log_sizes: Sequence[float]) -> float:
         """
+        Calculate the maximum cluster weighted size for this cluster and its children.
+
+        Args:
+            rv_log_sizes: is an array of random variable sizes, such that
+                for a random variable `rv`, `rv_log_sizes[rv.idx] = log2(len(rv))`.
+
         Returns:
             the maximum `log2` over self and all children, recursively.
         """
@@ -82,8 +93,8 @@ JoinTreeAlgorithm = Callable[[PGM], JoinTree]
 
 def _join_tree_algorithm(pgm_to_clusters: ClusterAlgorithm) -> JoinTreeAlgorithm:
     """
-    Helper function for creating a standard JoinTreeAlgorithm from
-    a ClusterAlgorithm.
+    Helper function for creating a standard JoinTreeAlgorithm
+    from a ClusterAlgorithm.
 
     Args:
         pgm_to_clusters: The clusters method to use.
@@ -112,14 +123,17 @@ MIN_TRADITIONAL_WEIGHTED_FILL: JoinTreeAlgorithm = _join_tree_algorithm(min_trad
 
 def clusters_to_join_tree(clusters: Clusters) -> JoinTree:
     """
-    Construct a join tree maker for the given PGM and random variable clusters.
+    Construct a join tree from the given random variable clusters.
 
     A join tree is formed by finding a minimum spanning tree over the clusters
-    where the cost between a pair of cluster is defined according to
-    `separator_cost_counts` and `costing`.
+    where the cost between a pair of clusters is the number of random variables
+    in common (using separator state space size to break ties).
 
     Args:
-        clusters: the clusters that resulted from graph clusters of the given PGM.
+        clusters: the clusters that resulted from graph clusters of a PGM.
+
+    Returns:
+        a JoinTree.
     """
     pgm: PGM = clusters.pgm
     cluster_sets: List[Set[int]] = clusters.clusters
@@ -170,6 +184,19 @@ def _make_spanning_tree_small_root(cost: NDArrayFloat64, clusters: List[Set[int]
     """
     Construct a minimum spanning tree over the clusters, where the root is the cluster with
     the smallest number of random variable.
+
+    Args:
+        cost: is an N x N matrix of costs between N clusters.
+        clusters: is a list of N clusters, each cluster is a set of random variable indices.
+
+    Returns:
+        (spanning_tree, root_index)
+
+        spanning_tree: is a spanning tree represented as a list of nodes, the list is coindexed with
+        the given cost matrix, each node is a list of children, each child being
+        represented as an index into the list of nodes.
+
+        root_index: is the index the chosen root of the spanning tree.
     """
     root_custer_index: int = 0
     root_size: int = len(clusters[root_custer_index])
@@ -185,10 +212,22 @@ def _make_spanning_tree_small_root(cost: NDArrayFloat64, clusters: List[Set[int]
 def _make_spanning_tree_arbitrary_root(cost: NDArrayFloat64) -> Tuple[List[List[int]], int]:
     """
     Construct a minimum spanning tree over the clusters, starting at an arbitrary root.
+
+    Args:
+        cost: is an N x N matrix of costs between N clusters.
+
+    Returns:
+        (spanning_tree, root_index)
+
+        spanning_tree: is a spanning tree represented as a list of nodes, the list is coindexed with
+        the given cost matrix, each node is a list of children, each child being
+        represented as an index into the list of nodes.
+
+        root_index: is the index the chosen root of the spanning tree.
     """
-    root_custer_index: int = 0
-    children: List[List[int]] = _make_spanning_tree_at_root(cost, root_custer_index)
-    return children, root_custer_index
+    root_index: int = 0
+    spanning_tree: List[List[int]] = _make_spanning_tree_at_root(cost, root_index)
+    return spanning_tree, root_index
 
 
 def _make_spanning_tree_at_root(
@@ -202,6 +241,12 @@ def _make_spanning_tree_at_root(
         cost: and nxn matrix where n is the number of clusters and cost[i, j]
             gives the cost between clusters i and j.
         root_custer_index: a nominated root cluster to be the root of the tree.
+
+    Returns:
+        a spanning tree represented as a list of nodes, the list is coindexed with
+        the given cost matrix, each node is a list of children, each child being
+        represented as an index into the list of nodes. The root node is the
+        index `root_custer_index` as passed to this function.
     """
     number_of_clusters: int = cost.shape[0]
 
@@ -257,7 +302,19 @@ def _form_join_tree_r(
         cluster_factors: List[List[Factor]],
 ) -> JoinTree:
     """
-    Recursively build the join tree data structure.
+    Recursively build a JoinTree from the spanning tree `children`.
+    This function merely pull the corresponding component from the
+    arguments to make a JoinTree object, doing this recursively
+    for the children.
+
+    Args:
+        pgm: the source PGM for the join tree.
+        cluster_index: index for the node we are processing (current root). This
+            indexes into `children`, `clusters`, and `cluster_factors`.
+        parent_cluster: set of random variable indices in the parent cluster.
+        children: list of spanning tree nodes, as per `_make_spanning_tree_at_root` result.
+        clusters: list of clusters, each cluster is a set of random variable indices.
+        cluster_factors: assignment of factors to clusters.
     """
     cluster: Set[int] = clusters[cluster_index]
     factors: List[Factor] = cluster_factors[cluster_index]

ck/pgm_compiler/variable_elimination.py

@@ -51,6 +51,8 @@ def compile_pgm(
 
     elimination_order: Sequence[int] = algorithm(pgm).eliminated
 
+    # Eliminate rvs from the factor tables according to the
+    # elimination order.
     cur_tables: List[CircuitTable] = list(factor_tables.tables)
     for rv_idx in elimination_order:
         next_tables: List[CircuitTable] = []

ck/utils/local_config.py

@@ -0,0 +1,270 @@
+"""
+This module provides access to local configuration variables.
+
+Local configuration variables are {variable} = {value} pairs that
+are defined externally to CK for the purposes of adapting
+to the local environment that CK is installed in. Local
+configuration variables are not expected to modify the
+behaviour of algorithms implemented in CK.
+
+The primary method to access local configuration is `get`. Various
+other getter methods wrap `get`.
+
+The `get` method will search for a value for a requested variable
+using the following steps.
+1) Check the `programmatic config` which is a dictionary that
+   can be directly updated.
+2) Check the PYTHONPATH for a module called `config` (i.e., a
+   `config.py` file) for global variables defined in that module.
+3) Check the system environment variables (`os.environ`).
+
+Variable names must be a valid Python identifier. Only valid
+value types are supported, as per the function `valid_value`.
+
+Usage:
+    from ck.utils.local_config import config
+
+    # assume `config.py` is in the PYTHONPATH and contains:
+    #    ABC = 123
+    #    DEF = 456
+
+    val = config.ABC                  # val = 123
+    val = config.XYZ                  # will raise an exception
+    val = config.get('ABC')           # val = 123
+    val = config['DEF']               # val = 456
+    val = config['XYZ']               # will raise an exception
+    val = config.get('XYZ')           # val = None
+    val = config.get('XYZ', 999)      # val = 999
+
+    from ck.utils.local_config import get_params
+
+    val = get_params('ABC')                  # val = ('ABC', 123)
+    val = get_params('ABC', 'DEF')           # val = (('ABC', 123), ('DEF', 456))
+    val = get_params('ABC', 'DEF', sep='=')  # val = ('ABC=123', 'DEF=456')
+    val = get_params('ABC;DEF', delim=';')   # val = 'ABC=123;DEF=456'
+
+"""
+
+import inspect
+import os
+from ast import literal_eval
+from itertools import chain
+from typing import Optional, Dict, Any, Sequence, Iterable
+
+from ck.utils.iter_extras import flatten
+
+try:
+    # Try to import the user's `config.py`
+    import config as _user_config
+except ImportError:
+    _user_config = None
+
+# Sentinel object
+_NIL = object()
+
+
+class Config:
+
+    def __init__(self):
+        self._programmatic_config: Dict[str, Any] = {}
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        Get the value of the given local configuration variable.
+        If the configuration variable is not available, return the given default value.
+        """
+        if not key.isidentifier():
+            raise KeyError(f'invalid local configuration parameter: {key!r}')
+
+        # Check the programmatic config
+        value = self._programmatic_config.get(key, _NIL)
+        if value is not _NIL:
+            return value
+
+        # Check config.py
+        if _user_config is not None:
+            value = vars(_user_config).get(key, _NIL)
+            if value is not _NIL:
+                if not valid_value(value):
+                    raise KeyError(f'user configuration file contains an invalid value for variable: {key!r}')
+                return value
+
+        # Check the OS environment
+        value = os.environ.get(key, _NIL)
+        if value is not _NIL:
+            return value
+
+        # Not found - return the default value
+        return default
+
+    def __contains__(self, key: str) -> bool:
+        return self.get(key, _NIL) is not _NIL
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        """
+        Programmatically overwrite a local configuration variable.
+        """
+        if not key.isidentifier():
+            raise KeyError(f'invalid local configuration parameter: {key!r}')
+        if not valid_value(value):
+            raise ValueError(f'invalid local configuration parameter value: {value!r}')
+        self._programmatic_config[key] = value
+
+    def __getitem__(self, key: str):
+        """
+        Get the value of the given configuration variable.
+        If the configuration variable is not available, raise a KeyError.
+        """
+        value = self.get(key, _NIL)
+        if value is _NIL:
+            raise KeyError(f'undefined local configuration parameter: {key}')
+        return value
+
+    def __getattr__(self, key: str):
+        """
+        Get the value of the given configuration variable.
+        If the configuration variable is not available, raise a KeyError.
+        """
+        value = self.get(key, _NIL)
+        if value is _NIL:
+            raise KeyError(f'undefined local configuration parameter: {key}')
+        return value
+
+
+# The global local config object.
+config = Config()
+
+
+def valid_value(value: Any) -> bool:
+    """
+    Does the given value have an acceptable type for
+    a configuration variable?
+    """
+    if isinstance(value, (list, tuple, set)):
+        return all(valid_value(elem) for elem in value)
+    if isinstance(value, dict):
+        return all(valid_value(elem) for elem in chain(value.keys(), value.values()))
+    if callable(value) or inspect.isfunction(value) or inspect.ismodule(value):
+        return False
+    # All tests pass
+    return True
+
+
+# noinspection PyShadowingNames
+def get_params(
+        *keys: str,
+        sep: Optional[str] = None,
+        delim: Optional[str] = None,
+        config: Config = config,
+):
+    """
+    Return one or more configuration parameter as key-value pairs.
+
+    If `sep` is None then each key-value pair is returned as a tuple, otherwise
+    each key-value pair is returned as a string with `sep` as the separator.
+
+    If `delim` is None then each key is treated as is. If one key is provided then
+    its value is returned. If multiple keys are provided, then multiple values
+    are returned in a tuple.
+
+    If `delim` is not None, then keys are split using `delim`, and results
+    are returned as a single string with `delim` as the delimiter. If
+    `delim` is not None then the default value for `sep` is '='.
+
+    For example, assume config.py contains: ABC = 123 and DEF = 456,
+    then:
+        get_params('ABC') -> ('ABC', 123)
+        get_params('ABC', 'DEF') -> ('ABC', 123), ('DEF', 456)
+        get_params('ABC', sep='=') = 'ABC=123'
+        get_params('ABC', 'DEF', sep='=') = 'ABC=123', 'DEF=456'
+        get_params('ABC;DEF', delim=';') = 'ABC=123;DEF=456'
+        get_params('ABC;DEF', sep='==', delim=';') = 'ABC==123;DEF==456'
+
+    :param keys: the names of variables to access.
+    :param sep: the separator character between {variable} and {value}.
+    :param delim: the delimiter character between key-value pairs.
+    :param config: a Config instance to update. Default is the global config.
+    """
+    if delim is not None:
+        keys = flatten(key.split(delim) for key in keys)
+        if sep is None:
+            sep = '='
+
+    if sep is None:
+        items = ((key, config[key]) for key in keys)
+    else:
+        items = (f'{key}{sep}{config[key]!r}' for key in keys)
+
+    if delim is None:
+        result = tuple(items)
+        if len(result) == 1:
+            result = result[0]
+    else:
+        result = delim.join(str(item) for item in items)
+
+    return result
+
+
+# noinspection PyShadowingNames
+def update_config(
+        argv: Sequence[str],
+        valid_keys: Optional[Iterable[str]] = None,
+        *,
+        sep: str = '=',
+        strip_whitespace: bool = True,
+        config: Config = config,
+) -> None:
+    """
+    Programmatically overwrite a local configuration variable from a command line `argv`.
+
+    Variable values are interpreted as per a Python literal.
+
+    Example usage:
+        import sys
+        from ck.utils.local_config import update_config
+
+        def main():
+            ...
+
+        if __name__ == '__main__':
+            update_config(sys.argv, ['in_name', 'out_name'])
+            main()
+
+    :param argv: a collection of strings in the form '{variable}={value}'.
+        Variables not in `valid_keys` will raise a ValueError.
+    :param valid_keys: an optional collection of strings that are valid variables to
+        process from argv, or None to accept all variables.
+    :param sep: the separator character between {variable} and {value}.
+        Defaults is '='.
+    :param strip_whitespace: If True, then whitespace is stripped from
+        the value before updating the config. Whitespace is always stripped
+        from the variable name.
+    :param config: a Config instance to update. Default is the global config.
+    """
+    if valid_keys is not None:
+        valid_keys = set(valid_keys)
+
+    for arg in argv:
+        var_val = str(arg).split(sep, maxsplit=1)
+        if len(var_val) != 2:
+            raise ValueError(f'cannot split argument: {arg!r} using separator {sep!r}')
+
+        var, val = var_val
+        var = var.strip()
+        if strip_whitespace:
+            val = val.strip()
+
+        if valid_keys is not None and var not in valid_keys:
+            raise KeyError(f'invalid key: {arg!r}')
+
+        try:
+            interpreted = literal_eval(val)
+        except (ValueError, SyntaxError) as err:
+            # Some operating systems strip quotes off
+            # strings, so we try to recover.
+            if '"' in val or "'" in val:
+                # Too hard... forget it.
+                raise err
+            interpreted = str(val)
+
+        config[var] = interpreted

ck_demos/pgm_compiler/compare_pgm_compilers.py

@@ -16,6 +16,7 @@ from ck_demos.utils.compare import compare
 CACHE_CIRCUITS: bool = True
 BREAK_BETWEEN_PGMS: bool = True
 COMMA_NUMBERS: bool = True
+PRINT_HEADER: bool = True
 
 PGMS: Sequence[PGM] = [
     example.Rain(),
@@ -52,6 +53,7 @@ def main() -> None:
         cache_circuits=CACHE_CIRCUITS,
         break_between_pgms=BREAK_BETWEEN_PGMS,
         comma_numbers=COMMA_NUMBERS,
+        print_header=PRINT_HEADER,
     )
     print()
     print('Done.')

ck_demos/pgm_compiler/demo_compiler_dump.py

@@ -9,6 +9,16 @@ from ck.pgm_compiler.support.join_tree import JoinTree, clusters_to_join_tree
 
 
 def main() -> None:
+    """
+    This demo shows the full compilation chain for factor elimination.
+
+    Process:
+        Rain example -> PGM
+        min_degree -> Clusters
+        clusters_to_join_tree -> JoinTree
+        join_tree_to_circuit -> PGMCircuit
+        default circuit compiler -> WMCProgram
+    """
     pgm: PGM = example.Rain()
 
     print(f'PGM {pgm.name!r}')

ck_demos/pgm_compiler/time_fe_compiler.py

@@ -0,0 +1,93 @@
+from ck import example
+from ck.circuit import CircuitNode, Circuit
+from ck.circuit_compiler import DEFAULT_CIRCUIT_COMPILER
+from ck.pgm import PGM
+from ck.pgm_circuit import PGMCircuit
+from ck.pgm_compiler.factor_elimination import DEFAULT_PRODUCT_SEARCH_LIMIT, _circuit_tables_from_join_tree
+from ck.pgm_compiler.support.circuit_table import CircuitTable
+from ck.pgm_compiler.support.clusters import min_degree, Clusters
+from ck.pgm_compiler.support.factor_tables import FactorTables, make_factor_tables
+from ck.pgm_compiler.support.join_tree import JoinTree, clusters_to_join_tree
+from ck.program import ProgramBuffer, RawProgram
+from ck_demos.utils.stop_watch import timer
+
+
+def main() -> None:
+    """
+    Time components of the compilation chain for factor elimination.
+
+    Process:
+        example -> PGM
+        min_degree -> Clusters
+        clusters_to_join_tree -> JoinTree
+        join_tree_to_circuit -> PGMCircuit
+        default circuit compiler -> RawProgram
+        execute program
+    """
+    with timer('make PGM') as make_pgm_time:
+        pgm: PGM = example.Mildew()
+
+    with timer('make clusters') as make_clusters_time:
+        clusters: Clusters = min_degree(pgm)
+
+    with timer('make join tree') as make_join_tree_time:
+        join_tree: JoinTree = clusters_to_join_tree(clusters)
+
+    with timer('make factor tables') as make_factor_tables_time:
+        factor_tables: FactorTables = make_factor_tables(
+            pgm=pgm,
+            const_parameters=True,
+            multiply_indicators=True,
+            pre_prune_factor_tables=False,
+        )
+
+    with timer('make circuit tables') as make_circuit_tables_time:
+        top_table: CircuitTable = _circuit_tables_from_join_tree(
+            factor_tables,
+            join_tree,
+            DEFAULT_PRODUCT_SEARCH_LIMIT,
+        )
+    top: CircuitNode = top_table.top()
+    circuit: Circuit = top.circuit
+
+    orig_size = circuit.number_of_op_nodes
+    with timer('remove unreachable nodes') as remove_unreachable_time:
+        circuit.remove_unreachable_op_nodes(top)
+    print(f'    saving  {orig_size - circuit.number_of_op_nodes:10,}')
+    print(f'    leaving {circuit.number_of_op_nodes:10,}')
+
+    with timer('make PGMCircuit') as make_pgm_time:
+        pgm_circuit = PGMCircuit(
+            rvs=tuple(pgm.rvs),
+            conditions=(),
+            circuit_top=top,
+            number_of_indicators=factor_tables.number_of_indicators,
+            number_of_parameters=factor_tables.number_of_parameters,
+            slot_map=factor_tables.slot_map,
+            parameter_values=factor_tables.parameter_values,
+        )
+
+    with timer('make program') as make_program_time:
+        program: RawProgram = DEFAULT_CIRCUIT_COMPILER(pgm_circuit.circuit_top)
+
+    program_buffer = ProgramBuffer(program)
+    with timer('execute program') as execute_program_time:
+        program_buffer.compute()
+
+    print()
+    print(f'make PGM            {make_pgm_time.seconds():5.2f}')
+    print(f'make clusters       {make_clusters_time.seconds():5.2f}')
+    print(f'make join_tree      {make_join_tree_time.seconds():5.2f}')
+    print(f'make factor tables  {make_factor_tables_time.seconds():5.2f}')
+    print(f'make circuit tables {make_circuit_tables_time.seconds():5.2f}')
+    print(f'remove unreachables {remove_unreachable_time.seconds():5.2f}')
+    print(f'make PGM circuit    {make_pgm_time.seconds():5.2f}')
+    print(f'make program        {make_program_time.seconds():5.2f}')
+    print(f'execute program     {execute_program_time.seconds():5.2f}')
+
+    print()
+    print('Done.')
+
+
+if __name__ == '__main__':
+    main()