Предобработка лога событий загруженного в pandas.DataFrame
def preprocessing(df):
    tracks = [list(track.sort_values(by=["timest"], ascending=True).activity.values) for track_id, track in df.groupby(df.trace)]
    tokens = sorted(list(set(df.activity)) +['#'])
    token_to_id = {t:i for i,t in enumerate(tokens)}
    id_to_token = {i:t for i,t in enumerate(tokens)}
    MAX_LEN = max(list(map(len, tracks)))
    tracks_ix = list(map(lambda track: list(map(token_to_id.get,track)), tracks))
    for i in range(len(tracks_ix)):
        if len(tracks_ix[i]) < MAX_LEN:
            tracks_ix[i] += [token_to_id['#']]*(MAX_LEN - len(tracks_ix[i]))
    tracks_ix = np.array(tracks_ix)
    return tokens, tracks_ix, id_to_token, token_to_id
tokens, tracks_ix, id_to_token, token_to_id = preprocessing(df)

sequence = T.matrix('token sequence','int64')

Настрока архитектуры нейросети:
def model(tokens, token_to_id, neurons_num=5):
    sequence = T.matrix('token sequence','int64')
    inputs = sequence[:,:-1] # по символу предсказываю следующий, поэтому входные - все, кроме последнего
    targets = sequence[:,1:] # а выходные - все, кроме первого
    l_input_sequence = InputLayer(shape=(None, None),input_var=inputs)
    tau = theano.shared(np.float32(0.1))
    pseudo_sigmoid = GumbelSigmoid(t=tau)
    class step:
        #inputs
        h_prev = InputLayer((None, neurons_num),name='previous rnn state')
        inp = InputLayer((None,),name='current character')
        emb = EmbeddingLayer(inp, len(tokens), 30, name='emb') # сопоставление при условии минимума фции потерь
        #recurrent part
        f_dense = DenseLayer(concat([h_prev, emb]), num_units=8, nonlinearity=T.nnet.relu)    # 0 .. +inf
        s_dense = DenseLayer(f_dense, num_units=neurons_num, nonlinearity=None) # -inf .. +inf
        next_state_probs = NonlinearityLayer(s_dense, T.nnet.sigmoid) # Вероятность битов состояния
        h_new = NonlinearityLayer(s_dense, pseudo_sigmoid) # Новое состояние - вектор битов
        next_token_probas = DenseLayer(s_dense, len(tokens),nonlinearity=T.nnet.softmax) # Вероятность токена - P(Ti|Ti-1....T0)
    batch_size = sequence.shape[0]
    initial_state = InputLayer((None, neurons_num), T.zeros((batch_size, neurons_num)))
    training_loop = Recurrence(
        state_variables={step.h_new:step.h_prev},
        state_init={step.h_new:initial_state},
        input_sequences={step.inp:l_input_sequence},
        tracked_outputs=[step.next_token_probas,],
        unroll_scan=False,
    )
    weights = lasagne.layers.get_all_params(training_loop, trainable=True)
    predicted_probabilities = lasagne.layers.get_output(training_loop[step.next_token_probas])
    xent = lasagne.objectives.categorical_crossentropy(predicted_probabilities.reshape((-1,len(tokens))),
                                                   targets.reshape((-1,))).reshape(targets.shape)
    mask = T.neq(inputs, token_to_id["#"]) # оставляем только значимые токены, т.к. незначимые появились после паддинга
    loss = (mask * xent).sum(axis=1).mean() # функция ошибки
    #<Loss function - a simple categorical crossentropy will do, maybe add some regularizer>
    updates = lasagne.updates.adam(loss, weights)
    train_step = theano.function([sequence], loss,
                             updates=training_loop.get_automatic_updates()+updates)
    h_deterministic = NonlinearityLayer(step.next_state_probs, lambda x: T.gt(x, 0.5).astype(x.dtype))
    validation_loop = Recurrence(
        state_variables={h_deterministic:step.h_prev},
        state_init={h_deterministic:initial_state},
        input_sequences={step.inp:l_input_sequence},
        tracked_outputs=[step.next_token_probas,],
        unroll_scan=False,
    )
    states_seq = get_output(validation_loop[h_deterministic], {l_input_sequence:sequence})
    infer_states = theano.function([sequence], states_seq, updates=None)
    return train_step, infer_states

Обучение нейросети:
def training(tokens, tracks_ix, token_to_id, neurons_num=5, n_epochs = 25, batches_per_epoch = 250, batch_size= 10):
    train_step, infer_states = model(tokens,token_to_id)
    for epoch in range(n_epochs):
        avg_cost = 0;
        for _ in range(batches_per_epoch):
            avg_cost += train_step(sample_batch(tracks_ix, batch_size))
        print("\n\nEpoch {} average loss = {}".format(epoch, avg_cost / batches_per_epoch))
    return infer_states
infer_states = training(tokens, tracks_ix, token_to_id, 10)

Построение TS:
def build_json(filename, inferred_states, tracks_ix, neurons_num=10):
    graph = {"states":set(), "transitions":list(), "meta":{"isAccepting":set()}}
    all_states = []
    all_used_states = set()
    for binary_states in inferred_states:
        binary_states = np.vstack((np.zeros(neurons_num), binary_states)) # add initial state
        states = list(map(binary_state_to_id, binary_states))
        graph["states"].update(set(states))
        all_states.append(states)
    for states, track_ids in zip(all_states, tracks_ix):
        track = list(map(id_to_token.get, track_ids))
        for index, symbol in enumerate(track):
            transition = {"from":states[index], "to":states[index + 1], "track":symbol}
            all_used_states.add(transition["from"])
            all_used_states.add(transition["to"])
            if transition not in graph["transitions"]:
                graph["transitions"].append(transition)
        graph["meta"]["isAccepting"].add(states[len(track)])
    graph["states"] = list(all_used_states)
    graph["meta"]["isAccepting"] = list(graph["meta"]["isAccepting"])
    graph["meta"]["tracksNum"] = len(tracks_ix)
    with open(filename, "w") as json_file:
        json.dump(graph, json_file)
    return graph
inferred_states = infer_states(tracks_ix)
graph = build_json(json_filename, inferred_states, tracks_ix)
Отрисовка графа:
def build_dot(json_graph, filename):
    graph = "digraph test {\n"
    for state in json_graph["states"]:
        if state in json_graph["meta"]["isAccepting"]:
            graph += "\t" + state + " [shape=doublecircle];\n"
        else:
            graph += "\t" + state + ";\n"
    for transition in json_graph["transitions"]:
        graph += "\t" + transition["from"] + " -> " + transition["to"]
        graph += " [label="" + transition["track"] + ""];\n"
    graph += "}"
    with open(filename, "w") as graph_file:
        print(graph, file=graph_file, end="")
    return graph
dot_graph = build_dot(graph, dot_filename)