""" Basical implementation of a terminal view for World object. """ import neural_world.commons as commons import neural_world.actions as action from neural_world.individual import Individual from neural_world.nutrient import Nutrient from neural_world.neural_network import NeuralNetwork from . import observer LOGGER = commons.logger() class TerminalWorldView(observer.Observer, action.ActionEmitter): def __init__(self, engine): super().__init__(invoker=engine) self.graphics = { Nutrient: '·', Individual: '#', } def update(self, world, signals={}): """Print World in the terminal""" if len(signals) == 0 or observer.Signal.NEW_STEP in signals: print('\nstep:', world.step_number, '\tindividuals:', world.object_counter[Individual], '\tmemories:', len(NeuralNetwork.MEMORIES), NeuralNetwork.MEMORIES, '\ndirections:', NeuralNetwork.DIRECTIONS,
"""Definition of the NeuralNetworkEngine base class.""" import itertools from neural_world import commons from neural_world import default from neural_world import solving from neural_world.commons import (NeuronType, Direction, FILE_ASP_CLEANING, FILE_ASP_RUNNING) LOGGER = commons.logger(commons.SUBLOGGER_LIFE) MINIMAL_NEURON_ID = 1 class NeuralNetworkEngine: """Base class for the NeuralNetwork class. Define the underlying behavior of neural networks, as an abstract object. Each neural network figures a set of atoms, and provides an API for building new neural networks, reacting to neighbors states and cloning. A neural network is a string, containing ASP-formatted data as atoms as: - neuron(I,T): neuron of id I is of type T (T in IXANO) - output(I): neuron of id I is an output neuron - edge(I,J): there is an edge between neurons of id I and J The object assume that inputs and outputs attributes are iterables of pairs (f, n), where f is a function and n the number of neuron associated to the function. For input neurons, function takes no parameters, and should return
Individual is a class that keep together id, dna and neural networks. """ from itertools import islice, chain from collections import defaultdict import tergraw from neural_world import actions from neural_world import default from neural_world import commons from neural_world.commons import Direction from neural_world import neural_network LOGGER = commons.logger('life') class Individual: """Unit of life, having a neural network and able to move in space.""" next_individual_id = 1 # useful for give to each instance a unique id def __init__(self, neural_network:str, energy:int): # Attribution of an unique ID self.unique_id = Individual.next_individual_id Individual.next_individual_id += 1 # Life support self.neural_network = neural_network self.energy = energy def update(self, engine, neighbors, coords):
""" import time import docopt from functools import partial import neural_world.actions as action from neural_world import commons from neural_world.info import VERSION from neural_world.config import Configuration from neural_world.engine import Engine from neural_world.prompt import Prompt from neural_world.observer import (Archivist, TerminalWorldView, NullTerminalWorldView, TreeBuilder) LOGGER = commons.logger() def run_simulation(config, render_png): """Run a simulation, with CLI and many default behaviors""" # Observers v = TerminalWorldView a = partial(Archivist, archive_directory=config.dir_archive_simulation, render_graph=render_png) t = partial(TreeBuilder, archive_directory=config.dir_archive_simulation, render_graph=render_png) # Engine from rules e = Engine.generate_from(config, observers=(v, a, t))
"""Definition of generic solving routines, encapsulating ASP calls through pyasp API. """ from pyasp import asp from neural_world import commons LOGGER = commons.logger(commons.SUBLOGGER_SOLVING) # ASP SOLVING OPTIONS ASP_GRINGO_OPTIONS = '' # no default options ASP_CLASP_OPTIONS = '' # options of solving heuristics # ASP_CLASP_OPTIONS += ' -Wno-atom-undefined' # ASP_CLASP_OPTIONS += ' --configuration=frumpy' # ASP_CLASP_OPTIONS += ' --heuristic=Vsids' def model_from(base_atoms, aspfiles, aspargs={}, gringo_options='', clasp_options=''): """Compute a model from ASP source code in aspfiles, with aspargs given as grounding arguments and base_atoms given as input atoms. base_atoms -- string, ASP-readable atoms aspfiles -- (list of) filename, contains the ASP source code aspargs -- dict of constant:value that will be set as constants in aspfiles gringo_options -- string of command-line options given to gringo clasp_options -- string of command-line options given to clasp """ # use the right basename and use list of aspfiles in all cases
"""Definition of generic solving routines, encapsulating ASP calls through pyasp API. """ from pyasp import asp from neural_world import commons LOGGER = commons.logger(commons.SUBLOGGER_SOLVING) # ASP SOLVING OPTIONS ASP_GRINGO_OPTIONS = '' # no default options ASP_CLASP_OPTIONS = '' # options of solving heuristics # ASP_CLASP_OPTIONS += ' -Wno-atom-undefined' # ASP_CLASP_OPTIONS += ' --configuration=frumpy' # ASP_CLASP_OPTIONS += ' --heuristic=Vsids' def model_from(base_atoms, aspfiles, aspargs={}, gringo_options='', clasp_options=''): """Compute a model from ASP source code in aspfiles, with aspargs given as grounding arguments and base_atoms given as input atoms. base_atoms -- string, ASP-readable atoms aspfiles -- (list of) filename, contains the ASP source code aspargs -- dict of constant:value that will be set as constants in aspfiles gringo_options -- string of command-line options given to gringo clasp_options -- string of command-line options given to clasp
import random import itertools from functools import partial from collections import deque from neural_world import actions from neural_world import default from neural_world import atoms from neural_world import commons from neural_world import solving from neural_world.commons import (FILE_ASP_RUNNING, FILE_ASP_CLEANING, NeuronType, Direction) from neural_world.neural_network_engine import NeuralNetworkEngine, MINIMAL_NEURON_ID LOGGER = commons.logger(commons.SUBLOGGER_LIFE) class NeuralNetwork(NeuralNetworkEngine): """Definition of the neural network behaviors. About the memory: The input memory neurons are named input because they inject the memory value inside the network. The output memory neurons are named output because they are output of the neural running. When the neural network is ran, memory input neurons are mapped to up or down accordingly to the memory values. When an output memory neuron is up after the run, the memory value at the