def optimal_gauss_kernel_size(train, optimize_steps, progress=None):
""" Return the optimal kernel size for a spike density estimation
of a spike train for a gaussian kernel. This function takes a single
spike train, which can be a superposition of multiple spike trains
(created with :func:`collapsed_spike_trains`) that should be included
in a spike density estimation.
Implements the algorithm from
(Shimazaki, Shinomoto. Journal of Computational Neuroscience. 2010).
:param train: The spike train for which the kernel
size should be optimized.
:type train: :class:`neo.core.SpikeTrain`
:param optimize_steps: Array of kernel sizes to try (the best of
these sizes will be returned).
:type optimize_steps: Quantity 1D
:param progress: Set this parameter to report progress. Will be
advanced by len(`optimize_steps`) steps.
:type progress: :class:`.progress_indicator.ProgressIndicator`
:returns: Best of the given kernel sizes
:rtype: Quantity scalar
"""
if not progress:
progress = ProgressIndicator()
x = train.rescale(optimize_steps.units)
N = len(train)
C = {}
sampling_rate = 1024.0 / (x.t_stop - x.t_start)
dt = float(1.0 / sampling_rate)
y_hist = tools.bin_spike_trains({0: [x]}, sampling_rate)[0][0][0]
y_hist = sp.asfarray(y_hist) / N / dt
for step in optimize_steps:
s = float(step)
yh = sigproc.smooth(y_hist,
sigproc.GaussianKernel(2 * step),
sampling_rate,
num_bins=2048,
ensure_unit_area=True) * optimize_steps.units
# Equation from Matlab code, 7/2012
c = (sp.sum(yh**2) * dt - 2 * sp.sum(yh * y_hist) * dt +
2 * 1 / sp.sqrt(2 * sp.pi) / s / N)
C[s] = c * N * N
progress.step()
# Return kernel size with smallest cost
return min(C, key=C.get) * optimize_steps.units
def optimal_gauss_kernel_size(train, optimize_steps, progress=None):
""" Return the optimal kernel size for a spike density estimation
of a spike train for a gaussian kernel. This function takes a single
spike train, which can be a superposition of multiple spike trains
(created with :func:`collapsed_spike_trains`) that should be included
in a spike density estimation.
Implements the algorithm from
(Shimazaki, Shinomoto. Journal of Computational Neuroscience. 2010).
:param train: The spike train for which the kernel
size should be optimized.
:type train: :class:`neo.core.SpikeTrain`
:param optimize_steps: Array of kernel sizes to try (the best of
these sizes will be returned).
:type optimize_steps: Quantity 1D
:param progress: Set this parameter to report progress. Will be
advanced by len(`optimize_steps`) steps.
:type progress: :class:`.progress_indicator.ProgressIndicator`
:returns: Best of the given kernel sizes
:rtype: Quantity scalar
"""
if not progress:
progress = ProgressIndicator()
x = train.rescale(optimize_steps.units)
N = len(train)
C = {}
sampling_rate = 1024.0 / (x.t_stop - x.t_start)
dt = float(1.0 / sampling_rate)
y_hist = tools.bin_spike_trains({0: [x]}, sampling_rate)[0][0][0]
y_hist = sp.asfarray(y_hist) / N / dt
for step in optimize_steps:
s = float(step)
yh = sigproc.smooth(
y_hist, sigproc.GaussianKernel(2 * step), sampling_rate, num_bins=2048,
ensure_unit_area=True) * optimize_steps.units
# Equation from Matlab code, 7/2012
c = (sp.sum(yh ** 2) * dt -
2 * sp.sum(yh * y_hist) * dt +
2 * 1 / sp.sqrt(2 * sp.pi) / s / N)
C[s] = c * N * N
progress.step()
# Return kernel size with smallest cost
return min(C, key=C.get) * optimize_steps.units
def _victor_purpura_multiunit_dist_for_trial_pair(
a, b, reassignment_cost, kernel):
# The algorithm used is based on the one given in
#
# Victor, J. D., & Purpura, K. P. (1996). Nature and precision of temporal
# coding in visual cortex: a metric-space analysis. Journal of
# Neurophysiology.
#
# It constructs a matrix cost[i, j_1, ... j_L] containing the minimal cost
# when only considering the first i spikes of the merged spikes of a and
# j_w spikes of the spike trains of b (the reference given above denotes
# this matrix with G). In this implementation the only the one submatrix
# for one specific i is stored as in each step only i-1 and i will be
# accessed. That saves some memory.
# Initialization of various variables needed by the algorithm. Also swap
# a and b if it will save time as the algorithm is not symmetric.
a_num_spikes = [st.size for st in a]
b_num_spikes = [st.size for st in b]
a_num_total_spikes = sp.sum(a_num_spikes)
complexity_same = a_num_total_spikes * sp.prod(b_num_spikes)
complexity_swapped = sp.prod(a_num_spikes) * sp.sum(b_num_spikes)
if complexity_swapped < complexity_same:
a, b = b, a
a_num_spikes, b_num_spikes = b_num_spikes, a_num_spikes
a_num_total_spikes = sp.sum(a_num_spikes)
if a_num_total_spikes <= 0:
return sp.sum(b_num_spikes)
b_dims = tuple(sp.asarray(b_num_spikes) + 1)
cost = sp.asfarray(sp.sum(sp.indices(b_dims), axis=0))
a_merged = _merge_trains_and_label_spikes(a)
b_strides = sp.cumprod((b_dims + (1,))[::-1])[:-1]
flat_b_indices = sp.arange(cost.size)
b_indices = sp.vstack(sp.unravel_index(flat_b_indices, b_dims))
flat_neighbor_indices = sp.maximum(
0, sp.atleast_2d(flat_b_indices).T - b_strides[::-1])
invalid_neighbors = b_indices.T == 0
b_train_mat = sp.empty((len(b), sp.amax(b_num_spikes))) * b[0].units
for i, st in enumerate(b):
b_train_mat[i, :st.size] = st.rescale(b[0].units)
b_train_mat[i, st.size:] = sp.nan * b[0].units
reassignment_costs = sp.empty((a_merged[0].size,) + b_train_mat.shape)
reassignment_costs.fill(reassignment_cost)
reassignment_costs[sp.arange(a_merged[1].size), a_merged[1], :] = 0.0
k = 1 - 2 * kernel(sp.atleast_2d(
a_merged[0]).T - b_train_mat.flatten()).simplified.reshape(
(a_merged[0].size,) + b_train_mat.shape) + reassignment_costs
decreasing_sequence = flat_b_indices[::-1]
# Do the actual calculations.
for a_idx in xrange(1, a_num_total_spikes + 1):
base_costs = cost.flat[flat_neighbor_indices]
base_costs[invalid_neighbors] = sp.inf
min_base_cost_labels = sp.argmin(base_costs, axis=1)
cost_all_possible_shifts = k[a_idx - 1, min_base_cost_labels, :] + \
sp.atleast_2d(base_costs[flat_b_indices, min_base_cost_labels]).T
cost_shift = cost_all_possible_shifts[
sp.arange(cost_all_possible_shifts.shape[0]),
b_indices[min_base_cost_labels, flat_b_indices] - 1]
cost_delete_in_a = cost.flat[flat_b_indices]
# cost_shift is dimensionless, but there is a bug in quantities with
# the minimum function:
# <https://github.com/python-quantities/python-quantities/issues/52>
# The explicit request for the magnitude circumvents this problem.
cost.flat = sp.minimum(cost_delete_in_a, cost_shift.magnitude) + 1
cost.flat[0] = sp.inf
# Minimum with cost for deleting in b
# The calculation order is somewhat different from the order one would
# expect from the naive algorithm. This implementation, however,
# optimizes the use of the CPU cache giving a considerable speed
# improvement.
# Basically this codes calculates the values of a row of elements for
# each dimension of cost.
for dim_size, stride in zip(b_dims[::-1], b_strides):
for i in xrange(stride):
segment_size = dim_size * stride
for j in xrange(i, cost.size, segment_size):
s = sp.s_[j:j + segment_size:stride]
seq = decreasing_sequence[-cost.flat[s].size:]
cost.flat[s] = sp.minimum.accumulate(
cost.flat[s] + seq) - seq
return cost.flat[-1]
def _victor_purpura_multiunit_dist_for_trial_pair(a, b, reassignment_cost,
kernel):
# The algorithm used is based on the one given in
#
# Victor, J. D., & Purpura, K. P. (1996). Nature and precision of temporal
# coding in visual cortex: a metric-space analysis. Journal of
# Neurophysiology.
#
# It constructs a matrix cost[i, j_1, ... j_L] containing the minimal cost
# when only considering the first i spikes of the merged spikes of a and
# j_w spikes of the spike trains of b (the reference given above denotes
# this matrix with G). In this implementation the only the one submatrix
# for one specific i is stored as in each step only i-1 and i will be
# accessed. That saves some memory.
# Initialization of various variables needed by the algorithm. Also swap
# a and b if it will save time as the algorithm is not symmetric.
a_num_spikes = [st.size for st in a]
b_num_spikes = [st.size for st in b]
a_num_total_spikes = sp.sum(a_num_spikes)
complexity_same = a_num_total_spikes * sp.prod(b_num_spikes)
complexity_swapped = sp.prod(a_num_spikes) * sp.sum(b_num_spikes)
if complexity_swapped < complexity_same:
a, b = b, a
a_num_spikes, b_num_spikes = b_num_spikes, a_num_spikes
a_num_total_spikes = sp.sum(a_num_spikes)
if a_num_total_spikes <= 0:
return sp.sum(b_num_spikes)
b_dims = tuple(sp.asarray(b_num_spikes) + 1)
cost = sp.asfarray(sp.sum(sp.indices(b_dims), axis=0))
a_merged = _merge_trains_and_label_spikes(a)
b_strides = sp.cumprod((b_dims + (1, ))[::-1])[:-1]
flat_b_indices = sp.arange(cost.size)
b_indices = sp.vstack(sp.unravel_index(flat_b_indices, b_dims))
flat_neighbor_indices = sp.maximum(
0,
sp.atleast_2d(flat_b_indices).T - b_strides[::-1])
invalid_neighbors = b_indices.T == 0
b_train_mat = sp.empty((len(b), sp.amax(b_num_spikes))) * b[0].units
for i, st in enumerate(b):
b_train_mat[i, :st.size] = st.rescale(b[0].units)
b_train_mat[i, st.size:] = sp.nan * b[0].units
reassignment_costs = sp.empty((a_merged[0].size, ) + b_train_mat.shape)
reassignment_costs.fill(reassignment_cost)
reassignment_costs[sp.arange(a_merged[1].size), a_merged[1], :] = 0.0
k = 1 - 2 * kernel(sp.atleast_2d(a_merged[0]).T -
b_train_mat.flatten()).simplified.reshape(
(a_merged[0].size, ) +
b_train_mat.shape) + reassignment_costs
decreasing_sequence = flat_b_indices[::-1]
# Do the actual calculations.
for a_idx in xrange(1, a_num_total_spikes + 1):
base_costs = cost.flat[flat_neighbor_indices]
base_costs[invalid_neighbors] = sp.inf
min_base_cost_labels = sp.argmin(base_costs, axis=1)
cost_all_possible_shifts = k[a_idx - 1, min_base_cost_labels, :] + \
sp.atleast_2d(base_costs[flat_b_indices, min_base_cost_labels]).T
cost_shift = cost_all_possible_shifts[
sp.arange(cost_all_possible_shifts.shape[0]),
b_indices[min_base_cost_labels, flat_b_indices] - 1]
cost_delete_in_a = cost.flat[flat_b_indices]
# cost_shift is dimensionless, but there is a bug in quantities with
# the minimum function:
# <https://github.com/python-quantities/python-quantities/issues/52>
# The explicit request for the magnitude circumvents this problem.
cost.flat = sp.minimum(cost_delete_in_a, cost_shift.magnitude) + 1
cost.flat[0] = sp.inf
# Minimum with cost for deleting in b
# The calculation order is somewhat different from the order one would
# expect from the naive algorithm. This implementation, however,
# optimizes the use of the CPU cache giving a considerable speed
# improvement.
# Basically this codes calculates the values of a row of elements for
# each dimension of cost.
for dim_size, stride in zip(b_dims[::-1], b_strides):
for i in xrange(stride):
segment_size = dim_size * stride
for j in xrange(i, cost.size, segment_size):
s = sp.s_[j:j + segment_size:stride]
seq = decreasing_sequence[-cost.flat[s].size:]
cost.flat[s] = sp.minimum.accumulate(cost.flat[s] +
seq) - seq
return cost.flat[-1]
import pandas as pd
import tensorflow as tf
from sklearn.datasets import load_iris
import scipy as sc
from tensorflow import keras
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
data = load_iris()
x = sc.asfarray(data.data)
#checking x for null values
print(sum(sc.isnan(x)))
y = sc.asfarray(data.target)
#checking y for null values
print(sum(sc.isnan(y)))
#labels and there mappings
labels = data.target_names
labelDict = {
0: labels[0],
1: labels[1],
2: labels[2],
}
#NO visualization is done in this practice
#spilliting data
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
print(x_train.shape, y_train.shape)
def normalized_vp_dist(trains, tau):
num_spikes = sp.atleast_2d(sp.asarray([st.size for st in trains]))
normalization = num_spikes + num_spikes.T
normalization[normalization == 0.0] = 1.0
return sp.asfarray(
stm.victor_purpura_dist(trains, 2.0 / tau, sort=False)) / normalization
