impsy 0.5.0__py3-none-any.whl

impsy/__main__.py

@@ -0,0 +1,5 @@
+"""imps.__main__: executed when imps directory is called as a script."""
+
+
+from .impsy import main
+main()

impsy/dataset.py

@@ -0,0 +1,72 @@
+"""impsy.dataset: functions for generating a dataset from .log files in the log directory."""
+
+
+import numpy as np
+import pandas as pd
+import os
+import click
+
+
+def transform_log_to_sequence_example(logfile, dimension):
+    data_names = ['x'+str(i) for i in range(dimension-1)]
+    column_names = ['date', 'source'] + data_names
+    perf_df = pd.read_csv(logfile,
+                          header=None, parse_dates=True,
+                          index_col=0, names=column_names)
+    #  Filter out RNN lines, just keep 'interface'
+    perf_df = perf_df[perf_df.source == 'interface']
+    #  Process times.
+    perf_df['t'] = perf_df.index
+    perf_df.t = perf_df.t.diff()
+    perf_df.t = perf_df.t.dt.total_seconds()
+    perf_df = perf_df.dropna()
+    return np.array(perf_df[['t']+data_names])
+
+
+@click.command(name="dataset")
+@click.option("-D", "--dimension", type=int, default=2, help="The dimension of the data to model, must be >= 2.")
+@click.option("-S", "--source", type=str, default="logs", help="The source directory to obtain .log files.")
+def dataset(dimension: int, source: str):
+    """Generate a dataset from .log files in the log directory."""
+    # Load up the performances
+    log_location = f"{source}/"
+    log_file_ending = "-" + str(dimension) + "d-mdrnn.log"
+    log_arrays = []
+
+    for local_file in os.listdir(log_location):
+        if local_file.endswith(log_file_ending):
+            print("Processing:", local_file)
+            try:
+                log = transform_log_to_sequence_example(log_location + local_file,
+                                                    dimension)
+                log_arrays.append(log)
+            except Exception:
+                print("Processing failed for", local_file)        
+
+    # Save Performance Data in a compressed numpy file.
+    dataset_location = 'datasets/'
+    dataset_filename = 'training-dataset-' + str(dimension) + 'd.npz'
+
+    # Input format is:
+    # 0. 1. 2. ... n.
+    # dt x1 x2 ... xn
+
+    raw_perfs = []
+
+    acc = 0
+    time = 0
+    interactions = 0
+    for l in log_arrays:
+        acc += l.shape[0] * l.shape[1]
+        interactions += l.shape[0]
+        time += l.T[0].sum()
+        raw = l.astype('float32')  # dt, x_1, ... , x_n
+        raw_perfs.append(raw)
+
+    print("total number of values:", acc)
+    print("total number of interactions:", interactions)
+    print("total time represented:", time)
+    print("total number of perfs in raw array:", len(raw_perfs))
+    raw_perfs = np.array(raw_perfs)
+    np.savez_compressed(dataset_location + dataset_filename, perfs=raw_perfs)
+    print("done saving:", dataset_location + dataset_filename)

impsy/impsy.py

@@ -0,0 +1,22 @@
+"""impsy.impsy: provides entry point main() to impsy.""" 
+
+
+import click
+from .dataset import dataset
+from .train import train
+from .interaction import run
+from .tests import test_mdrnn
+
+@click.group()
+def cli():
+    pass
+
+
+def main():
+    """The entry point function for IMPSY, this just passes through the interfaces for each command"""
+    cli.add_command(dataset)
+    cli.add_command(train)
+    cli.add_command(run)
+    cli.add_command(test_mdrnn)
+    # runs the command line interface
+    cli()

impsy/interaction.py

@@ -0,0 +1,323 @@
+"""impsy.interaction: Functions for using imps as an interactive music system. This server has OSC input and output."""
+
+import logging
+import time
+import datetime
+import numpy as np
+import queue
+import click
+from pythonosc import dispatcher
+from pythonosc import osc_server
+from pythonosc import udp_client
+from threading import Thread
+from .utils import mdrnn_config
+
+
+np.set_printoptions(precision=2)
+
+# Interaction Modes:
+
+# user, callresponse, filter, battle. 
+# user: no AI generation, but user interaction is passed on and logged.
+# callresponse: AI responds after 'threshold' seconds, typical turn-based arrangement.
+# filter: AI responds directly to every input, could be providing second part etc.
+# battle: AI disconnected from human input, both running simultaneously.
+
+
+# Global variables
+# TODO: get rid of these, use a Class instead for data storage.
+call_response_mode = False
+user_to_rnn = False
+rnn_to_rnn = False
+rnn_to_sound = False
+last_user_interaction_time = None
+last_user_interaction_data = None
+
+
+@click.command(name="run")
+@click.option("--log/--no-log", default=True, help="Save input and output data to a log file.")
+@click.option("--verbose/--no-verbose", default=True, help="Verbose mode, print prediction results.")
+# Performance modes
+@click.option("-O", "--mode", type=str, default="callresponse", help="Select interaction mode, one of: user, callresponse, filter, battle. user: no AI generation, callresponse: AI responds after 'threshold' seconds, filter: AI responds directly to every input, battle: AI disconnected from human input")
+@click.option("-T", "--threshold", type=float, default=2.0, help="Seconds to wait before switching to response")
+# MDRNN arguments.
+@click.option("-D", "--dimension", type=int, default=2, help="The dimension of the data to model, must be >= 2.")
+@click.option("-M", "--modelsize", default="s", help="The model size: xs, s, m, l, xl", type=str)
+@click.option("-S", "--sigmatemp", type=float, default=0.01, help="The sigma temperature for sampling.")
+@click.option("-P", "--pitemp", type=float, default=1, help="The pi temperature for sampling.")
+# OSC addresses
+@click.option("--clientip", type=str, default="localhost", help="The address of output device, default is 'localhost'.")
+@click.option("--clientport", type=int, default=5000, help="The port the output device is listening on, default is 5000.")
+@click.option("--serverip", type=str, default="localhost", help="The address of this server, default is 'localhost'.")
+@click.option("--serverport", type=int, default=5001, help="The port this server should listen on, default is 5001.")
+def run(log: bool, verbose: bool, mode: str, threshold: float, dimension: int, modelsize: str, sigmatemp: float, pitemp: float, clientip: str, clientport: int, serverip:str, serverport: int):
+    """Run IMPS predictive musical interaction system as a server with OSC input and output."""
+    global call_response_mode
+    global user_to_rnn
+    global rnn_to_rnn
+    global rnn_to_sound
+    global last_user_interaction_time
+    global last_user_interaction_data
+
+    # import tensorflow, do this now to make CLI more responsive.
+    print("Importing MDRNN.")
+    start_import = time.time()
+    import impsy.mdrnn as mdrnn
+    import tensorflow.compat.v1 as tf
+    print("Done. That took", time.time() - start_import, "seconds.")
+
+    model_config = mdrnn_config(modelsize)
+    mdrnn_units = model_config["units"]
+    mdrnn_layers = model_config["layers"]
+    mdrnn_mixes = model_config["mixes"]
+
+    # Interaction Loop Parameters
+    # All set to false before setting is chosen.
+    user_to_rnn = False
+    rnn_to_rnn = False
+    rnn_to_sound = False
+
+    # Interactive Mapping
+    if mode == "callresponse":
+        print("Entering call and response mode.")
+        # set initial conditions.
+        user_to_rnn = True
+        rnn_to_rnn = False
+        rnn_to_sound = False
+    elif mode == "filter":
+        print("Entering filter mode.")
+        user_to_rnn = True
+        rnn_to_rnn = False
+        rnn_to_sound = True
+    elif mode == "battle":
+        print("Entering battle royale mode.")
+        user_to_rnn = False
+        rnn_to_rnn = True
+        rnn_to_sound = True
+    elif mode == "user":
+        print("Entering user only mode.")
+        user_to_rnn = False
+        rnn_to_rnn = False
+        rnn_to_sound = False
+
+
+    def build_network(sess):
+        """Build the MDRNN."""
+        mdrnn.MODEL_DIR = "./models/"
+        tf.keras.backend.set_session(sess)
+        with compute_graph.as_default():
+            net = mdrnn.PredictiveMusicMDRNN(mode=mdrnn.NET_MODE_RUN,
+                                                dimension=dimension,
+                                                n_hidden_units=mdrnn_units,
+                                                n_mixtures=mdrnn_mixes,
+                                                layers=mdrnn_layers)
+            net.pi_temp = pitemp
+            net.sigma_temp = sigmatemp
+        print("MDRNN Loaded.")
+        return net
+
+
+    def handle_interface_message(address: str, *osc_arguments) -> None:
+        """Handler for OSC messages from the interface"""
+        global last_user_interaction_time
+        global last_user_interaction_data
+        if verbose:
+            # print out OSC message.
+            print("User:", ', '.join(["{0:0.2f}".format(abs(i)) for i in osc_arguments]))
+        int_input = osc_arguments
+        logger = logging.getLogger("impslogger")
+        logger.info("{1},interface,{0}".format(','.join(map(str, int_input)),
+                    datetime.datetime.now().isoformat()))
+        dt = time.time() - last_user_interaction_time
+        last_user_interaction_time = time.time()
+        last_user_interaction_data = np.array([dt, *int_input])
+        assert len(last_user_interaction_data) == dimension, "Input is incorrect dimension, set dimension to %r" % len(last_user_interaction_data)
+        # These values are accessed by the RNN in the interaction loop function.
+        interface_input_queue.put_nowait(last_user_interaction_data)
+
+
+    def handle_temperature_message(address: str, *osc_arguments) -> None:
+        """Handler for temperature messages from the interface: format is ff [sigma temp, pi temp]"""
+        new_sigma_temp = osc_arguments[0]
+        new_pi_temp = osc_arguments[1]
+        if verbose:
+            print(f"Temperature -- Sigma: {new_sigma_temp}, Pi: {new_pi_temp}")
+        net.sigma_temp = new_sigma_temp
+        net.pi_temp = new_pi_temp
+
+
+    def handle_timescale_message(address: str, *osc_arguments) -> None:
+        """Handler for timescale messages: format is f [timescale]"""
+        new_timescale = osc_arguments[0]
+        if verbose:
+            print(f"Timescale: {new_timescale}")
+        # TODO: implement this on the prediction end.
+
+
+    def request_rnn_prediction(input_value):
+        """ Accesses a single prediction from the RNN. """
+        output_value = net.generate_touch(input_value)
+        return output_value
+
+
+    def make_prediction(sess, compute_graph):
+        """Interaction loop: reads input, makes predictions, outputs results."""
+        # Make predictions.
+
+        # First deal with user --> MDRNN prediction
+        if user_to_rnn and not interface_input_queue.empty():
+            item = interface_input_queue.get(block=True, timeout=None)
+            tf.keras.backend.set_session(sess)
+            with compute_graph.as_default():
+                rnn_output = request_rnn_prediction(item)
+            # if verbose:
+            #     print("User->RNN:", ",".join(["{0:0.2f}".format(float(i)) for i in rnn_output]))
+            if rnn_to_sound:
+                rnn_output_buffer.put_nowait(rnn_output)
+            interface_input_queue.task_done()
+
+        # Now deal with MDRNN --> MDRNN prediction.
+        if rnn_to_rnn and rnn_output_buffer.empty() and not rnn_prediction_queue.empty():
+            item = rnn_prediction_queue.get(block=True, timeout=None)
+            tf.keras.backend.set_session(sess)
+            with compute_graph.as_default():
+                rnn_output = request_rnn_prediction(item)
+            if verbose:
+                print("RNN: ", ', '.join(["{0:0.2f}".format(abs(i)) for i in rnn_output[1:]]), 'dt:', "{0:0.2f}".format(abs(rnn_output[0])))
+            rnn_output_buffer.put_nowait(rnn_output)  # put it in the playback queue.
+            rnn_prediction_queue.task_done()
+
+
+    def send_sound_command(command_args):
+        """Send a sound command back to the interface/synth"""
+        assert len(command_args)+1 == dimension, "Dimension not same as prediction size." # Todo more useful error.
+        osc_client.send_message(OUTPUT_MESSAGE_ADDRESS, command_args)
+
+
+    def playback_rnn_loop():
+        """Plays back RNN notes from its buffer queue."""
+        while True:
+            item = rnn_output_buffer.get(block=True, timeout=None)  # Blocks until next item is available.
+            # print("processing an rnn command", time.time())
+            dt = item[0]
+            x_pred = np.minimum(np.maximum(item[1:], 0), 1)
+            dt = max(dt, 0.001)  # stop accidental minus and zero dt.
+            time.sleep(dt)  # wait until time to play the sound
+            # put last played in queue for prediction.
+            rnn_prediction_queue.put_nowait(np.concatenate([np.array([dt]), x_pred]))
+            if rnn_to_sound:
+                send_sound_command(x_pred)
+                # print("RNN Played:", x_pred, "at", dt)
+                logger = logging.getLogger("impslogger")
+                logger.info("{1},rnn,{0}".format(','.join(map(str, x_pred)),
+                            datetime.datetime.now().isoformat()))
+            rnn_output_buffer.task_done()
+
+
+    def monitor_user_action():
+        """Handles changing action responsibility in Call-Response mode."""
+        global call_response_mode
+        global user_to_rnn
+        global rnn_to_rnn
+        global rnn_to_sound
+        # Check when the last user interaction was
+        dt = time.time() - last_user_interaction_time
+        if dt > threshold:
+            # switch to response modes.
+            user_to_rnn = False
+            rnn_to_rnn = True
+            rnn_to_sound = True
+            if call_response_mode == 'call':
+                print("switching to response.")
+                call_response_mode = 'response'
+                while not rnn_prediction_queue.empty():
+                    # Make sure there's no inputs waiting to be predicted.
+                    rnn_prediction_queue.get()
+                    rnn_prediction_queue.task_done()
+                rnn_prediction_queue.put_nowait(last_user_interaction_data)  # prime the RNN queue
+        else:
+            # switch to call mode.
+            user_to_rnn = True
+            rnn_to_rnn = False
+            rnn_to_sound = False
+            if call_response_mode == 'response':
+                print("switching to call.")
+                call_response_mode = 'call'
+                # Empty the RNN queues.
+                while not rnn_output_buffer.empty():
+                    # Make sure there's no actions waiting to be synthesised.
+                    rnn_output_buffer.get()
+                    rnn_output_buffer.task_done()
+
+
+    # Logging
+    LOG_FILE = datetime.datetime.now().isoformat().replace(":", "-")[:19] + "-" + str(dimension) + "d" +  "-mdrnn.log"  # Log file name.
+    LOG_FILE = "logs/" + LOG_FILE
+    LOG_FORMAT = '%(message)s'
+
+    if log:
+        formatter = logging.Formatter(LOG_FORMAT)
+        handler = logging.FileHandler(LOG_FILE)        
+        handler.setFormatter(formatter)
+        logger = logging.getLogger("impslogger")
+        logger.setLevel(logging.INFO)
+        logger.addHandler(handler)
+        print("Logging enabled:", LOG_FILE)
+    # Details for OSC output
+    INPUT_MESSAGE_ADDRESS = "/interface"
+    OUTPUT_MESSAGE_ADDRESS = "/prediction"
+    TEMPERATURE_MESSAGE_ADDRESS = "/temperature"
+    TIMESCALE_MESSAGE_ADDRESS = "/timescale"
+
+    # Set up runtime variables.
+    # ## Load the Model
+    compute_graph = tf.Graph()
+    with compute_graph.as_default():
+        sess = tf.Session()
+    net = build_network(sess)
+    interface_input_queue = queue.Queue()
+    rnn_prediction_queue = queue.Queue()
+    rnn_output_buffer = queue.Queue()
+    writing_queue = queue.Queue()
+    last_user_interaction_time = time.time()
+    last_user_interaction_data = mdrnn.random_sample(out_dim=dimension)
+    rnn_prediction_queue.put_nowait(mdrnn.random_sample(out_dim=dimension))
+    call_response_mode = 'call'
+
+    # Set up OSC client and server
+    osc_client = udp_client.SimpleUDPClient(clientip, clientport)
+    disp = dispatcher.Dispatcher()
+    disp.map(INPUT_MESSAGE_ADDRESS, handle_interface_message)
+    disp.map(TEMPERATURE_MESSAGE_ADDRESS, handle_temperature_message)
+    disp.map(TIMESCALE_MESSAGE_ADDRESS, handle_timescale_message)
+    server = osc_server.ThreadingOSCUDPServer((serverip, serverport), disp)
+
+    thread_running = True  # TODO: is this line needed?
+
+    # Set up run loop.
+    print("Preparing MDRNN.")
+    tf.keras.backend.set_session(sess)
+    with compute_graph.as_default():
+        net.load_model()  # try loading from default file location.
+    print("Preparting MDRNN thread.")
+    rnn_thread = Thread(target=playback_rnn_loop, name="rnn_player_thread", daemon=True)
+    print("Preparing Server thread.")
+    server_thread = Thread(target=server.serve_forever, name="server_thread", daemon=True)
+
+    try:
+        rnn_thread.start()
+        server_thread.start()
+        print("Prediction server started.")
+        print("Serving on {}".format(server.server_address))
+        while True:
+            make_prediction(sess, compute_graph)
+            if mode == "callresponse":
+                monitor_user_action()
+    except KeyboardInterrupt:
+        print("\nCtrl-C received... exiting.")
+        thread_running = False
+        rnn_thread.join(timeout=0.1)
+        server_thread.join(timeout=0.1)
+        pass
+    finally:
+        print("\nDone, shutting down.")

impsy/mdrnn/__init__.py

@@ -0,0 +1,267 @@
+"""
+EMPI MDRNN Model.
+Charles P. Martin, 2018
+University of Oslo, Norway.
+"""
+import numpy as np
+import tensorflow.compat.v1 as tf
+import mdn
+import time
+
+tf.logging.set_verbosity(tf.logging.INFO)  # set logging.
+NET_MODE_TRAIN = 'train'
+NET_MODE_RUN = 'run'
+MODEL_DIR = "./models/"
+LOG_PATH = "./logs/"
+SCALE_FACTOR = 10  # scales input and output from the model. Should be the same between training and inference.
+
+
+# Functions for slicing up data
+def slice_sequence_examples(sequence, num_steps, step_size=1):
+    """ Slices a sequence into examples of length
+        num_steps with step size step_size."""
+    xs = []
+    for i in range((len(sequence) - num_steps) // step_size + 1):
+        example = sequence[(i * step_size): (i * step_size) + num_steps]
+        xs.append(example)
+    return xs
+
+
+def seq_to_overlapping_format(examples):
+    """Takes sequences of seq_len+1 and returns overlapping
+    sequences of seq_len."""
+    xs = []
+    ys = []
+    for ex in examples:
+        xs.append(ex[:-1])
+        ys.append(ex[1:])
+    return (xs, ys)
+
+
+def seq_to_singleton_format(examples):
+    """Return the examples in seq to singleton format.
+    """
+    xs = []
+    ys = []
+    for ex in examples:
+        xs.append(ex[:-1])
+        ys.append(ex[-1])
+    return (xs, ys)
+
+
+def build_model(seq_len=30, hidden_units=256, num_mixtures=5, layers=2,
+                out_dim=2, time_dist=True, inference=False, compile_model=True,
+                print_summary=True):
+    """Builds a EMPI MDRNN model for training or inference.
+
+    Keyword Arguments:
+    seq_len : sequence length to unroll
+    hidden_units : number of LSTM units in each layer
+    num_mixtures : number of mixture components (5-10 is good)
+    layers : number of layers (2 is good)
+    out_dim : number of dimensions for the model = number of degrees of freedom + 1 (time)
+    time_dist : time distributed or not (default True)
+    inference : inference network or training (default False)
+    compile_model : compiles the model (default True)
+    print_summary : print summary after creating mdoe (default True)
+    """
+    print("Building EMPI Model...")
+    # Set up training mode
+    stateful = False
+    # batch_shape = None
+    batch_size = None
+    # Set up inference mode.
+    if inference:
+        stateful = True
+        batch_size = 1
+        #batch_shape = (1, 1, out_dim)
+    inputs = tf.keras.layers.Input(shape=(seq_len, out_dim), name='inputs',
+                                   batch_size=batch_size)
+                                # batch_shape=batch_shape)
+    lstm_in = inputs  # starter input for lstm
+    for layer_i in range(layers):
+        ret_seq = True
+        if (layer_i == layers - 1) and not time_dist:
+            # return sequences false if last layer, and not time distributed.
+            ret_seq = False
+        lstm_out = tf.keras.layers.LSTM(hidden_units, name='lstm'+str(layer_i),
+                                     return_sequences=ret_seq,
+                                     stateful=stateful)(lstm_in)
+        lstm_in = lstm_out
+
+    mdn_layer = mdn.MDN(out_dim, num_mixtures, name='mdn_outputs')
+    if time_dist:
+        mdn_layer = tf.keras.layers.TimeDistributed(mdn_layer, name='td_mdn')
+    mdn_out = mdn_layer(lstm_out)  # apply mdn
+    model = tf.keras.models.Model(inputs=inputs, outputs=mdn_out)
+
+    if compile_model:
+        loss_func = mdn.get_mixture_loss_func(out_dim, num_mixtures)
+        optimizer = tf.keras.optimizers.Adam()
+        model.compile(loss=loss_func, optimizer=optimizer)
+
+    model.summary()
+    return model
+
+
+def load_inference_model(model_file="", layers=2, units=512, mixtures=5, predict_moving=False):
+    """Returns an IMPS model loaded from a file"""
+    # TODO: make this parse the name to get the hyperparameters.
+    decoder = decoder = build_model(seq_len=1, hidden_units=units, num_mixtures=mixtures, layers=layers, time_dist=False, inference=True, compile_model=False, print_summary=True, predict_moving=predict_moving)
+    decoder.load_weights(model_file)
+    return decoder
+
+
+def random_sample(out_dim=2):
+    """ Generate a random sample in format (dt, x_1, ..., x_n), where dt is positive
+    and the x_i are between 0 and 1."""
+    output = np.random.rand(out_dim)
+    output[0] = (0.01 + (np.random.rand()-0.5)*0.005)  # TODO: see if this dt heuristic should change
+    return output
+
+
+def proc_generated_touch(x_input, out_dim=2):
+    """ Processes a generated touch in the format (dt, x)
+        such that dt > 0, and 0 <= x <= 1 """
+    dt = np.maximum(x_input[0], 0.000454)  # TODO: see if the min value of dt shoud change.
+    x_output = np.minimum(np.maximum(x_input[1:], 0), 1)
+    return np.concatenate([np.array([dt]), x_output])
+
+
+def generate_sample(model, n_mixtures, prev_sample, pi_temp=1.0, sigma_temp=0.0, out_dim=2):
+    """Generate one forward prediction from a previous sample in format
+    (dt, x_1,...,x_n). Pi and Sigma temperature are adjustable."""
+    params = model.predict(prev_sample.reshape(1, 1, out_dim) * SCALE_FACTOR)
+    new_sample = mdn.sample_from_output(params[0], out_dim, n_mixtures, temp=pi_temp, sigma_temp=sigma_temp) / SCALE_FACTOR
+    new_sample = new_sample.reshape(out_dim,)
+    return new_sample
+
+
+def generate_performance(model, n_mixtures, first_sample, time_limit=None, steps_limit=1000, pi_temp=1.0, sigma_temp=0.0, out_dim=2):
+    """Generates a performance of (dt, x) pairs, up to a step_limit.
+    Time limit is not presently implemented.
+    """
+    time = 0
+    steps = 0
+    prev_sample = first_sample
+    print(prev_sample)
+    performance = [prev_sample.reshape((out_dim,))]
+    while (steps < steps_limit):  # and time < time_limit
+        params = model.predict(prev_sample.reshape(1, 1, out_dim) * SCALE_FACTOR)
+        prev_sample = mdn.sample_from_output(params[0], out_dim, n_mixtures,
+                                             temp=pi_temp,
+                                             sigma_temp=sigma_temp)
+        prev_sample = prev_sample / SCALE_FACTOR
+        output_touch = prev_sample.reshape(out_dim,)
+        output_touch = proc_generated_touch(output_touch)
+        performance.append(output_touch.reshape((out_dim,)))
+        steps += 1
+        time += output_touch[0]
+    return np.array(performance)
+
+
+class PredictiveMusicMDRNN(object):
+    """EMPI MDRNN object for convenience in the run script."""
+
+    def __init__(self, mode=NET_MODE_TRAIN, dimension=2, n_hidden_units=128, n_mixtures=5, batch_size=100, sequence_length=120, layers=2):
+        """Initialise the MDRNN model. Use mode='run' for evaluation graph and
+        mode='train' for training graph."""
+        # network parameters
+        self.dimension = dimension
+        self.mode = mode
+        self.n_hidden_units = n_hidden_units
+        self.n_rnn_layers = layers
+        self.n_mixtures = n_mixtures  # number of mixtures
+        # Training parameters
+        self.batch_size = batch_size
+        self.sequence_length = sequence_length
+        self.val_split = 0.10
+        # Sampling hyperparameters
+        self.pi_temp = 1.5
+        self.sigma_temp = 0.01
+
+        if self.mode is NET_MODE_TRAIN:
+            self.model = build_model(seq_len=self.sequence_length,
+                                     hidden_units=self.n_hidden_units,
+                                     num_mixtures=self.n_mixtures,
+                                     layers=self.n_rnn_layers,
+                                     out_dim=self.dimension,
+                                     time_dist=True,
+                                     inference=False,
+                                     compile_model=True,
+                                     print_summary=True)
+        else:
+            self.model = build_model(seq_len=1,
+                                     hidden_units=self.n_hidden_units,
+                                     num_mixtures=self.n_mixtures,
+                                     layers=self.n_rnn_layers,
+                                     out_dim=self.dimension,
+                                     time_dist=False,
+                                     inference=True,
+                                     compile_model=False,
+                                     print_summary=True)
+
+        self.run_name = self.get_run_name()
+
+    def model_name(self):
+        """Returns the name of the present model for saving to disk"""
+        return "musicMDRNN" + "-dim" + str(self.dimension) + "-layers" + str(self.n_rnn_layers) + "-units" + str(self.n_hidden_units) + "-mixtures" + str(self.n_mixtures) + "-scale" + str(SCALE_FACTOR)
+
+    def load_model(self, model_file=None):
+        if model_file is None:
+            model_file = MODEL_DIR + self.model_name() + ".h5"
+        try:
+            self.model.load_weights(model_file)
+        except OSError as err:
+            print("OS error: {0}".format(err))
+            print("MDRNN could not be loaded from file:", model_file)
+            print("MDRNN is untrained.")
+
+    def get_run_name(self):
+        out = self.model_name() + "-"
+        out += time.strftime("%Y%m%d-%H%M%S")
+        return out
+
+    def train(self, X, y, num_epochs=10, saving=True):
+        """Train the network for the a number of epochs."""
+        # Setup callbacks
+        filepath = MODEL_DIR + self.model_name() + "-E{epoch:02d}-VL{val_loss:.2f}.hdf5"
+        checkpoint = tf.keras.callbacks.ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, mode='min')
+        terminateOnNaN = tf.keras.callbacks.TerminateOnNaN()
+        tboard = tf.keras.callbacks.TensorBoard(log_dir=LOG_PATH+self.run_name, histogram_freq=2, batch_size=32, write_graph=True, update_freq='epoch')
+        callbacks = [terminateOnNaN, tboard]
+        if saving:
+            callbacks.append(checkpoint)
+
+        # Do the data scaling in here.
+        X = np.array(X) * SCALE_FACTOR
+        y = np.array(y) * SCALE_FACTOR
+        print("Training corpus has shape:")
+        print("X:", X.shape)
+        print("y:", y.shape)
+
+        # Train
+        history = self.model.fit(X, y, batch_size=self.batch_size,
+                                 epochs=num_epochs,
+                                 validation_split=self.val_split,
+                                 callbacks=callbacks)
+        return history
+
+    def prepare_model_for_running(self):
+        """Reset RNN state."""
+        self.model.reset_states()  # reset LSTM state.
+
+    def generate_touch(self, prev_sample):
+        # TODO - do something with the session.
+        output = generate_sample(self.model, self.n_mixtures, prev_sample,
+                                 pi_temp=self.pi_temp,
+                                 sigma_temp=self.sigma_temp,
+                                 out_dim=self.dimension)
+        return output
+
+    def generate_performance(self, first_sample, number):
+        return generate_performance(self.model, self.n_mixtures,
+                                    first_sample, time_limit=None,
+                                    steps_limit=number, pi_temp=self.pi_temp,
+                                    sigma_temp=self.sigma_temp,
+                                    out_dim=self.dimension)

impsy/mdrnn/sample_data.py

@@ -0,0 +1,59 @@
+"""Manages Training Data for the Musical MDN and can generate fake datsets for testing."""
+import numpy as np
+import pandas as pd
+import random
+
+
+def batch_generator(seq_len, batch_size, dim, corpus):
+    """Returns a generator to cut up datasets into
+    batches of features and labels."""
+    # generator = batch_generator(SEQ_LEN, BATCH_SIZE, 3, corpus)
+    batch_X = np.zeros((batch_size, seq_len, dim))
+    batch_y = np.zeros((batch_size, dim))
+    while True:
+        for i in range(batch_size):
+            # choose random example
+            l = random.choice(corpus)
+            last_index = len(l) - seq_len - 1
+            start_index = np.random.randint(0, high=last_index)
+            batch_X[i] = l[start_index:start_index+seq_len]
+            batch_y[i] = l[start_index+1:start_index+seq_len+1]  # .reshape(1,dim)
+        yield batch_X, batch_y
+
+
+def generate_data():
+    """Generating some Slightly fuzzy sine wave data."""
+    NSAMPLE = 50000
+    print("Generating", str(NSAMPLE), "toy data samples.")
+    t_data = np.float32(np.array(range(NSAMPLE)) / 10.0)
+    t_interval = t_data[1] - t_data[0]
+    t_r_data = np.random.normal(0, t_interval / 20.0, size=NSAMPLE)
+    t_data = t_data + t_r_data
+    r_data = np.random.normal(size=NSAMPLE)
+    x_data = np.sin(t_data) * 1.0 + (r_data * 0.05)
+    df = pd.DataFrame({'t': t_data, 'x': x_data})
+    df.t = df.t.diff()
+    df.t = df.t.fillna(1e-4)
+    print(df.describe())
+    return np.array(df)
+
+
+def generate_synthetic_3D_data():
+    """
+    Generates some slightly fuzzy sine wave data
+    in two dimensions (plus time).
+    """
+    NSAMPLE = 50000
+    print("Generating", str(NSAMPLE), "toy data samples.")
+    t_data = np.float32(np.array(range(NSAMPLE)) / 10.0)
+    t_interval = t_data[1] - t_data[0]
+    t_r_data = np.random.normal(0, t_interval / 20.0, size=NSAMPLE)
+    t_data = t_data + t_r_data
+    r_data = np.random.normal(size=NSAMPLE)
+    x_data = (np.sin(t_data) + (r_data / 10.0) + 1) / 2.0
+    y_data = (np.sin(t_data * 3.0) + (r_data / 10.0) + 1) / 2.0
+    df = pd.DataFrame({'a': x_data, 'b': y_data, 't': t_data})
+    df.t = df.t.diff()
+    df.t = df.t.fillna(1e-4)
+    print(df.describe())
+    return np.array(df)

impsy/mdrnn/test_model.py

@@ -0,0 +1,17 @@
+from . import model
+from . import sample_data
+
+
+def train_epochs(num_epochs=1):
+    print("Training Mixture RNN for", num_epochs, "epochs")
+    net = model.MixtureRNN(mode=model.NET_MODE_TRAIN, n_hidden_units=128, n_mixtures=10, batch_size=100, sequence_length=120)
+    x_t_log = sample_data.generate_data()
+    loader = sample_data.SequenceDataLoader(num_steps=121, batch_size=100, corpus=x_t_log)
+    losses = net.train(loader, num_epochs, saving=True)
+    print("Training Done.")
+    print("Mean Losses per Batch:")
+    print(losses)
+
+
+if __name__ == "__main__":
+    train_epochs(30)

impsy/tests.py

@@ -0,0 +1,36 @@
+import click
+import time
+from .utils import mdrnn_config
+
+
+@click.command(name="test-mdrnn")
+def test_mdrnn():
+  """This command simply loads the MDRNN to test that it works and how long it takes."""
+  # import tensorflow, do this now to make CLI more responsive.
+  print("Importing MDRNN.")
+  start_import = time.time()
+  import impsy.mdrnn as mdrnn
+  import tensorflow.compat.v1 as tf
+  print("Done. That took", time.time() - start_import, "seconds.")
+
+  model_config = mdrnn_config("s")
+
+  def build_network(sess, dimension, units, mixes, layers):
+    """Build the MDRNN."""
+    mdrnn.MODEL_DIR = "./models/"
+    tf.keras.backend.set_session(sess)
+    with compute_graph.as_default():
+        net = mdrnn.PredictiveMusicMDRNN(mode=mdrnn.NET_MODE_RUN,
+                                            dimension=dimension,
+                                            n_hidden_units=units,
+                                            n_mixtures=mixes,
+                                            layers=layers)
+    print("MDRNN Loaded.")
+    return net
+
+  start_build = time.time()
+  compute_graph = tf.Graph()
+  with compute_graph.as_default():
+      sess = tf.Session()
+  build_network(sess, 4, model_config["units"], model_config["mixes"], model_config["layers"])
+  print("Done. That took", time.time() - start_build, "seconds.")

impsy/train.py

@@ -0,0 +1,140 @@
+"""impsy.train: Functions for training an impsy mdrnn model."""
+
+
+import random
+import numpy as np
+import os
+import datetime
+import click
+from .utils import mdrnn_config
+
+
+# Input and output to serial are bytes (0-255)
+# Output to Pd is a float (0-1)
+
+
+# Model Hyperparameters
+SEQ_LEN = 50
+SEQ_STEP = 1
+TIME_DIST = True
+# Training Hyperparameters:
+VAL_SPLIT = 0.10
+# Set random seed for reproducibility
+SEED = 2345
+
+
+@click.command(name="train")
+@click.option("-D", "--dimension", type=int, default=2, help="The dimension of the data to model, must be >= 2.")
+@click.option("-S", "--source", type=str, default="datasets", help="The source directory to obtain .npz dataset files.")
+@click.option("-M", "--modelsize", default="s", help="The model size: xxs, xs, s, m, l, xl.", type=str)
+@click.option("--earlystopping/--no-earlystopping", default=True, help="Use early stopping.")
+@click.option("-P", "--patience", type=int, default=10, help="The number of epochs patience for early stopping.")
+@click.option("-N", "--numepochs", type=int, default=100, help="The maximum number of epochs.")
+@click.option("-B", "--batchsize", type=int, default=64, help="Batch size for training, default=64.")
+def train(dimension: int, source: str, modelsize: str, earlystopping: bool, patience: int, numepochs: int, batchsize: int):
+    """Trains a predictive music interaction model."""
+
+    # Hack to get openMP working annoyingly.
+    os.environ['KMP_DUPLICATE_LIB_OK']='True' # TODO: is this necessary?
+    # Import IMPS MDRNN at this point so CLI is fast.
+    import impsy.mdrnn as mdrnn
+    from tensorflow.compat.v1 import keras
+    import tensorflow.compat.v1 as tf
+    # Set up environment.
+    # Only for GPU use:
+    os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+    config = tf.ConfigProto()
+    config.gpu_options.allow_growth = True
+    sess = tf.Session(config=config)
+    tf.keras.backend.set_session(sess)
+
+    model_config = mdrnn_config(modelsize)
+    mdrnn_units = model_config["units"]
+    mdrnn_layers = model_config["layers"]
+    mdrnn_mixes = model_config["mixes"]
+
+    print("Model size:", modelsize)
+    print("Units:", mdrnn_units)
+    print("Layers:", mdrnn_layers)
+    print("Mixtures:", mdrnn_mixes)
+
+    random.seed(SEED)
+    np.random.seed(SEED)
+
+    # Load dataset
+    dataset_location = f'{source}/'
+    dataset_filename = f'training-dataset-{str(dimension)}d.npz'
+
+    with np.load(dataset_location + dataset_filename, allow_pickle=True) as loaded:
+        perfs = loaded['perfs']
+
+    print("Loaded perfs:", len(perfs))
+    print("Num touches:", np.sum([len(l) for l in perfs]))
+    corpus = perfs  # might need to do some processing here...processing
+    # Restrict corpus to sequences longer than the corpus.
+    corpus = [l for l in corpus if len(l) > SEQ_LEN+1]
+    print("Corpus Examples:", len(corpus))
+    # Prepare training data as X and Y.
+    slices = []
+    for seq in corpus:
+        slices += mdrnn.slice_sequence_examples(seq,
+                                                    SEQ_LEN+1,
+                                                    step_size=SEQ_STEP)
+    X, y = mdrnn.seq_to_overlapping_format(slices)
+    X = np.array(X) * mdrnn.SCALE_FACTOR
+    y = np.array(y) * mdrnn.SCALE_FACTOR
+
+    print("Number of training examples:")
+    print("X:", X.shape)
+    print("y:", y.shape)
+
+    # Setup Training Model
+    model = mdrnn.build_model(seq_len=SEQ_LEN,
+                                hidden_units=mdrnn_units,
+                                num_mixtures=mdrnn_mixes,
+                                layers=mdrnn_layers,
+                                out_dim=dimension,
+                                time_dist=TIME_DIST,
+                                inference=False,
+                                compile_model=True,
+                                print_summary=True)
+
+    model_dir = "models/"
+    model_name = "musicMDRNN" + "-dim" + str(dimension) + "-layers" + str(mdrnn_layers) + "-units" + str(mdrnn_units) + "-mixtures" + str(mdrnn_mixes) + "-scale" + str(mdrnn.SCALE_FACTOR)
+    date_string = datetime.datetime.today().strftime('%Y%m%d-%H_%M_%S')
+
+    filepath = model_dir + model_name + "-E{epoch:02d}-VL{val_loss:.2f}.hdf5"
+    checkpoint = keras.callbacks.ModelCheckpoint(filepath,
+                                                monitor='val_loss',
+                                                verbose=1,
+                                                save_best_only=True,
+                                                mode='min')
+    terminateOnNaN = keras.callbacks.TerminateOnNaN()
+    early_stopping = keras.callbacks.EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=patience)
+    tboard = keras.callbacks.TensorBoard(log_dir='./logs/' + date_string + model_name,
+                                        histogram_freq=0,
+                                        write_graph=True,
+                                        update_freq='epoch')
+
+    callbacks = [checkpoint, terminateOnNaN, tboard]
+    if earlystopping:
+        print("Enabling Early Stopping.")
+        callbacks.append(early_stopping)
+    # Train
+    history = model.fit(X, y, batch_size=batchsize,
+                        epochs=numepochs,
+                        validation_split=VAL_SPLIT,
+                        callbacks=callbacks)
+
+    # Save final Model
+    model.save_weights(model_dir + model_name + ".h5")
+
+    # ## Converting for tensorflow lite.
+    # # Convert the model.
+    # converter = tf.lite.TFLiteConverter.from_keras_model(model)
+    # tflite_model = converter.convert()
+    # tflite_model_name = f`{model_dir}{model_name}-lite.h5`
+    # with open(tflite_model_name, 'wb') as f:
+    #   f.write(tflite_model)
+
+    print("Training done, bye.")

impsy/utils.py

@@ -0,0 +1,41 @@
+SIZE_TO_PARAMETERS = {
+  'xxs': {
+      "units": 16,
+      "mixes": 5,
+      "layers": 2,
+  },
+  'xs': {
+      "units": 32,
+      "mixes": 5,
+      "layers": 2,
+  },
+  's': {
+      "units": 64,
+      "mixes": 5,
+      "layers": 2
+    },
+  'm': {
+      "units": 128,
+      "mixes": 5,
+      "layers": 2
+    },
+  'l': {
+      "units": 256,
+      "mixes": 5,
+      "layers": 2
+    },
+  'xl': {
+      "units": 512,
+      "mixes": 5,
+      "layers": 3
+  },
+  'default': {
+    "units": 128,
+    "mixes": 5,
+    "layers": 2
+  }
+}
+
+def mdrnn_config(size: str):
+  """Get a config dictionary from a size string as used in the IMPS command line interface."""
+  return SIZE_TO_PARAMETERS[size]

impsy-0.5.0.dist-info/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright 2019 Charles P Martin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

impsy-0.5.0.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.1
+Name: impsy
+Version: 0.5.0
+Summary: IMPSY is the Interactive Musical Prediction SYstem, a tool for creative interactive intelligent musical instruments using a recurrent mixture density neural network.
+License: MIT
+Author: Charles Martin
+Author-email: cpm@charlesmartin.au
+Requires-Python: >=3.11,<3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: keras-mdn-layer (>=0.3.0,<0.4.0)
+Requires-Dist: pandas (>=2.0.3,<3.0.0)
+Requires-Dist: python-osc (>=1.8.3,<2.0.0)
+Requires-Dist: tensorflow (==2.15.0) ; sys_platform == "linux"
+Requires-Dist: tensorflow-macos (==2.15.0) ; sys_platform == "darwin"
+Requires-Dist: tensorflow-probability (==0.23.0)
+Description-Content-Type: text/markdown
+
+# IMPSY: The Interactive Musical Predictive System
+
+![MIT License](https://img.shields.io/github/license/cpmpercussion/keras-mdn-layer.svg?style=flat)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.2580176.svg)](https://doi.org/10.5281/zenodo.2580176)
+
+![Predictive Musical Interaction](https://github.com/cpmpercussion/imps/raw/master/images/predictive_interaction.png)
+
+IMPSY is a system for predicting musical control data in live performance. It uses a mixture density recurrent neural network (MDRNN) to observe control inputs over multiple time steps, predicting the next value of each step, and the time that expects the next value to occur. It provides an input and output interface over OSC and can work with musical interfaces with any number of real valued inputs (we've tried from 1-8). Several interactive paradigms are supported for call-response improvisation, as well as independent operation, and "filtering" of the performer's input. Whenever you use IMPSY, your input data is logged to build up a training corpus and a script is provided to train new versions of your model.
+
+Here's a [demonstration video showing how IMPSY can be used with different musical interfaces:](https://www.youtube.com/embed/Kdmhrp2dfHw)
+
+<!-- <iframe width="560" height="315" src="https://www.youtube.com/embed/Kdmhrp2dfHw" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe> -->
+
+## Installation
+
+IMPSY is written in Python with Keras and TensorFlow Probability, so it should work on any platform where Tensorflow can be installed. Python 3 is required and we use [Poetry](https://python-poetry.org) for managing dependencies. IMPSY currently relies on Python 3.11, TensorFlow 2.15.0, TensorFlow Probability 0.23.0, and keras-mdn-layer 0.3.0. You can see the dependencies in `pyproject.toml`.
+
+To install IMPSY, first **ensure that you have a Python 3.11** installation available, then install [Poetry](https://python-poetry.org). The poetry install instructions vary depending on your preferences for a python setup this is likely to work on Linux, macOS or Windows (WSL):
+
+    curl -sSL https://install.python-poetry.org | python3 -
+
+Then you should clone this repository or download it to your computer:
+
+    git clone https://github.com/cpmpercussion/impsy.git
+    cd impsy
+
+Then you can install the dependencies using Poetry:
+
+    poetry install
+
+Finally, you can test that IMPSY works:
+
+    poetry run ./start_impsy.py --help
+
+## How to use
+
+There are four steps for using IMPSY. First, you'll need to setup your musical interface to send it OSC data and receive predictions the same way. Then you can log data, train the MDRNN, and make predictions using our provided scripts.
+
+### 1. Connect music interface and synthesis software
+
+You'll need:
+
+- A music interface that can output data as OSC.
+- Some synthesiser software that can take OSC as input.
+
+These could be the same piece of software or hardware!
+
+You need to decide on the number of inputs (or dimension) for your predictive model. This is the number of continuous outputs from your interface plus one (for time). So for an interface with 8 faders, the dimension will be 9.
+
+Now you need your music interface to send messages to IMPSY over OSC. The default address for IMPSY is: localhost:5001. The messages to IMPSY should have the OSC address `/interface`, and then a float between 0 and 1 for each continuous output on your interface, e.g.:
+
+    /interface 0 0.5 0.23 0.87 0.9 0.7 0.45 0.654
+
+For an 8-dimensional interface.
+
+Your synthesiser software or interface needs to listen for messages from the IMPSY system as well. These have the same format with the OSC address `/prediction`. You can interpret these as interactions predicted to occur right when the message is sent.
+
+Here's an example diagram for our 8-controller example, the [xtouch mini controller](https://www.musictribe.com/Categories/Behringer/Computer-Audio/Desktop-Controllers/X-TOUCH-MINI/p/P0B3M).
+
+![Predictive Musical Interaction](https://github.com/cpmpercussion/imps/raw/master/images/IMPS_connection_example.png)
+
+In this example we've used Pd to connect the xtouch mini to IMPSY and to synthesis sounds. Our Pd mapping patch takes data from the xtouch and sends `/interface` OSC messages to IMPSY, it also receives `/prediction` OSC message back from IMPSY whenever they occur. Of course, whenever the user performs with the controller, the mapping patch sends commands to the synthesiser patch to make sound. Whenever `/prediction` messages are received, these also trigger changes in the synth patch, and we also send MIDI messages back to the xtouch controller to update its lights so that the performer knows what IMPSY is predicting.
+
+So what happens if IMPSY and the performer play at the same time? In this example, it doesn't make sense for both to control the synthesiser at the same time, so we set IMPSY to run in "call and response" mode, so that it only makes predictions when the human has stopped performing. We could also set up our mapping patch to use prediction messages for a different synth and use one of the simultaneous performance modes of IMPS.
+
+### 2. Log some training data
+
+You use the `run` command to log training data. If your interface has N inputs the dimension is N+1:
+
+    poetry run ./start_impsy run --dimension (N+1) --log
+
+This command creates files in the `logs` directory with data like this:
+
+    2019-01-17T12:37:38.109979,interface,0.3359375,0.296875,0.5078125
+    2019-01-17T12:37:38.137938,interface,0.359375,0.296875,0.53125
+    2019-01-17T12:37:38.160842,interface,0.375,0.3046875,0.1953125
+
+These CSV files have the format: timestamp, source of message (interface or rnn), x_1, x_2, ...,  x_N.
+
+You can log training data without using the RNN with the `mode` option to select "user" if you like, or use a partially trained RNN and then collect more data.
+
+    poetry run ./start_impsy run --dimension (N+1) --log -mode user
+
+Every time you use IMPS' "run" command, a new log file is created so that you can build up a significant dataset!
+
+### 3. Train an MDRNN
+
+There's two steps for training: Generate a dataset file, and train the predictive model.
+
+Use the `dataset` command:
+
+    poetry run ./start_impsy dataset --dimension (N+1)
+
+This command collates all logs of dimension N+1 from the logs directory and saves the data in a compressed `.npz` file in the datasets directory. It will also print out some information about your dataset, in particular the total number of individual interactions. To have a useful dataset, it's good to start with more than 10,000 individual interactions but YMMV.
+
+To train the model, use the `train` command---this can take a while on a normal computer, so be prepared to let your computer sit and think for a few hours! You'll have to decide what _size_ model to try to train: `xs`, `s`, `m`, `l`, `xl`. The size refers to the number of LSTM units in each layer of your model and roughly corresponds to "learning capacity" at a cost of slower training and predictions.
+It's a good idea to start with an `xs` or `s` model, and the larger models are more relevant for quite large datasets (e.g., >1M individual interactions).
+
+    poetry run ./start_impsy train --dimension (N+1) --modelsize s
+
+It's a good idea to use the `earlystopping` option to stop training after the model stops improving for 10 epochs.
+
+### 4. Perform with your predictive model
+
+Now that you have a trained model, you can run this command to start making predictions:
+
+    poetry run ./start_impsy run --dimension (N+1) --modelsize xs --log
+
+The `--log` switch logs all of your interactions as well as predictions for later re-training. (The dataset generator filters out RNN records so that you only train on human sourced data).
+
+PS: all the IMPSY commands respond to the `--help` switch to show command line options. If there's something not documented or working, it would be great if you add an issue above to let me know.
+
+## More about Mixture Density Recurrent Neural Networks
+
+IMPSY uses a mixture density recurrent neural network MDRNN to make predictions. This machine learning architecture is set up to predict the next in a sequence of multi-valued elements. The recurrent neural network uses LSTM units to remember information about past inputs and use this to help make decisions. The mixture density model at the end of the network allows continuous multi-valued elements to be sampled from a rich probability distribution. 
+
+The network is illustrated here---every time IMPSY receives an interaction message from your interface, it is sent to thorugh the LSTM layers to produce the parameters of a Gaussian mixture model. The predicted next interaction is sampled from this probability model.
+
+![A Musical MDRNN](https://github.com/cpmpercussion/imps/raw/master/images/mdn_diagram.png)
+
+The MDRNN is written in Keras and uses the [keras-mdn-layer](https://github.com/cpmpercussion/keras-mdn-layer) package. There's more info and tutorials about MDNs on [that github repo](https://github.com/cpmpercussion/keras-mdn-layer).
+

impsy-0.5.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+impsy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+impsy/__main__.py,sha256=zpRvI5LqD_MKQM20J7YFi0RWsoB9YrF6g_vOzPAv-qY,105
+impsy/dataset.py,sha256=_d6cVFPiPfB6XmlnwoUOeXvi2X-WTLr8wP3Hw5EYqSM,2639
+impsy/impsy.py,sha256=iGPym9IjH2uXUC1ehOzvwUIH6PuaWnfEvZDtWCx_j_E,499
+impsy/interaction.py,sha256=W7xyr6SzxxBGPAdYYCzwRfXHn59e52sRLqOb8WQiLZE,14005
+impsy/mdrnn/__init__.py,sha256=qB4Oq_gL75o7RW5OfWOjwl31nBFrd3rvlDCZ6CtBlMg,11147
+impsy/mdrnn/sample_data.py,sha256=dOE0JwhAxaiCCkkaszIx4TvWx9FkpI8UoXRRhML8MMw,2201
+impsy/mdrnn/test_model.py,sha256=ngrxhKeMdijt2MXmPRcFyNAEk31tyJyfzjUDcvMyhPI,587
+impsy/tests.py,sha256=Mkqhrrq5eDvuEleDqNLSh8gu1hsArvzPx2vr335_oCs,1328
+impsy/train.py,sha256=UPqzt2d8aXZ7RwJG18tGrIbwuizs9pWDdMuoXpH4wQw,5717
+impsy/utils.py,sha256=oaPL_WSTd_w2mxYG4CcrRvcbilTugZ6AYOBCIxVXgcg,682
+impsy-0.5.0.dist-info/LICENSE.md,sha256=jnbna6p-Yx2oDGjcXqA6StZU1XFF9KkvUo8QIOYjZe0,1055
+impsy-0.5.0.dist-info/METADATA,sha256=frYTmNpTsObI8Op9c-Ielrx-son9erws6nqKil-whSQ,9995
+impsy-0.5.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+impsy-0.5.0.dist-info/RECORD,,

impsy-0.5.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any