j_hartling/paper_2025
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Colored the hopper. Lots of polishing.

Browse Source
This commit is contained in:
j-hartling
2026-02-20 16:46:44 +01:00
parent 5afd073de9
commit 1ea2081eab
60 changed files with 3860 additions and 4156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
python/fig_pathway_stages.py
View File

@@ -1,5 +1,3 @@
from math import log
import plotstyle_plt
import glob
import numpy as np
@@ -118,6 +116,40 @@ def reorder_traces(handles, signal, zlow=2, zhigh=2.5):
handles[ind].set_zorder(z)
return None
def choose_kernels(kern_specs, features, kern_types, per_type=2, thresh=0.01):
embed()
mean_feat = features.mean(axis=0)
feat_diff = np.abs(mean_feat[:, None] - mean_feat[None, :])
feat_diff[features.max(axis=0) < thresh, :] = np.nan
feat_diff = np.nanmean(feat_diff, axis=0)
ranking = np.argsort(feat_diff)
kern_inds = []
for type_id in kern_types:
type_inds = np.nonzero(kern_specs[:, 0] == type_id)[0]
rank_inds = np.nonzero(np.isin(ranking, type_inds))[0][-per_type:]
kern_inds.extend(ranking[rank_inds])
return np.array(kern_inds)
mean_feat = features.mean(axis=0)
mean_feat -= mean_feat.min()
mean_feat /= mean_feat.max()
feat_diff = np.abs(mean_feat[:, None] - mean_feat[None, :]).mean(axis=0)
feat_diff -= feat_diff.min()
feat_diff /= feat_diff.max()
ranking = np.argsort(mean_feat + feat_diff)
kern_inds = []
for type_id in kern_types:
type_inds = np.nonzero(kern_specs[:, 0] == type_id)[0]
rank_inds = np.nonzero(np.isin(ranking, type_inds))[0][-per_type:]
kern_inds.extend(ranking[rank_inds])
return np.array(kern_inds)
def letter_subplots(axes, labels='abcd', x=0.02, y=1, ha='left', va='bottom',
fontsize=16, fontweight='bold', **kwargs):
for ax, label in zip(axes, labels):
@@ -130,7 +162,7 @@ def letter_subplots(axes, labels='abcd', x=0.02, y=1, ha='left', va='bottom',
target = 'Omocestus_rufipes'
data_paths = glob.glob(f'../data/processed/{target}*.npz')
stages = ['filt', 'env', 'log', 'inv', 'conv', 'bi', 'feat']
save_name = '../figures/pathway_stages'
save_path = None#'../figures/'
# PLOT SETTINGS:
fig_kwargs = dict(
@@ -196,13 +228,27 @@ zoom_kwargs = dict(
zorder=0,
linewidth=0
)
# kernels = np.array([
# [-2, 0.016],
# [3, 0.032]
# ])
kern_types = np.array([1, -1, 2, -2, 3, -3, 4, -4])
kern_sigmas = np.array([0.008, 0.032])
kernels = np.array([[k, s] for k in kern_types for s in kern_sigmas])
kernels = np.array([
[1, 0.002],
[1, 0.016],
[-1, 0.002],
[-1, 0.016],
[2, 0.004],
[2, 0.032],
[-2, 0.004],
[-2, 0.032],
[3, 0.004],
[3, 0.032],
[-3, 0.004],
[-3, 0.032],
[4, 0.004],
[4, 0.032],
[-4, 0.004],
[-4, 0.032]
])
# t = [1, 2, 3, 4]
# s = [0.001, 0.002, 0.004, 0.008, 0.032]
# kernels = np.array([[i, j] for i in t for j in s])
conv_colors = load_colors('../data/conv_colors.npz')
bi_colors = load_colors('../data/bi_colors.npz')
feat_colors = load_colors('../data/feat_colors.npz')
@@ -266,9 +312,8 @@ for data_path in data_paths:
indicate_zoom(fig, axes[0, 0], axes[-1, 0], zoom_abs, **zoom_kwargs)
indicate_zoom(fig, axes[0, 1], axes[-1, 1], zoom_abs, **zoom_kwargs)
letter_subplots(axes[:, 0])
# fig.align_ylabels(axes[:, 0])
if save_name is not None:
fig.savefig(f'{save_name}_pre.pdf')
if save_path is not None:
fig.savefig(f'{save_path}fig_pre_stages.pdf')
# PART II: FEATURE EXTRACTION STAGE:
@@ -312,9 +357,8 @@ for data_path in data_paths:
indicate_zoom(fig, axes[0, 0], axes[-1, 0], zoom_abs, **zoom_kwargs)
indicate_zoom(fig, axes[0, 1], axes[-1, 1], zoom_abs, **zoom_kwargs)
letter_subplots(axes[:, 0])
# fig.align_ylabels(axes[:, 0])
if save_name is not None:
fig.savefig(f'{save_name}_feat.pdf')
if save_path is not None:
fig.savefig(f'{save_path}fig_feat_stages.pdf')
plt.show()

140
python/save_figure_texts.py Normal file
View File

@@ -0,0 +1,140 @@
import matplotlib.pyplot as plt
# Fixed RCs:
plt.rcParams['font.style'] = 'normal'
plt.rcParams['mathtext.fontset'] = 'cm'
plt.rcParams['svg.fonttype'] = 'path'
plt.rc('text.latex', preamble=r'\usepackage{amsmath}')
# Context RCs:
show_figs = True
rc_tex = {
'text.usetex': True,
'font.family': 'computer modern roman',
}
rc_plt = {
'text.usetex': False,
'font.family': 'sans-serif',
}
# Instance configs:
title_props = dict(
use_tex=False,
figsize=(5, 2.5),
fs=53,
fw='normal',
)
letter_props = dict(
use_tex=False,
figsize=(1, 1),
fs=70,
fw='bold',
)
element_props = dict(
use_tex=True,
figsize=(3, 3),
fs=80,
fw='normal',
)
line_props = dict(
use_tex=True,
figsize=(3, 2),
fs=75,
fw='normal',
)
# Auxiliary configs:
fig_kwargs = dict(
gridspec_kw={'left': 0, 'right': 1, 'top': 1, 'bottom': 0},
facecolor='none',
edgecolor='none',
frameon=False,
)
ax_kwargs = dict(
facecolor='none',
frame_on=False,
)
text_kwargs = dict(
color='k',
x=0.5,
y=0.5,
ha='center',
va='center',
)
# Targets:
texts = {
### PLAIN FONT ###
# TITLES (NEURONAL CIRCUIT):
'neuron_titles_tympanum': ('Tympanal\nMembrane', title_props),
'neuron_titles_receptors': ('Receptor\nNeurons', title_props),
'neuron_titles_interneurons': ('Local\nInterneurons', title_props),
'neuron_titles_ascending': ('Ascending\nNeurons', title_props),
'neuron_titles_brain': ('Central\nBrain', title_props),
# TITLES (MODEL CIRCUIT):
'model_titles_bandpass': ('Bandpass\nFiltering', title_props),
'model_titles_envelope': ('Envelope\nExtraction', title_props),
'model_titles_logarithm': ('Logarithmic\nCompression', title_props),
'model_titles_adaptation': ('Intensity\nAdaptation', title_props),
'model_titles_convolution': ('Convolutional\nFiltering', title_props),
'model_titles_nonlinear': ('Threshold\nNonlinearity', title_props),
'model_titles_integration': ('Temporal\nAveraging', title_props),
'model_titles_readout': ('Weighted\nReadout', title_props),
# SUBPLOT LETTERS:
'subplot_a': ('a', letter_props),
'subplot_b': ('b', letter_props),
'subplot_c': ('c', letter_props),
'subplot_d': ('d', letter_props),
### TEX FONT ###
# ELEMENT LABELS (MODEL CIRCUIT):
'model_elements_filt': (r'$x_{\text{filt}}$', element_props),
'model_elements_env': (r'$x_{\text{env}}$', element_props),
'model_elements_log': (r'$x_{\text{dB}}$', element_props),
'model_elements_adapt': (r'$x_{\text{adapt}}$', element_props),
'model_elements_c1': (r'$c_1$', element_props),
'model_elements_c2': (r'$c_2$', element_props),
'model_elements_c3': (r'$c_3$', element_props),
'model_elements_b1': (r'$b_1$', element_props),
'model_elements_b2': (r'$b_2$', element_props),
'model_elements_b3': (r'$b_3$', element_props),
'model_elements_f1': (r'$f_1$', element_props),
'model_elements_f2': (r'$f_2$', element_props),
'model_elements_f3': (r'$f_3$', element_props),
'model_elements_out': (r'$\hat{y}$', element_props),
# LINE LABELS (MODEL CIRCUIT):
'model_lines_env': (r'$\lvert\cdot\lvert,h_{\text{LP}}$', line_props),
'model_lines_log': (r'$\text{log}$', line_props),
'model_lines_hp': (r'$h_{\text{HP}}$', line_props),
'model_lines_k1': (r'$k_1$', line_props),
'model_lines_k2': (r'$k_2$', line_props),
'model_lines_k3': (r'$k_3$', line_props),
'model_lines_t1': (r'$\Theta_1$', line_props),
'model_lines_t2': (r'$\Theta_2$', line_props),
'model_lines_t3': (r'$\Theta_3$', line_props),
# 'model_lines_H1': (r'$H(c_1-\Theta_1)$', line_props),
# 'model_lines_H2': (r'$H(c_2-\Theta_2)$', line_props),
# 'model_lines_H3': (r'$H(c_3-\Theta_3)$', line_props),
'model_lines_lp': (r'$h_{\text{LP}}$', line_props),
'model_lines_w1': (r'$\omega_1$', line_props),
'model_lines_w2': (r'$\omega_2$', line_props),
'model_lines_w3': (r'$\omega_3$', line_props),
}
# Save each target string:
for name, (text, props) in texts.items():
plt.rcParams.update(rc_tex if props['use_tex'] else rc_plt)
fig, ax = plt.subplots(figsize=props['figsize'], **fig_kwargs)
ax.set(**ax_kwargs)
ax.axis('off')
ax.text(s=text, size=props['fs'], weight=props['fw'], **text_kwargs)
fig.savefig(f'../figures/{name}_text.svg', dpi=300,
bbox_inches='tight', pad_inches=0)
if show_figs:
plt.show()
plt.close(fig)

2
python/save_kernel_colors.py
View File

@@ -13,4 +13,6 @@ stage_colors = load_colors('../data/stage_colors.npz')
for stage in stages:
colors = shade_colors(stage_colors[stage], shade_factors)
colors = {str(k): c for k, c in zip(kern_types, colors)}
print(f'\n{stage} colors:')
print(colors)
np.savez(f'../data/{stage}_colors.npz', **colors)

103
python/save_latex_texts.py
View File

@@ -1,103 +0,0 @@
import matplotlib.pyplot as plt
plt.rcParams['text.usetex'] = True
plt.rcParams['font.family'] = 'computer modern roman'
plt.rcParams['mathtext.fontset'] = 'cm'
plt.rcParams['mathtext.default'] = 'regular'
plt.rcParams['svg.fonttype'] = 'path'
plt.rc('text.latex', preamble=r'\usepackage{amsmath}')
# Settings:
titles_fontsize = 65
titles_figsize = (5, 2.5)
elements_fontsize = 80
elements_figsize = (3, 3)
lines_fontsize = 75
lines_figsize = (3, 2)
show_figs = True
grid_props = dict(left=0, right=1, top=1, bottom=0)
fig_props = {
'facecolor': 'none',
'edgecolor': 'none',
'frameon': False,
}
ax_props = {
'facecolor': 'none',
'frame_on': False,
}
text_props = {
'color': 'k',
'x': 0.5,
'y': 0.5,
'ha': 'center',
'va': 'center',
}
# Targets:
texts = {
# # TITLES (NEURONAL CIRCUIT):
# 'neuron_titles_tympanum': ('Tympanal\nMembrane', titles_fontsize, titles_figsize),
# 'neuron_titles_receptors': ('Receptor\nNeurons', titles_fontsize, titles_figsize),
# 'neuron_titles_interneurons': ('Local\nInterneurons', titles_fontsize, titles_figsize),
# 'neuron_titles_ascending': ('Ascending\nNeurons', titles_fontsize, titles_figsize),
# 'neuron_titles_brain': ('Central\nBrain', titles_fontsize, titles_figsize),
# # TITLES (MODEL CIRCUIT):
# 'model_titles_bandpass': ('Bandpass\nFiltering', titles_fontsize, titles_figsize),
# 'model_titles_envelope': ('Envelope\nExtraction', titles_fontsize, titles_figsize),
# 'model_titles_logarithm': ('Logarithmic\nCompression', titles_fontsize, titles_figsize),
# 'model_titles_adaptation': ('Intensity\nAdaptation', titles_fontsize, titles_figsize),
# 'model_titles_convolution': ('Convolutional\nFiltering', titles_fontsize, titles_figsize),
# 'model_titles_nonlinear': ('Threshold\nNonlinearity', titles_fontsize, titles_figsize),
# 'model_titles_integration': ('Temporal\nAveraging', titles_fontsize, titles_figsize),
# 'model_titles_readout': ('Weighted\nReadout', titles_fontsize, titles_figsize),
# # ELEMENT LABELS (MODEL CIRCUIT):
# 'model_elements_filt': (r'$x_{\text{filt}}$', elements_fontsize, elements_figsize),
# 'model_elements_env': (r'$x_{\text{env}}$', elements_fontsize, elements_figsize),
# 'model_elements_log': (r'$x_{\text{dB}}$', elements_fontsize, elements_figsize),
# 'model_elements_adapt': (r'$x_{\text{adapt}}$', elements_fontsize, elements_figsize),
# 'model_elements_c1': (r'$c_1$', elements_fontsize, elements_figsize),
# 'model_elements_c2': (r'$c_2$', elements_fontsize, elements_figsize),
# 'model_elements_c3': (r'$c_3$', elements_fontsize, elements_figsize),
# 'model_elements_b1': (r'$b_1$', elements_fontsize, elements_figsize),
# 'model_elements_b2': (r'$b_2$', elements_fontsize, elements_figsize),
# 'model_elements_b3': (r'$b_3$', elements_fontsize, elements_figsize),
# 'model_elements_f1': (r'$f_1$', elements_fontsize, elements_figsize),
# 'model_elements_f2': (r'$f_2$', elements_fontsize, elements_figsize),
# 'model_elements_f3': (r'$f_3$', elements_fontsize, elements_figsize),
# 'model_elements_out': (r'$\hat{y}$', elements_fontsize, elements_figsize),
# LINE LABELS (MODEL CIRCUIT):
'model_lines_env': (r'$\lvert\cdot\lvert,h_{\text{LP}}$', lines_fontsize, lines_figsize),
'model_lines_log': (r'$\text{log}$', lines_fontsize, lines_figsize),
'model_lines_hp': (r'$h_{\text{HP}}$', lines_fontsize, lines_figsize),
'model_lines_k1': (r'$k_1$', lines_fontsize, lines_figsize),
'model_lines_k2': (r'$k_2$', lines_fontsize, lines_figsize),
'model_lines_k3': (r'$k_3$', lines_fontsize, lines_figsize),
'model_lines_t1': (r'$\Theta_1$', lines_fontsize, lines_figsize),
'model_lines_t2': (r'$\Theta_2$', lines_fontsize, lines_figsize),
'model_lines_t3': (r'$\Theta_3$', lines_fontsize, lines_figsize),
# 'model_lines_H1': (r'$H(c_1-\Theta_1)$', lines_fontsize, lines_figsize),
# 'model_lines_H2': (r'$H(c_2-\Theta_2)$', lines_fontsize, lines_figsize),
# 'model_lines_H3': (r'$H(c_3-\Theta_3)$', lines_fontsize, lines_figsize),
'model_lines_lp': (r'$h_{\text{LP}}$', lines_fontsize, lines_figsize),
'model_lines_w1': (r'$\omega_1$', lines_fontsize, lines_figsize),
'model_lines_w2': (r'$\omega_2$', lines_fontsize, lines_figsize),
'model_lines_w3': (r'$\omega_3$', lines_fontsize, lines_figsize),
}
# Save each target string:
for name, (text, fs, size) in texts.items():
fig, ax = plt.subplots(figsize=size, gridspec_kw=grid_props, **fig_props)
ax.set(**ax_props)
ax.axis('off')
ax.text(s=text, fontsize=fs, **text_props)
fig.savefig(f'../figures/{name}_text.svg', dpi=300,
bbox_inches='tight', pad_inches=0)
if show_figs:
plt.show()
plt.close(fig)

8
python/save_stage_colors.py
View File

@@ -1,10 +1,10 @@
import matplotlib.pyplot as plt
from color_functions import load_colors, color_selector
from color_functions import load_colors, color_selector, hex_to_rgb
from IPython import embed
# Settings:
stages = ['filt', 'env', 'log', 'inv', 'conv', 'bi', 'feat']
file_name = None#'../data/stage_colors'
stages = ['filt', 'env', 'log', 'inv', 'conv', 'bi', 'feat', 'out']
file_name = '../data/stage_colors'
colors = None
if True:
colors = load_colors('../data/stage_colors.npz')
@@ -12,4 +12,4 @@ if True:
# Execution:
colors = color_selector(len(stages), colors, file_name, labels=stages, hex=True)
plt.show()
embed()
embed()