def _extract_batch(self,im, settings, num_parts, num_permutation, part_shape, parts):
assert parts is not None, "must be trained before calling extract"
x = im
print(parts.shape)
print(x.shape)
th = settings['threshold']
th = 5
n_coded = settings.get('n_coded', 1)
print(th)
support_mask = np.ones(part_shape, dtype=np.bool)
from pnet.cyfuncs import code_index_map_general
#print("=================")
#print(x.shape)
#print("=================")
print(np.mean(parts == self._parts))
feature_map = code_index_map_general(x,
parts,
support_mask.astype(np.uint8),
th,
outer_frame=settings['outer_frame'],
n_coded=n_coded,
standardize=settings.get('standardize', 0),
min_percentile=settings.get('min_percentile', 0.0))
# shifting spreading?
print(feature_map.shape)
return feature_map
def extract(self,X):
assert self._parts is not None, "Must be trained before calling extract"
bedges_settings = self._settings['bedges']
radius = bedges_settings['radius']
X = self._extract_many_edges(bedges_settings, self._settings, X, must_preserve_size = True)
X = ag.features.bspread(X, spread=self._settings['bedges']['spread'], radius = self._settings['bedges']['radius'])
support_mask = np.ones(self._part_shape, dtype=np.bool)
th = self._settings['threshold']
n_coded = 1
from pnet.cyfuncs import code_index_map_general
feature_map = code_index_map_general(X, self._parts, support_mask.astype(np.uint8),th,outer_frame=self._settings['outer_frame'],n_coded = 1, standardize=self._settings.get('standardize',0),
min_percentile = self._settings.get('min_percentile',0.0))
# Rotation spreading?
rotspread = self._settings.get('rotation_spreading_radius', 0)
if rotspread > 0:
between_feature_spreading = np.zeros((self._num_parts * self._num_rot , rotspread*2 + 1), dtype=np.int64)
ORI = self._num_rot
for f in range(self._num_parts * self._num_rot):
thepart = f // ORI
ori = f % ORI
for i in range(rotspread*2 + 1):
between_feature_spreading[f,i] = thepart * ORI + (ori - rotspread + i) % ORI
bb = np.concatenate([between_feature_spreading, -np.ones((1, rotspread*2 + 1), dtype=np.int64)], 0)
# Update feature map
feature_map = bb[feature_map[...,0]]
return feature_map
def extract(self, phi, data):
assert self._parts is not None, \
"Must be trained before calling extract"
X = phi(data)
th = self._settings['threshold']
n_coded = self._settings.get('n_coded', 1)
support_mask = self._settings.get('support_mask')
if support_mask is None:
support_mask = np.ones(self._part_shape, dtype=np.bool)
outer_frame = self._settings.get('outer_frame', 0)
standardize = self._settings.get('standardize', 0)
min_percentile = self._settings.get('min_percentile', 0.0)
from pnet.cyfuncs import code_index_map_general
feature_map = code_index_map_general(X,
self._parts,
support_mask.astype(np.uint8),
th,
outer_frame=outer_frame,
n_coded=n_coded,
standardize=standardize,
min_percentile=min_percentile)
return (feature_map, self._num_parts)
def _extract_batch(X, settings, num_parts, num_orientations, part_shape,
parts, extract_func):
assert parts is not None, "Must be trained before calling extract"
th = settings['threshold']
n_coded = settings.get('n_coded', 1)
support_mask = np.ones(part_shape, dtype=np.bool)
from pnet.cyfuncs import code_index_map_general
standardize = settings.get('standardize', 0)
min_percentile = settings.get('min_percentile', 0.0)
rotspread = settings.get('rotation_spreading_radius', 0)
feature_map = code_index_map_general(X,
parts,
support_mask.astype(np.uint8),
th,
outer_frame=settings['outer_frame'],
n_coded=n_coded,
standardize=standardize,
min_percentile=min_percentile)
# Rotation spreading?
if rotspread > 0:
between_feature_spreading = np.zeros((num_parts, rotspread*2 + 1),
dtype=np.int64)
ORI = num_orientations
for f in range(num_parts):
thepart = f // ORI
ori = f % ORI
for i in range(rotspread*2 + 1):
v = thepart * ORI + (ori - rotspread + i) % ORI
between_feature_spreading[f, i] = v
neg_ones = -np.ones((1, rotspread*2 + 1), dtype=np.int64)
bb = np.concatenate([between_feature_spreading, neg_ones], 0)
# Update feature map
feature_map = bb[feature_map[..., 0]]
return feature_map
def _extract_batch(im, settings, num_parts, num_orientations, part_shape, parts):
assert parts is not None, "Must be trained before calling extract"
X = _extract_many_edges(settings['bedges'], settings, im, must_preserve_size=True)
X = ag.features.bspread(X, spread=settings['bedges']['spread'], radius=settings['bedges']['radius'])
th = settings['threshold']
n_coded = settings.get('n_coded', 1)
support_mask = np.ones(part_shape, dtype=np.bool)
from pnet.cyfuncs import code_index_map_general
#print("=================")
#print(X.shape)
#print("=================")
feature_map = code_index_map_general(X,
parts,
support_mask.astype(np.uint8),
th,
outer_frame=settings['outer_frame'],
n_coded=n_coded,
standardize=settings.get('standardize', 0),
min_percentile=settings.get('min_percentile', 0.0))
# Rotation spreading?
rotspread = settings.get('rotation_spreading_radius', 0)
if rotspread > 0:
between_feature_spreading = np.zeros((num_parts, rotspread*2 + 1), dtype=np.int64)
ORI = num_orientations
for f in range(num_parts):
thepart = f // ORI
ori = f % ORI
for i in range(rotspread*2 + 1):
between_feature_spreading[f,i] = thepart * ORI + (ori - rotspread + i) % ORI
bb = np.concatenate([between_feature_spreading, -np.ones((1, rotspread*2 + 1), dtype=np.int64)], 0)
# Update feature map
feature_map = bb[feature_map[...,0]]
return feature_map
