temp.py

from simple import *
import copy
import operator
np.set_printoptions(suppress=True)

class Circularray:

    def __init__(self, nb_cols=8):
        self._nb_cols = nb_cols
        self.columns = np.zeros(nb_cols)

    def _generic_op(f):
        def _(self, other):
            ret = copy.deepcopy(self)
            ret.columns = f(ret.columns, other)
            return ret
        return _

    __add__ = __radd__ = _generic_op(operator.add)
    __sub__ = __rsub__ = _generic_op(operator.sub)
    __mul__ = __rmul__ = _generic_op(operator.mul)
    __truediv__ = __rtruediv__ = _generic_op(operator.truediv)
    __floordiv__ = __rfloordiv__ = _generic_op(operator.floordiv)
    __mod__ = __rmod__ = _generic_op(operator.mod)

    del _generic_op

    def circadd(self, other, start=0):
        for i, val in enumerate(other):
            self[start + i] += val

    def circsub(self, other, start=0):
        for i, val in enumerate(other):
            self[start + i] -= val

    def __getitem__(self, idx):
        return self.columns[idx % self._nb_cols]

    def __setitem__(self, idx, data):
        self.columns[idx % self._nb_cols] = data

    def __matmul__(self, other):
        return sum(x * y for x, y in zip(self, other))

    def __rmatmul__(self, other):
        return sum(x * y for x, y in zip(other, self))

    def __repr__(self):
        string_formatted = np.array2string(self.columns, separator=', ', suppress_small=True)
        return f"circularray{self._nb_cols}({string_formatted})"

    __array_priority__ = 10000

##




##

# eb_pbl = np.eye(9)
# eb_pbl[0, :] = 0
# eb_pbr = np.eye(9)
# eb_pbr[-1, :] = 0
#
# pbl_eb = np.roll(np.eye(9), -1, axis=1)
# pbl_eb[0, :] = 0
# pbr_eb = np.roll(np.eye(9), 1, axis=1)
# pbr_eb[-1, :] = 0
#
# ##
#
# eb = Circularray(8)
# pbl = np.zeros(9)
# pbr = np.zeros(9)
#
# for i in range(8):
#     eb[i] = i+1
#
# pbl[:] = eb@eb_pbl
# pbr[:] = eb@eb_pbr
#
# print("E-PG:")
# print(f"left bridge:     {pbl}")
# print(f"ellipsoid body:  {eb.columns}")
# print(f"right bridge:    {pbr}")
#

##
#
# eb_l = Circularray(8)
# eb_r = Circularray(8)
# pbl = np.zeros(9)
# pbr = np.zeros(9)
#
# for i in range(9):
#     pbl[i] = i+1
#     pbr[i] = i+1
#
# eb_update_l = pbl_eb@pbl
# eb_update_r = pbr_eb@pbr
#
#
# eb_l.circadd(eb_update_l)
# eb_r.circadd(eb_update_r)
#
#
# print("P-EN:")
# print(f"left bridge:     {pbl}")
# print(f"ellipsoid body:  {eb_l.columns}")
# print(f"ellipsoid body:  {eb_r.columns}")
# print(f"right bridge:    {pbr}")

##

class test:

    def __init__(self):
        self.N_EB = 8
        self.N_PB = 9

        # glomeruli values
        self.eb = Circularray(self.N_EB)
        self.pbl = np.zeros(self.N_PB)
        self.pbr = np.zeros(self.N_PB)

        # connectivity matrices
        self.eb_pbl = np.eye(self.N_PB)
        self.eb_pbl[0, :] = 0
        self.eb_pbr = np.eye(self.N_PB)
        self.eb_pbr[-1, :] = 0

        self.pbl_eb = np.roll(np.eye(self.N_PB), -1, axis=1)
        self.pbl_eb[0, :] = 0
        self.pbr_eb = np.roll(np.eye(self.N_PB), 1, axis=1)
        self.pbr_eb[-1, :] = 0

        # initialise the values
        a = (1 - np.cos(np.linspace(0, 2*np.pi, self.N_EB, endpoint=False))) * 0.5
        for i in range(self.N_EB):
            # self.eb[i] = a[i]
            self.eb[i] = 0

        self.pbl[:] = self.eb@self.eb_pbl
        self.pbr[:] = self.eb@self.eb_pbr

        self.weights_ring = self._gen_ring_attractor()

    def _gen_ring_attractor(self):

        # Generate N_EB values between 0 and 2π
        x_values = np.linspace(0, 2 * np.pi, self.N_EB, endpoint=False)
        sinus = np.sin(x_values)

        # Each row is shifted by 1 column
        weights = np.zeros([self.N_EB, self.N_EB])
        for i in range(self.N_EB):
            weights[i, :] = np.roll(sinus, i)

        # Roll everything left so that the diagonal is 1
        weights = np.roll(weights, -np.argmax(weights[0]), axis=1)

        return rescale(weights, -1, 0)

    def update(self, turnspeed):

        # eb_update_l = self.pbl_eb @ self.pbl
        # eb_update_r = self.pbr_eb @ self.pbr

        # self.pbl[0] += 0.003
        # self.pbl[-1] += 0.003
        #
        # self.pbr[0] += 0.003
        # self.pbr[-1] += 0.003
        #
        # test_l = np.zeros(8)
        # test_l[1:] = self.pbl[:7]
        # test_l[0] = self.pbl[-2]
        #
        # test_r = np.zeros(8)
        # test_r[:] = self.pbr[1:]

        # if turnspeed > 0:
        #     eb_update_l += 0.5
        # elif turnspeed < 0:
        #     eb_update_r += 0.5

        # plt.plot(self.eb.columns)
        # # plt.plot(np.arange(1, 10), eb_update_l)
        # # plt.plot(np.arange(1, 10), eb_update_r)
        # # plt.plot(np.arange(1, 9), test)
        # # plt.plot(np.arange(1, 9), test2)
        # plt.plot(test_l)
        # plt.plot(test_r)
        # plt.plot(normalise(self.eb.columns * (test_l+test_r)))
        # plt.legend(['EB', 'test_l', 'test_r', 'wef'])
        # plt.xticks([1, 2, 3, 4, 5, 6, 7, 8, 9])
        # plt.show()

        # a = normalise(self.eb.columns)
        # for i in range(self.N_EB):
        #     self.eb[i] = a[i]

        # self.eb.circadd(eb_update_l)
        # self.eb.circadd(eb_update_r)
        #
        # self.eb.columns -= (self.weights_ring @ self.eb.columns)
        # # self.eb.columns = normalise(self.eb.columns)
        #
        # self.pbl[:] = self.eb@self.eb_pbl
        # self.pbr[:] = self.eb@self.eb_pbr

        charge = 0.1

        if turnspeed > 0:
            self.eb.columns[3] += charge
        elif turnspeed < 0:
            self.eb.columns[7] += charge

        update = self.eb.columns @ self.weights_ring / (self.N_EB / 2)
        comp = 0.125
        self.eb.columns = np.clip(self.eb.columns + update + comp, 0, 1)

cx = test()
self = cx

##

self.eb.columns.fill(0.1)

turnspeed = 1
charge = 0.01

self.eb.columns[2] = 0.33
self.eb.columns[6] = -0.05

if turnspeed > 0:
    self.eb.columns[3] += charge
elif turnspeed < 0:
    self.eb.columns[7] += charge

a = self.eb.columns

for i in range(10):
    alph = np.clip(i/10.0 + 0.1, 0.1, 1.0)
    p1 = a @ self.weights_ring
    # mini, maxi = p.min(), p.max()
    # spread = maxi - mini

    plt.plot(a, color='r', alpha=alph)
    plt.plot(a + p1 / 4, color='r', alpha=alph)

    print(f"mean: {np.mean(a)}")
    print(f"median: {np.median(a)}")
    print(f"spread: {np.max(a)-np.min(a)}")
    a = (a + p1) / 3

plt.show()



update = self.eb.columns @ self.weights_ring / (self.N_EB / 2)

inhibited = self.eb.columns + update
print(inhibited)

compensation = 0.125
# print(compensation)

self.eb.columns = np.clip(self.eb.columns + update + compensation, 0, 1)

# cx.update(turnspeed=1)
print(cx.eb)

##

fig, axes = plt.subplots(nrows=3)

axes[0].plot(cx.eb.columns, color='#1E78C2')
axes[1].plot(cx.pbl, color='#FF9027')
axes[2].plot(cx.pbr, color='#FF9027')

plt.show()

##

# TB1: delta7
# TL: ER
# CPU4: PFN
# CPU1 t1: PFL1
# CPU1 t2: PFL3
# CL1 a/b: EPG/PEG
# Pontine: h7
# TN: LNO

##


import numpy as np
from  matplotlib import patches

def get_flow(heading, velocity):
    """Calculate optic flow depending on preference angles. [L, R]"""
    right = [np.sin(heading + np.pi/4.0), np.cos(heading + np.pi/4.0)]
    left = [np.sin(heading - np.pi/4.0), np.cos(heading - np.pi/4.0)]

    A = np.array([right, left])

    flow = np.dot(A, velocity)

    return flow


#
# heading = np.radians(30)
# velocity = pol2cart(1.0, heading)
#
#
# plt.clf()
# ax = plt.subplot(111)
#
# # create the unit circle
# uc = patches.Circle((0, 0), radius=1, fill=False,
#                     color='black', ls='dashed')
# ax.add_patch(uc)
#
#
# ax.spines['left'].set_position('center')
# ax.spines['bottom'].set_position('center')
# ax.spines['right'].set_visible(False)
# ax.spines['top'].set_visible(False)
#
# # set the ticks
# r = 1.5
# plt.axis('scaled')
# plt.axis([-r, r, -r, r])
# ticks = [-1, -.5, .5, 1]
# plt.xticks(ticks)
# plt.yticks(ticks)
#
# truc = [np.sin(heading + np.pi/4.0), np.cos(heading + np.pi/4.0)]
# chose = [np.sin(heading - np.pi/4.0), np.cos(heading - np.pi/4.0)]
#
# plt.scatter(*truc, color='green')
# plt.scatter(*chose, color='red')
#
# flow = get_flow(heading, velocity)
#
# plt.bar(-1.5, flow[0], color='blue', width=0.2, alpha=0.2)
# plt.bar(1.5, flow[1], color='blue',  width=0.2, alpha=0.2)
#
#
# plt.show()
#

##



##

# heading = np.radians(34)
# travel_direction = np.radians(34)
# speed = 2.0
#
# xy_speed = pol2cart(speed, travel_direction)
#
# flow = get_flow(heading, speed)


##
from trials import generate_route

T = 1000

headings, velocity = generate_route(T=T)

syn = SynapticWeights()
cx = CentralComplex(syn)

tb1 = np.zeros(syn.N_TB1)
memory = 0.5 * np.ones(syn.N_CPU4)
memory_holo = 0.5 * np.ones(syn.N_CPU4)

all_tb1 = np.zeros((T, 8))
all_tn1 = np.zeros((T, 2))
all_tn2 = np.zeros((T, 2))

all_memory = np.zeros((T, 16))
all_memory_holo = np.zeros((T, 16))

all_cpu4 = np.zeros((T, 16))
all_cpu4_holo = np.zeros((T, 16))


def upd(h, v, cx, memory, memory_holo, tb1):
    tl2 = cx.tl2_output(h)
    cl1 = cx.cl1_output(tl2)
    tb1 = cx.tb1_output(cl1, tb1)

    # Speed
    flow = cx.get_flow(h, v)
    tn1 = cx.tn1_output(flow)
    tn2 = cx.tn2_output(flow)

    # Update memory for distance just travelled
    memory = cx.cpu4_update(memory, tb1, tn1, tn2)
    memory_holo = cx.cpu4_update_holo(memory_holo, tb1, tn1, tn2)
    cpu4 = cx.cpu4_output(memory)
    cpu4_holo = cx.cpu4_output(memory_holo)

    # Steer based on memory and direction
    cpu1 = cx.cpu1_output(tb1, cpu4)
    cpu1_holo = cx.cpu1_output(tb1, cpu4_holo)
    motor = cx.motor_output(cpu1)
    motor_holo = cx.motor_output(cpu1_holo)

    return tl2, cl1, tb1, tn1, tn2, memory, memory_holo, cpu4, cpu4_holo, cpu1, cpu1_holo, motor, motor_holo


for t in range(T):
    h = headings[t]
    v = velocity[t]
    tl2, cl1, tb1, tn1, tn2, memory, memory_holo, cpu4, cpu4_holo, cpu1, cpu1_holo, motor, motor_holo = upd(h, v, cx, memory, memory_holo, tb1)

    all_tb1[t] = tb1

    all_tn1[t] = tn1
    all_tn2[t] = tn2

    all_memory[t] = memory
    all_memory_holo[t] = memory_holo

    all_cpu4[t] = cpu4
    all_cpu4_holo[t] = cpu4_holo

# def moving_average(a, n=3):
#     ret = np.cumsum(a, dtype=float)
#     ret[n:] = ret[n:] - ret[:-n]
#     return ret[n - 1:] / n
#



import matplotlib.pyplot as plt
from matplotlib.widgets import Slider


def plot_activity_interactive(logs=[]):

    nb_cells = len(logs)

    fig = plt.figure(figsize=(16, 10))

    gs = fig.add_gridspec(nb_cells + 1, 2)
    axpath = fig.add_subplot(gs[:-1, 0])
    axslider = fig.add_subplot(gs[-1, 0])

    axes = []
    lines = []
    for i in range(nb_cells):
        axes.append(fig.add_subplot(gs[i, 1]))
        axes[i].set_ylim(0, 1)

        vals = logs[i][0, :]
        line, = axes[i].plot(vals, color='red')
        lines.append(line)

    xy = np.cumsum(velocity, axis=0)

    axpath.plot(xy[:, 0], xy[:, 1], color='black', alpha=0.1)
    path_line, = axpath.plot(xy[0, 0], xy[0, 1], color='black', alpha=0.5)
    axpath.axis("equal")

    slider = Slider(axslider, 'T', 0, all_memory.shape[0] - 1, valinit=0, valfmt='%i')

    def update(val):
        ind = int(slider.val)

        for i in range(nb_cells):
            lines[i].set_ydata(logs[i][ind, :])
        path_line.set_data(xy[:ind, 0], xy[:ind, 1])
        fig.canvas.draw()

    slider.on_changed(update)
    plt.show()


plot_activity_interactive([all_tb1, all_tn1, all_tn2,
                            all_memory,
                           all_memory_holo,
                          all_cpu4,
                          all_cpu4_holo])


# fig = plt.figure(figsize=(16, 10))
#
# gs = fig.add_gridspec(2, 2)
# ax1 = fig.add_subplot(gs[0, 0])
# ax2 = fig.add_subplot(gs[0, 1])
# ax3 = fig.add_subplot(gs[1, :])
#
# avg = 30
#
# ax1.plot(test[:, 0], color='red', alpha=0.2)
# ax1.plot(np.arange(avg, T+1), moving_average(test[:, 0], n=avg), color='red')
#
# ax1.plot(test[:, 1], color='blue', alpha=0.2)
# ax1.plot(moving_average(test[:, 1], n=30), color='blue')
# ax1.set_ylim(0, 1)
#
# ax2.plot(test2[:, 0], color='red', alpha=0.2)
# ax2.plot(np.arange(avg, T+1), moving_average(test2[:, 0], n=avg), color='red')
#
# ax2.plot(test2[:, 1], color='blue', alpha=0.2)
# ax2.plot(moving_average(test2[:, 1], n=30), color='blue')
# ax2.set_ylim(0, 1)
#
# xy = np.cumsum(velocity, axis=0)
#
# ax3.plot(xy[:, 0], color='green', alpha=0.5)
# ax3.plot(xy[:, 1], color='orange', alpha=0.5)
# ax3.plot(xy[:, 0], xy[:, 1], color='black', alpha=0.25)
# ax3.axis("equal")
# plt.show()


##

cpu4_mem = all_memory[500]
tb1 = all_tb1[500]
tn1 = all_tn1[500]
tn2 = all_tn2[500]

##


a = 00.0

xs = np.arange(360)

l1 = (1 + np.cos(np.radians(xs - a + 45))) / 2.0
l2 = (1 + np.cos(np.radians(xs - a - 45))) / 2.0
l3 = (1 + np.cos(np.radians(xs - a + 135))) / 2.0
l4 = (1 + np.cos(np.radians(xs - a - 135))) / 2.0

def tns_output(travel_direction, speed):
    """
        L1                L2
    -45 (-π/4)        +45 (π/4)

        L3                L4
    -135 (-3π/4)      +135 (3π/4)
    """

    rf_angle = np.pi / 4.0

    L1 = np.abs(speed) * np.cos(travel_direction - (- rf_angle))
    L2 = np.abs(speed) * np.cos(travel_direction - (+ rf_angle))
    L3 = np.abs(speed) * np.cos(travel_direction - (- 3 * rf_angle))
    L4 = np.abs(speed) * np.cos(travel_direction - (+ 3 * rf_angle))

    return np.array([L1, L2, L3, L4])


test = tns_output(np.radians(0), 1.0)


plt.plot(l1 * test[0], color='#20120b', alpha=0.8)
plt.plot(l2 * test[1], color='#20120b', alpha=0.8)
plt.plot(l3 * (test[2] + 1), color='orange', alpha=0.8)
plt.plot(l4 * (test[3] + 1), color='orange', alpha=0.8)

plt.axvline(x=a, linestyle='dotted', color='k', alpha=0.5)
plt.show()