Python numpy.where() Examples
The following are code examples for showing how to use numpy.where(). They are from open source Python projects. You can vote up the examples you like or vote down the ones you don't like.
Example 1
| Project: mmdetection Author: open-mmlab File: sampler.py Apache License 2.0 | 9 votes |
|
def __iter__(self):
indices = []
for i, size in enumerate(self.group_sizes):
if size == 0:
continue
indice = np.where(self.flag == i)[0]
assert len(indice) == size
np.random.shuffle(indice)
num_extra = int(np.ceil(size / self.samples_per_gpu)
) * self.samples_per_gpu - len(indice)
indice = np.concatenate(
[indice, np.random.choice(indice, num_extra)])
indices.append(indice)
indices = np.concatenate(indices)
indices = [
indices[i * self.samples_per_gpu:(i + 1) * self.samples_per_gpu]
for i in np.random.permutation(
range(len(indices) // self.samples_per_gpu))
]
indices = np.concatenate(indices)
indices = indices.astype(np.int64).tolist()
assert len(indices) == self.num_samples
return iter(indices)
Example 2
| Project: b2ac Author: hbldh File: reference.py MIT License | 7 votes |
|
def fit_B2AC(points):
"""Ellipse fitting in Python with numerically unstable algorithm.
Described `here <http://research.microsoft.com/pubs/67845/ellipse-pami.pdf>`_.
N_POLYPOINTS.B. Do not use, since it works with almost singular matrix.
:param points: The [Nx2] array of points to fit ellipse to.
:type points: :py:class:`numpy.ndarray`
:return: The conic section array defining the fitted ellipse.
:rtype: :py:class:`numpy.ndarray`
"""
import scipy.linalg as scla
constraint_matrix = np.zeros((6, 6))
constraint_matrix[0, 2] = 2
constraint_matrix[1, 1] = -1
constraint_matrix[2, 0] = 2
S = _calculate_scatter_matrix_py(points[:, 0], points[:, 1])
evals, evect = scla.eig(S, constraint_matrix)
ind = np.where(evals == (evals[evals > 0].min()))[0][0]
return evect[:, ind]
Example 3
| Project: b2ac Author: hbldh File: unstable.py MIT License | 6 votes |
|
def fit_unstable_B2AC(points):
"""Ellipse fitting in Python with numerically unstable algorithm. Requires SciPy to run!
Described `here <http://research.microsoft.com/pubs/67845/ellipse-pami.pdf>`_.
N.B. Do not use, since it works with almost singular matrix.
:param points: The [Nx2] array of points to fit ellipse to.
:type points: :py:class:`numpy.ndarray`
:return: The conic section array defining the fitted ellipse.
:rtype: :py:class:`numpy.ndarray`
"""
import scipy.linalg as scla
constraint_matrix = np.zeros((6, 6))
constraint_matrix[0, 2] = 2
constraint_matrix[1, 1] = -1
constraint_matrix[2, 0] = 2
S = _calculate_scatter_matrix_double(points[:, 0], points[:, 1])
eigenvalues, eigenvalues = scla.eig(S, constraint_matrix)
ind = np.where(eigenvalues == (eigenvalues[eigenvalues > 0].min()))[0][0]
return eigenvalues[:, ind]
Example 4
| Project: building-boundary Author: Geodan File: segmentation.py MIT License | 6 votes |
|
def ransac_line_segmentation(points, distance):
"""
Segment a line using RANSAC.
Parameters
----------
points : (Mx2) array
The coordinates of the points
distance : float
The maximum distance between a point and a line for a point to be
considered belonging to that line.
Returns
-------
inliers : list of bool
True where point is an inlier.
"""
_, inliers = ransac(points, LineModelND,
min_samples=2,
residual_threshold=distance,
max_trials=1000)
return inliers
Example 5
| Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: train_val.py MIT License | 6 votes |
|
def filter_roidb(roidb):
"""Remove roidb entries that have no usable RoIs."""
def is_valid(entry):
# Valid images have:
# (1) At least one foreground RoI OR
# (2) At least one background RoI
overlaps = entry['max_overlaps']
# find boxes with sufficient overlap
fg_inds = np.where(overlaps >= cfg.TRAIN.FG_THRESH)[0]
# Select background RoIs as those within [BG_THRESH_LO, BG_THRESH_HI)
bg_inds = np.where((overlaps < cfg.TRAIN.BG_THRESH_HI) &
(overlaps >= cfg.TRAIN.BG_THRESH_LO))[0]
# image is only valid if such boxes exist
valid = len(fg_inds) > 0 or len(bg_inds) > 0
return valid
num = len(roidb)
filtered_roidb = [entry for entry in roidb if is_valid(entry)]
num_after = len(filtered_roidb)
print('Filtered {} roidb entries: {} -> {}'.format(num - num_after,
num, num_after))
return filtered_roidb
Example 6
| Project: cgp-cnn Author: sg-nm File: cgp.py MIT License | 6 votes |
|
def _evaluation(self, pop, eval_flag):
# create network list
net_lists = []
active_index = np.where(eval_flag)[0]
for i in active_index:
net_lists.append(pop[i].active_net_list())
# evaluation
fp = self.eval_func(net_lists)
for i, j in enumerate(active_index):
pop[j].eval = fp[i]
evaluations = np.zeros(len(pop))
for i in range(len(pop)):
evaluations[i] = pop[i].eval
self.num_eval += len(net_lists)
return evaluations
Example 7
| Project: wikilinks Author: trovdimi File: weighted_pagerank.py MIT License | 6 votes |
|
def pickle_correlations_zeros_january():
db = MySQLDatabase(DATABASE_HOST, DATABASE_USER, DATABASE_PASSWORD, DATABASE_NAME)
conn = db._create_connection()
print 'read'
df = pd.read_sql('select source_article_id, target_article_id from link_features', conn)
print 'loaded links'
df2 = pd.read_sql('select prev_id, curr_id, counts from clickstream_derived_en_201501 where link_type_derived= "internal-link";', conn)
print 'loaded counts'
result = pd.merge(df, df2, how='left', left_on = ['source_article_id', 'target_article_id'], right_on = ['prev_id', 'curr_id'])
print 'merged counts'
print result
article_counts = result.groupby(by=["target_article_id"])['counts'].sum().reset_index()
article_counts['counts'].fillna(0.0, inplace=True)
print article_counts
print 'write to file'
article_counts[["target_article_id","counts"]].to_csv(TMP+'january_article_counts.tsv', sep='\t', index=False)
Example 8
| Project: ieml Author: IEMLdev File: tools.py GNU General Public License v3.0 | 6 votes |
|
def _tree_graph_path_of_node(tree_graph, node):
if node in tree_graph.nodes:
nodes = [(node, False)]
else:
nodes = []
# can be a mode
nodes += [(c[0], True) for c_list in tree_graph.transitions.values() for c in c_list if c[1][2] == node]
if not nodes:
raise ValueError("Node not in tree graph : %s" % str(node))
def _build_coord(node, mode=False):
if node == tree_graph.root:
return [Coordinate(kind='s')]
parent = tree_graph.nodes[numpy.where(tree_graph.array[:, tree_graph.nodes_index[node]])[0][0]]
return _build_coord(parent) + \
[Coordinate(index=[c[0] for c in tree_graph.transitions[parent]].index(node), kind='m' if mode else 'a')]
return AdditivePath([MultiplicativePath(_build_coord(node, mode)) for node, mode in nodes])
Example 9
| Project: Automated-Social-Annotation Author: acadTags File: SVM.py MIT License | 6 votes |
|
def do_eval(modelToEval, evalX_embedded, evalY,hamming_q=FLAGS.ave_labels_per_doc):
y_pred = modelToEval.predict(evalX_embedded)
y_true = np.asarray(evalY)
acc, prec, rec, hamming_loss = 0.0, 0.0, 0.0, 0.0
for i in range(len(y_pred)):
label_predicted = np.where(y_pred[i]==1)[0]
curr_acc = calculate_accuracy(label_predicted,y_true[i])
acc = acc + curr_acc
curr_prec, curr_rec = calculate_precision_recall(label_predicted,y_true[i])
prec = prec + curr_prec
rec = rec + curr_rec
curr_hl = calculate_hamming_loss(label_predicted,y_true[i])
hamming_loss = hamming_loss + curr_hl
acc = acc/float(len(y_pred))
prec = prec/float(len(y_pred))
rec = rec/float(len(y_pred))
hamming_loss = hamming_loss/float(len(y_pred))/FLAGS.ave_labels_per_doc
if prec+rec != 0:
f_measure = 2*prec*rec/(prec+rec)
else:
f_measure = 0
return acc,prec,rec,f_measure,hamming_loss
# this also needs evalX
Example 10
| Project: Automated-Social-Annotation Author: acadTags File: SVM.py MIT License | 6 votes |
|
def display_for_qualitative_evaluation(modelToEval, evalX_embedded, evalX,evalY,vocabulary_index2word,vocabulary_index2word_label):
prediction_str=""
#generate the doc indexes same as for the deep learning models.
number_examples=len(evalY)
rn_dict={}
rn.seed(1) # set the seed to produce same documents for prediction
batch_size=128
for i in range(0,500):
batch_chosen=rn.randint(0,number_examples//batch_size)
x_chosen=rn.randint(0,batch_size)
#rn_dict[(batch_chosen*batch_size,x_chosen)]=1
rn_dict[batch_chosen*batch_size+x_chosen]=1
y_pred = modelToEval.predict(evalX_embedded)
y_true = np.asarray(evalY)
for i in range(len(y_pred)):
label_predicted = np.where(y_pred[i]==1)[0]
if rn_dict.get(i) == 1:
doc = 'doc: ' + ' '.join(display_results(evalX[i],vocabulary_index2word))
pred = 'prediction-svm: ' + ' '.join(display_results(label_predicted,vocabulary_index2word_label))
get_indexes = lambda x, xs: [i for (y, i) in zip(xs, range(len(xs))) if x == y]
label = 'labels: ' + ' '.join(display_results(get_indexes(1,evalY[i]),vocabulary_index2word_label))
prediction_str = prediction_str + '\n' + doc + '\n' + pred + '\n' + label + '\n'
return prediction_str
Example 11
| Project: FasterRCNN_TF_Py3 Author: upojzsb File: proposal_target_layer.py MIT License | 6 votes |
|
def _get_bbox_regression_labels(bbox_target_data, num_classes):
"""Bounding-box regression targets (bbox_target_data) are stored in a
compact form N x (class, tx, ty, tw, th)
This function expands those targets into the 4-of-4*K representation used
by the network (i.e. only one class has non-zero targets).
Returns:
bbox_target (ndarray): N x 4K blob of regression targets
bbox_inside_weights (ndarray): N x 4K blob of loss weights
"""
clss = bbox_target_data[:, 0]
bbox_targets = np.zeros((clss.size, 4 * num_classes), dtype=np.float32)
bbox_inside_weights = np.zeros(bbox_targets.shape, dtype=np.float32)
inds = np.where(clss > 0)[0]
for ind in inds:
cls = clss[ind]
start = int(4 * cls)
end = start + 4
bbox_targets[ind, start:end] = bbox_target_data[ind, 1:]
bbox_inside_weights[ind, start:end] = cfg.FLAGS2["bbox_inside_weights"]
return bbox_targets, bbox_inside_weights
Example 12
| Project: kuaa Author: rafaelwerneck File: plugin_majority_voting.py GNU General Public License v3.0 | 6 votes |
|
def majority_voting(predict_set, index):
"""
Performs the calculation of the majority voting for the list of results,
returning a numpy array with the majority class as 1.0, and the other
classes as 0.0.
"""
size_predict = len(predict_set[INDEX_ZERO][INDEX_ZERO])
list_max_index = []
mv = zeros(size_predict)
for predict_list in predict_set:
predict = predict_list[index]
pred_max = max(predict)
index_max = where(array(predict) == pred_max)[INDEX_ZERO][INDEX_ZERO]
list_max_index.append(index_max)
index_mv = majority(list_max_index)
mv[index_mv] = 1.0
return mv.tolist()
Example 13
| Project: kuaa Author: rafaelwerneck File: OPF.py GNU General Public License v3.0 | 6 votes |
|
def __findPrototypes(self, MST, labels):
"""
Parameters:
MST = MST adjacency matrix
labels = labels of the nodes
Note:
Return:
seeds = List with OPF prototypes
"""
n = MST.shape[0]
if n != len(labels): return []
seeds = []
for i in range(n):
w = MST[i, :]
wix = np.where(w != float("inf"))[0]
l = map(lambda x: labels[x], wix)
if set(l + [labels[i]]).__len__() > 1:
seeds.append(i)
return seeds
Example 14
| Project: Lane-And-Vehicle-Detection Author: JustinHeaton File: main.py MIT License | 6 votes |
|
def found_search(self, x, y):
'''
This function is applied when the lane lines have been detected in the previous frame.
It uses a sliding window to search for lane pixels in close proximity (+/- 25 pixels in the x direction)
around the previous detected polynomial.
'''
xvals = []
yvals = []
if self.found == True:
i = 720
j = 630
while j >= 0:
yval = np.mean([i,j])
xval = (np.mean(self.fit0))*yval**2 + (np.mean(self.fit1))*yval + (np.mean(self.fit2))
x_idx = np.where((((xval - 25) < x)&(x < (xval + 25))&((y > j) & (y < i))))
x_window, y_window = x[x_idx], y[x_idx]
if np.sum(x_window) != 0:
np.append(xvals, x_window)
np.append(yvals, y_window)
i -= 90
j -= 90
if np.sum(xvals) == 0:
self.found = False # If no lane pixels were detected then perform blind search
return xvals, yvals, self.found
Example 15
| Project: mmdetection Author: open-mmlab File: base.py Apache License 2.0 | 6 votes |
|
def forward_train(self, imgs, img_metas, **kwargs):
"""
Args:
img (list[Tensor]): list of tensors of shape (1, C, H, W).
Typically these should be mean centered and std scaled.
img_metas (list[dict]): list of image info dict where each dict
has:
'img_shape', 'scale_factor', 'flip', and my also contain
'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
For details on the values of these keys see
`mmdet/datasets/pipelines/formatting.py:Collect`.
**kwargs: specific to concrete implementation
"""
pass
Example 16
| Project: b2ac Author: hbldh File: reference.py MIT License | 5 votes |
|
def fit_improved_B2AC(points):
"""Ellipse fitting in Python with improved B2AC algorithm as described in
this `paper <http://autotrace.sourceforge.net/WSCG98.pdf>`_.
This version of the fitting uses float storage during calculations and performs the
eigensolver on a float array.
:param points: The [Nx2] array of points to fit ellipse to.
:type points: :py:class:`numpy.ndarray`
:return: The conic section array defining the fitted ellipse.
:rtype: :py:class:`numpy.ndarray`
"""
points = np.array(points, 'float')
S = _calculate_scatter_matrix_py(points[:, 0], points[:, 1])
S3 = S[3:, 3:]
S3 = np.array([S3[0, 0], S3[0, 1], S3[0, 2], S3[1, 1], S3[1, 2], S3[2, 2]])
S3_inv = inverse_symmetric_3by3_double(S3).reshape((3, 3))
S2 = S[:3, 3:]
T = -np.dot(S3_inv, S2.T)
M = S[:3, :3] + np.dot(S2, T)
inv_mat = np.array([[0, 0, 0.5], [0, -1, 0], [0.5, 0, 0]], 'float')
M = inv_mat.dot(M)
e_vals, e_vect = np.linalg.eig(M)
try:
elliptical_solution_index = np.where(((4 * e_vect[0, :] * e_vect[2, :]) - ((e_vect[1, :] ** 2))) > 0)[0][0]
except:
# No positive eigenvalues. Fit was not ellipse.
raise ArithmeticError("No elliptical solution found.")
a = e_vect[:, elliptical_solution_index]
if a[0] < 0:
a = -a
return np.concatenate((a, np.dot(T, a)))
Example 17
| Project: b2ac Author: hbldh File: reference.py MIT License | 5 votes |
|
def fit_improved_B2AC_int(points):
"""Ellipse fitting in Python with improved B2AC algorithm as described in
this `paper <http://autotrace.sourceforge.net/WSCG98.pdf>`_.
This version of the fitting uses int64 storage during calculations and performs the
eigensolver on an integer array.
:param points: The [Nx2] array of points to fit ellipse to.
:type points: :py:class:`numpy.ndarray`
:return: The conic section array defining the fitted ellipse.
:rtype: :py:class:`numpy.ndarray`
"""
S = _calculate_scatter_matrix_c(points[:, 0], points[:, 1])
S1 = np.array([S[0, 0], S[0, 1], S[0, 2], S[1, 1], S[1, 2], S[2, 2]])
S3 = np.array([S[3, 3], S[3, 4], S[3, 5], S[4, 4], S[4, 5], S[5, 5]])
adj_S3, det_S3 = inverse_symmetric_3by3_int(S3)
S2 = S[:3, 3:]
T_no_det = - np.dot(np.array(adj_S3.reshape((3, 3)), 'int64'), np.array(S2.T, 'int64'))
M_term2 = np.dot(np.array(S2, 'int64'), T_no_det) // det_S3
M = add_symmetric_matrix(M_term2, S1)
M[[0, 2], :] /= 2
M[1, :] = -M[1, :]
e_vals, e_vect = np.linalg.eig(M)
try:
elliptical_solution_index = np.where(((4 * e_vect[0, :] * e_vect[2, :]) - ((e_vect[1, :] ** 2))) > 0)[0][0]
except:
# No positive eigenvalues. Fit was not ellipse.
raise ArithmeticError("No elliptical solution found.")
a = e_vect[:, elliptical_solution_index]
return np.concatenate((a, np.dot(T_no_det, a) / det_S3))
Example 18
| Project: rhodonite Author: nestauk File: misc.py MIT License | 5 votes |
|
def get_aggregate_vp(g, vp, vp_grouper, agg=None):
"""aggregate_property_map
Parameters
----------
g : :obj:`graph_tool.Graph`
A graph.
vp : :obj:`str`
String representing an internal property map of graph, g.
vp_grouper : :obj:`str`
String representing name of an internal property map that will be
used to group by.
agg : :obj:`function`
Function to aggregate by. For example, min, max, sum, numpy.mean,
etc.
Returns
-------
:obj:`iter` of :obj:`float`
Aggregated values from x.
"""
vp_vals = get_vp_values(g, vp)
vp_agg = get_vp_values(g, vp_grouper)
sid_x = vp_agg.argsort()
# Get where the sorted version of base changes groups
split_idx = np.flatnonzero(np.diff(vp_agg[sid_x]) > 0) + 1
# OR np.unique(base[sidx],return_index=True)[1][1:]
# Finally sort inp based on the sorted indices and split based on split_idx
vp_vals_grouped = np.split(vp_vals[sid_x], split_idx)
x = sorted(set(vp_agg))
if agg:
y = [agg(vvg) for vvg in vp_vals_grouped]
else:
y = vp_vals_grouped
return x, y
Example 19
| Project: rhodonite Author: nestauk File: misc.py MIT License | 5 votes |
|
def get_vp_values(g, vertex_prop_name):
"""get_vp_values
Retrieves a vertex property from a graph, taking into account any filter.
Parameters
----------
g : :obj:`graph_tool.Graph`
A graph.
vertex_prop_name :obj:`str`
The name of an internal vertex property.
Returns
-------
pm : :obj:`PropertyMapArray`
An array of the property map.
"""
p_type = g.vp[vertex_prop_name].value_type()
mask = g.get_vertex_filter()[0]
if mask is not None:
mask = np.where(mask.get_array())
if p_type != 'string':
pm = g.vp[vertex_prop_name].get_array()[mask]
else:
pm = [g.vp[vertex_prop_name][v]
for m, v in zip(mask, g.vertices()) if m == True]
else:
pm = g.vp[vertex_prop_name].get_array()
return pm
Example 20
| Project: building-boundary Author: Geodan File: segmentation.py MIT License | 5 votes |
|
def extract_segment(points, indices, distance):
"""
Extract a line segment from a sequence of points.
Parameters
----------
points : (Mx2) array
The coordinates of all the points.
indices : list of int
The indices of the points in the sequence.
distance : float
The maximum distance between a point and a line for a point to be
considered belonging to that line.
Returns
-------
segment : list of int
The indices of the points belonging to the segment/line.
"""
inliers = ransac_line_segmentation(points[indices], distance)
inliers = indices[inliers]
sequences = np.split(inliers, np.where(np.diff(inliers) != 1)[0] + 1)
segment = list(max(sequences, key=len))
if len(segment) > 1:
segment = extend_segment(segment, points, indices, distance)
elif len(segment) == 1:
if segment[0] + 1 in indices:
segment.append(segment[0] + 1)
segment = extend_segment(segment, points, indices, distance)
elif segment[0] - 1 in indices:
segment.insert(0, segment[0] - 1)
segment = extend_segment(segment, points, indices, distance)
return segment
Example 21
| Project: building-boundary Author: Geodan File: segmentation.py MIT License | 5 votes |
|
def get_insert_loc(segments, segment):
"""
Uses a binary search to find the correct location to insert a new segment.
Parameters
----------
segments : list of list of int
The indices of the points belonging to the segments/lines.
segment : list of int
The indices of the points belonging to the segment/line.
Returns
-------
: int
The index where the segment should be inserted.
"""
if len(segments) == 0:
return 0
if segment[0] > segments[-1][0]:
return len(segments)
lo = 0
hi = len(segments)
while lo < hi:
mid = (lo + hi) // 2
if segment[0] < segments[mid][0]:
hi = mid
else:
lo = mid + 1
return lo
Example 22
| Project: building-boundary Author: Geodan File: segmentation.py MIT License | 5 votes |
|
def get_remaining_sequences(indices, mask):
"""
Gets the remaining sequences given the points that are already part of
a segment.
Parameters
----------
indices : list of int
The indices of the points in the sequence.
mask : list of bool
Marks the points that are part of a segment.
Returns
-------
sequences : list of list of int
The indices of each remaining sequence.
"""
sequences = np.split(indices, np.where(np.diff(mask) == 1)[0] + 1)
if mask[0]:
sequences = [s for i, s in enumerate(sequences) if i % 2 == 0]
else:
sequences = [s for i, s in enumerate(sequences) if i % 2 != 0]
sequences = [s for s in sequences if len(s) > 1]
return sequences
Example 23
| Project: building-boundary Author: Geodan File: merge.py MIT License | 5 votes |
|
def find_pivots(orientations, angle):
"""
Finds the indices of where the difference in orientation is
larger than the given angle.
Parameters
----------
orientations : list of float
The sequence of orientations
angle : float or int
The difference in angle at which a point will be considered a
pivot.
Returns
-------
pivot_indices : list of int
"""
ori_diff = np.fromiter((utils.angle.angle_difference(a1, a2) for
a1, a2 in utils.create_pairs(orientations)),
orientations.dtype)
pivots_bool = ori_diff > angle
pivots_idx = list(np.where(pivots_bool)[0] + 1)
# edge case
if pivots_idx[-1] > (len(orientations)-1):
del pivots_idx[-1]
pivots_idx[0:0] = [0]
return pivots_idx
Example 24
| Project: RF-Monitor Author: EarToEarOak File: cli.py GNU General Public License v2.0 | 5 votes |
|
def __on_scan_data(self, event):
levels = numpy.log10(event['l'])
levels *= 10
noise = numpy.percentile(levels,
self._dynP)
for monitor in self._monitors:
freq = monitor.get_frequency()
if monitor.get_enabled():
monitor.set_noise(noise)
index = numpy.where(freq == event['f'])[0]
signal = monitor.set_level(levels[index][0],
event['timestamp'],
self._location)
if signal is not None:
signals = 'Signals: {}\r'.format(self.__count_signals() -
self._signalCount)
self.__std_out(signals, False)
if signal.end is not None:
recording = format_recording(freq, signal)
if self._pushUri is not None:
self._push.send(self._pushUri,
recording)
if self._server is not None:
self._server.send(recording)
if self._json:
sys.stdout.write(recording + '\n')
Example 25
| Project: RF-Monitor Author: EarToEarOak File: gui.py GNU General Public License v2.0 | 5 votes |
|
def __on_scan_data(self, event):
levels = numpy.log10(event['l'])
levels *= 10
self._levels = levels
noise = numpy.percentile(levels,
self._toolbar.get_dynamic_percentile())
updated = False
for monitor in self._monitors:
freq = monitor.get_frequency()
if monitor.get_enabled():
monitor.set_noise(noise)
index = numpy.where(freq == event['f'])[0]
signal = monitor.set_level(levels[index][0],
event['timestamp'],
self._location)
if signal is not None:
updated = True
if signal.end is not None:
recording = format_recording(freq, signal)
if self._settings.get_push_enable():
self._push.send(self._settings.get_push_uri(),
recording)
if self._server is not None:
self._server.send(recording)
if updated:
if self._isSaved:
self._isSaved = False
self.__set_title()
self.__set_timeline()
self.__set_spectrum(noise)
self._rssi.set_noise(numpy.mean(levels))
self._rssi.set_level(numpy.max(levels))
Example 26
| Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: layer.py MIT License | 5 votes |
|
def _shuffle_roidb_inds(self):
"""Randomly permute the training roidb."""
# If the random flag is set,
# then the database is shuffled according to system time
# Useful for the validation set
if self._random:
st0 = np.random.get_state()
millis = int(round(time.time() * 1000)) % 4294967295
np.random.seed(millis)
if cfg.TRAIN.ASPECT_GROUPING:
raise NotImplementedError
'''
widths = np.array([r['width'] for r in self._roidb])
heights = np.array([r['height'] for r in self._roidb])
horz = (widths >= heights)
vert = np.logical_not(horz)
horz_inds = np.where(horz)[0]
vert_inds = np.where(vert)[0]
inds = np.hstack((
np.random.permutation(horz_inds),
np.random.permutation(vert_inds)))
inds = np.reshape(inds, (-1, 2))
row_perm = np.random.permutation(np.arange(inds.shape[0]))
inds = np.reshape(inds[row_perm, :], (-1,))
self._perm = inds
'''
else:
self._perm = np.random.permutation(np.arange(len(self._roidb)))
# Restore the random state
if self._random:
np.random.set_state(st0)
self._cur = 0
Example 27
| Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: train_val.py MIT License | 5 votes |
|
def remove_snapshot(self, np_paths, ss_paths):
to_remove = len(np_paths) - cfg.TRAIN.SNAPSHOT_KEPT
for c in range(to_remove):
nfile = np_paths[0]
os.remove(str(nfile))
np_paths.remove(nfile)
to_remove = len(ss_paths) - cfg.TRAIN.SNAPSHOT_KEPT
for c in range(to_remove):
sfile = ss_paths[0]
# To make the code compatible to earlier versions of Tensorflow,
# where the naming tradition for checkpoints are different
os.remove(str(sfile))
ss_paths.remove(sfile)
Example 28
| Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: test.py MIT License | 5 votes |
|
def apply_nms(all_boxes, thresh):
"""Apply non-maximum suppression to all predicted boxes output by the
test_net method.
"""
num_classes = len(all_boxes)
num_images = len(all_boxes[0])
nms_boxes = [[[] for _ in range(num_images)] for _ in range(num_classes)]
for cls_ind in range(num_classes):
for im_ind in range(num_images):
dets = all_boxes[cls_ind][im_ind]
if dets == []:
continue
x1 = dets[:, 0]
y1 = dets[:, 1]
x2 = dets[:, 2]
y2 = dets[:, 3]
scores = dets[:, 4]
inds = np.where((x2 > x1) & (y2 > y1))[0]
dets = dets[inds,:]
if dets == []:
continue
keep = nms(torch.from_numpy(dets), thresh).numpy()
if len(keep) == 0:
continue
nms_boxes[cls_ind][im_ind] = dets[keep, :].copy()
return nms_boxes
Example 29
| Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: voc_eval.py MIT License | 5 votes |
|
def voc_ap(rec, prec, use_07_metric=False):
""" ap = voc_ap(rec, prec, [use_07_metric])
Compute VOC AP given precision and recall.
If use_07_metric is true, uses the
VOC 07 11 point method (default:False).
"""
if use_07_metric:
# 11 point metric
ap = 0.
for t in np.arange(0., 1.1, 0.1):
if np.sum(rec >= t) == 0:
p = 0
else:
p = np.max(prec[rec >= t])
ap = ap + p / 11.
else:
# correct AP calculation
# first append sentinel values at the end
mrec = np.concatenate(([0.], rec, [1.]))
mpre = np.concatenate(([0.], prec, [0.]))
# compute the precision envelope
for i in range(mpre.size - 1, 0, -1):
mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])
# to calculate area under PR curve, look for points
# where X axis (recall) changes value
i = np.where(mrec[1:] != mrec[:-1])[0]
# and sum (\Delta recall) * prec
ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])
return ap
Example 30
| Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: coco.py MIT License | 5 votes |
|
def __init__(self, image_set, year):
imdb.__init__(self, 'coco_' + year + '_' + image_set)
# COCO specific config options
self.config = {'use_salt': True,
'cleanup': True}
# name, paths
self._year = year
self._image_set = image_set
self._data_path = osp.join(cfg.DATA_DIR, 'coco')
# load COCO API, classes, class <-> id mappings
self._COCO = COCO(self._get_ann_file())
cats = self._COCO.loadCats(self._COCO.getCatIds())
self._classes = tuple(['__background__'] + [c['name'] for c in cats])
self._class_to_ind = dict(list(zip(self.classes, list(range(self.num_classes)))))
self._class_to_coco_cat_id = dict(list(zip([c['name'] for c in cats],
self._COCO.getCatIds())))
self._image_index = self._load_image_set_index()
# Default to roidb handler
self.set_proposal_method('gt')
self.competition_mode(False)
# Some image sets are "views" (i.e. subsets) into others.
# For example, minival2014 is a random 5000 image subset of val2014.
# This mapping tells us where the view's images and proposals come from.
self._view_map = {
'minival2014': 'val2014', # 5k val2014 subset
'valminusminival2014': 'val2014', # val2014 \setminus minival2014
'test-dev2015': 'test2015',
}
coco_name = image_set + year # e.g., "val2014"
self._data_name = (self._view_map[coco_name]
if coco_name in self._view_map
else coco_name)
# Dataset splits that have ground-truth annotations (test splits
# do not have gt annotations)
self._gt_splits = ('train', 'val', 'minival')
Example 31
| Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: coco.py MIT License | 5 votes |
|
def _print_detection_eval_metrics(self, coco_eval):
IoU_lo_thresh = 0.5
IoU_hi_thresh = 0.95
def _get_thr_ind(coco_eval, thr):
ind = np.where((coco_eval.params.iouThrs > thr - 1e-5) &
(coco_eval.params.iouThrs < thr + 1e-5))[0][0]
iou_thr = coco_eval.params.iouThrs[ind]
assert np.isclose(iou_thr, thr)
return ind
ind_lo = _get_thr_ind(coco_eval, IoU_lo_thresh)
ind_hi = _get_thr_ind(coco_eval, IoU_hi_thresh)
# precision has dims (iou, recall, cls, area range, max dets)
# area range index 0: all area ranges
# max dets index 2: 100 per image
precision = \
coco_eval.eval['precision'][ind_lo:(ind_hi + 1), :, :, 0, 2]
ap_default = np.mean(precision[precision > -1])
print(('~~~~ Mean and per-category AP @ IoU=[{:.2f},{:.2f}] '
'~~~~').format(IoU_lo_thresh, IoU_hi_thresh))
print('{:.1f}'.format(100 * ap_default))
for cls_ind, cls in enumerate(self.classes):
if cls == '__background__':
continue
# minus 1 because of __background__
precision = coco_eval.eval['precision'][ind_lo:(ind_hi + 1), :, cls_ind - 1, 0, 2]
ap = np.mean(precision[precision > -1])
print('{:.1f}'.format(100 * ap))
print('~~~~ Summary metrics ~~~~')
coco_eval.summarize()
Example 32
| Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: ds_utils.py MIT License | 5 votes |
|
def filter_small_boxes(boxes, min_size): w = boxes[:, 2] - boxes[:, 0] h = boxes[:, 3] - boxes[:, 1] keep = np.where((w >= min_size) & (h > min_size))[0] return keep
Example 33
| Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: demo.py MIT License | 5 votes |
|
def vis_detections(im, class_name, dets, thresh=0.5):
"""Draw detected bounding boxes."""
inds = np.where(dets[:, -1] >= thresh)[0]
if len(inds) == 0:
return
im = im[:, :, (2, 1, 0)]
fig, ax = plt.subplots(figsize=(12, 12))
ax.imshow(im, aspect='equal')
for i in inds:
bbox = dets[i, :4]
score = dets[i, -1]
ax.add_patch(
plt.Rectangle((bbox[0], bbox[1]),
bbox[2] - bbox[0],
bbox[3] - bbox[1], fill=False,
edgecolor='red', linewidth=3.5)
)
ax.text(bbox[0], bbox[1] - 2,
'{:s} {:.3f}'.format(class_name, score),
bbox=dict(facecolor='blue', alpha=0.5),
fontsize=14, color='white')
ax.set_title(('{} detections with '
'p({} | box) >= {:.1f}').format(class_name, class_name,
thresh),
fontsize=14)
plt.axis('off')
plt.tight_layout()
plt.draw()
Example 34
| Project: ultra_secret_scripts Author: CharlesDankoff File: image_search.py GNU General Public License v3.0 | 5 votes |
|
def search_image_in_image(small_image, large_image, precision=0.95):
template = small_image.astype(np.float32)
img_rgb = large_image.astype(np.float32)
template = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)
img_rgb = cv2.cvtColor(img_rgb, cv2.COLOR_BGR2GRAY)
res = cv2.matchTemplate(img_rgb, template, cv2.TM_CCOEFF_NORMED)
threshold = precision
loc = np.where(res >= threshold)
found_positions = list(zip(*loc[::-1]))
# print("FOUND: {}".format(found_positions))
return found_positions
Example 35
| Project: prediction-constrained-topic-models Author: dtak File: train_and_eval_sklearn_binary_classifier.py MIT License | 5 votes |
|
def predict(self, x):
''' Make thresholded predictions
Returns
-------
yhat_N : 1D array of class labels
'''
yproba_class1_N = self.clf.predict_proba(x)[:,1]
# Recall that np.where assigns as follows:
# first value in self.classes when True
# second value when False
yhat_N = np.where(yproba_class1_N <= self.proba_thr_for_class1, *self.classes_)
return yhat_N
Example 36
| Project: wikilinks Author: trovdimi File: compare_hypothesis.py MIT License | 5 votes |
|
def norm_hyp(matrix):
print "in norm_hyp"
tmp = csr_matrix(matrix, copy=True)
norm_h = tmp.sum(axis=1)
n_nzeros = np.where(norm_h > 0)
norm_h[n_nzeros] = 1.0 / norm_h[n_nzeros]
norm_h = np.array(norm_h).T[0]
print "in place mod"
# modify sparse_csc_matrix in place
csr_scale_rows(tmp.shape[0],
tmp.shape[1],
tmp.indptr,
tmp.indices,
tmp.data, norm_h)
return tmp
Example 37
| Project: wikilinks Author: trovdimi File: weighted_pagerank.py MIT License | 5 votes |
|
def norm (hypothesis):
hypothesis = hypothesis.copy()
norma = hypothesis.sum(axis=1)
n_nzeros = np.where(norma > 0)
n_zeros,_ = np.where(norma == 0)
norma[n_nzeros] = 1.0 / norma[n_nzeros]
norma = norma.T[0]
csr_scale_rows(hypothesis.shape[0], hypothesis.shape[1], hypothesis.indptr, hypothesis.indices, hypothesis.data, norma)
return hypothesis
Example 38
| Project: wikilinks Author: trovdimi File: weighted_pagerank.py MIT License | 5 votes |
|
def correlations(network_name):
db = MySQLDatabase(DATABASE_HOST, DATABASE_USER, DATABASE_PASSWORD, DATABASE_NAME)
conn = db._create_connection()
cursor = conn.cursor()
# wikipedia graph structural statistics
results = None
try:
results = cursor.execute('select c.curr_id, sum(c.counts) as counts from clickstream_derived c where c.link_type_derived= %s group by c.curr_id;', ("internal-link",))
results = cursor.fetchall()
except MySQLdb.Error, e:
print ('error retrieving xy coord for all links links %s (%d)' % (e.args[1], e.args[0]))
Example 39
| Project: wikilinks Author: trovdimi File: HypTrails.py MIT License | 5 votes |
|
def zero_rows_norm(self, hypothesis, structur,k):
norma = hypothesis.sum(axis=1)
n_zeros = np.where(norma == 0)
print 'n_zeros'
print len(n_zeros[0])
for x, i in enumerate(n_zeros[0]):
if x % 1000 == 0:
print x, len(n_zeros[0])
links = np.where(structur[i,:]!=0)
hypothesis[i,links[0]] = k / len(links[0])
print 'n_zeros done'
# def zero_rows_norm_eff(self,hypothesis, structur):
# #find zero sum rows in hypothesis
# print 'sum hyp'
# norma = hypothesis.sum(axis=1)
# n_zeros = np.where(norma == 0)
# # norm the structure matrix
# print 'sum structure'
# tmp = structur[n_zeros]
# norm_s = tmp.sum(axis=1)
# norm_s = np.array(norm_s).T[0]
# tmp = tmp/norm_s[:,None]
# #replece the zero rows in hypothesis with the corresponding rows in the normed strcuture matrix
# print 'replace'
# hypotheis[n_zeros,:]=tmp[n_zeros,:]
Example 40
| Project: Multi-Modal-Spectral-Image-Super-Resolution Author: IVRL File: test.py MIT License | 5 votes |
|
def APPSA(gt, rc):
nom = np.sum(gt * rc, axis=0)
denom = np.linalg.norm(gt, axis=0) * np.linalg.norm(rc, axis=0)
cos = np.where((nom / (denom + 1e-3)) > 1, 1, (nom / (denom + 1e-3)))
appsa = np.arccos(cos)
return np.sum(appsa) / (gt.shape[1] * gt.shape[0])
Example 41
| Project: Multi-Modal-Spectral-Image-Super-Resolution Author: IVRL File: test.py MIT License | 5 votes |
|
def APPSA(gt, rc):
nom = np.sum(gt * rc, axis=0)
denom = np.linalg.norm(gt, axis=0) * np.linalg.norm(rc, axis=0)
cos = np.where((nom / (denom + 1e-3)) > 1, 1, (nom / (denom + 1e-3)))
appsa = np.arccos(cos)
return np.sum(appsa) / (gt.shape[1] * gt.shape[0])
Example 42
| Project: Automated-Social-Annotation Author: acadTags File: BiGRU_train.py MIT License | 5 votes |
|
def assign_pretrained_word_embedding(sess,vocabulary_index2word,vocab_size,model,num_run,word2vec_model_path=None):
if num_run==0:
print("using pre-trained word emebedding.started.word2vec_model_path:",word2vec_model_path)
# transform embedding input into a dictionary
# word2vecc=word2vec.load('word_embedding.txt') #load vocab-vector fiel.word2vecc['w91874']
word2vec_model = word2vec.load(word2vec_model_path, kind='bin')
word2vec_dict = {}
for word, vector in zip(word2vec_model.vocab, word2vec_model.vectors):
word2vec_dict[word] = vector
word_embedding_2dlist = [[]] * vocab_size # create an empty word_embedding list: which is a list of list, i.e. a list of word, where each word is a list of values as an embedding vector.
word_embedding_2dlist[0] = np.zeros(FLAGS.embed_size) # assign empty for first word:'PAD'
bound = np.sqrt(6.0) / np.sqrt(vocab_size) # bound for random variables.
count_exist = 0;
count_not_exist = 0
for i in range(1, vocab_size): # loop each word
word = vocabulary_index2word[i] # get a word
embedding = None
try:
embedding = word2vec_dict[word] # try to get vector:it is an array.
except Exception:
embedding = None
if embedding is not None: # the 'word' exist a embedding
word_embedding_2dlist[i] = embedding;
count_exist = count_exist + 1 # assign array to this word.
else: # no embedding for this word
word_embedding_2dlist[i] = np.random.uniform(-bound, bound, FLAGS.embed_size);
count_not_exist = count_not_exist + 1 # init a random value for the word.
word_embedding_final = np.array(word_embedding_2dlist) # covert to 2d array.
#print(word_embedding_final[0]) # print the original embedding for the first word
word_embedding = tf.constant(word_embedding_final, dtype=tf.float32) # convert to tensor
t_assign_embedding = tf.assign(model.Embedding,word_embedding) # assign this value to our embedding variables of our model.
sess.run(t_assign_embedding);
if num_run==0:
print("word. exists embedding:", count_exist, " ;word not exist embedding:", count_not_exist)
print("using pre-trained word emebedding.ended...")
# based on a threshold, 在验证集上做验证，报告损失、精确度-multilabel
Example 43
| Project: Automated-Social-Annotation Author: acadTags File: BiGRU_train.py MIT License | 5 votes |
|
def get_label_using_logits_threshold(logits,threshold=0.5):
sig = sigmoid_array(logits)
index_list = np.where(sig > threshold)[0]
return index_list
Example 44
| Project: Automated-Social-Annotation Author: acadTags File: HAN_train.py MIT License | 5 votes |
|
def assign_pretrained_word_embedding(sess,vocabulary_index2word,vocab_size,model,num_run,word2vec_model_path=None):
if num_run==0:
print("using pre-trained word emebedding.started.word2vec_model_path:",word2vec_model_path)
# transform embedding input into a dictionary
# word2vecc=word2vec.load('word_embedding.txt') #load vocab-vector fiel.word2vecc['w91874']
word2vec_model = word2vec.load(word2vec_model_path, kind='bin')
word2vec_dict = {}
for word, vector in zip(word2vec_model.vocab, word2vec_model.vectors):
word2vec_dict[word] = vector
word_embedding_2dlist = [[]] * vocab_size # create an empty word_embedding list: which is a list of list, i.e. a list of word, where each word is a list of values as an embedding vector.
word_embedding_2dlist[0] = np.zeros(FLAGS.embed_size) # assign empty for first word:'PAD'
bound = np.sqrt(6.0) / np.sqrt(vocab_size) # bound for random variables.
count_exist = 0;
count_not_exist = 0
for i in range(1, vocab_size): # loop each word
word = vocabulary_index2word[i] # get a word
embedding = None
try:
embedding = word2vec_dict[word] # try to get vector:it is an array.
except Exception:
embedding = None
if embedding is not None: # the 'word' exist a embedding
word_embedding_2dlist[i] = embedding;
count_exist = count_exist + 1 # assign array to this word.
else: # no embedding for this word
word_embedding_2dlist[i] = np.random.uniform(-bound, bound, FLAGS.embed_size);
count_not_exist = count_not_exist + 1 # init a random value for the word.
word_embedding_final = np.array(word_embedding_2dlist) # covert to 2d array.
word_embedding = tf.constant(word_embedding_final, dtype=tf.float32) # convert to tensor
t_assign_embedding = tf.assign(model.Embedding,word_embedding) # assign this value to our embedding variables of our model.
sess.run(t_assign_embedding);
if num_run==0:
print("word. exists embedding:", count_exist, " ;word not exist embedding:", count_not_exist)
print("using pre-trained word emebedding.ended...")
# based on a threshold, 在验证集上做验证，报告损失、精确度-multilabel
Example 45
| Project: Automated-Social-Annotation Author: acadTags File: JMAN_train.py MIT License | 5 votes |
|
def assign_pretrained_word_embedding(sess,vocabulary_index2word,vocab_size,model,num_run,word2vec_model_path=None):
if num_run==0:
print("using pre-trained word emebedding.started.word2vec_model_path:",word2vec_model_path)
# transform embedding input into a dictionary
# word2vecc=word2vec.load('word_embedding.txt') #load vocab-vector fiel.word2vecc['w91874']
word2vec_model = word2vec.load(word2vec_model_path, kind='bin')
word2vec_dict = {}
for word, vector in zip(word2vec_model.vocab, word2vec_model.vectors):
word2vec_dict[word] = vector
word_embedding_2dlist = [[]] * vocab_size # create an empty word_embedding list: which is a list of list, i.e. a list of word, where each word is a list of values as an embedding vector.
word_embedding_2dlist[0] = np.zeros(FLAGS.embed_size) # assign empty for first word:'PAD'
bound = np.sqrt(6.0) / np.sqrt(vocab_size) # bound for random variables.
count_exist = 0;
count_not_exist = 0
for i in range(1, vocab_size): # loop each word
word = vocabulary_index2word[i] # get a word
embedding = None
try:
embedding = word2vec_dict[word] # try to get vector:it is an array.
except Exception:
embedding = None
if embedding is not None: # the 'word' exist a embedding
word_embedding_2dlist[i] = embedding;
count_exist = count_exist + 1 # assign array to this word.
else: # no embedding for this word
word_embedding_2dlist[i] = np.random.uniform(-bound, bound, FLAGS.embed_size);
count_not_exist = count_not_exist + 1 # init a random value for the word.
word_embedding_final = np.array(word_embedding_2dlist) # covert to 2d array.
word_embedding = tf.constant(word_embedding_final, dtype=tf.float32) # convert to tensor
t_assign_embedding = tf.assign(model.Embedding,word_embedding) # assign this value to our embedding variables of our model.
sess.run(t_assign_embedding);
if num_run==0:
print("word. exists embedding:", count_exist, " ;word not exist embedding:", count_not_exist)
print("using pre-trained word emebedding.ended...")
Example 46
| Project: Automated-Social-Annotation Author: acadTags File: JMAN_train.py MIT License | 5 votes |
|
def get_label_using_logits_threshold(logits,threshold=0.5):
sig = sigmoid_array(logits)
index_list = np.where(sig > threshold)[0]
return index_list
Example 47
| Project: nonogram-solver Author: mprat File: solver.py MIT License | 5 votes |
|
def possibilities_generator(
prior, min_pos, max_start_pos, constraint_len, total_filled):
"""
Given a row prior, a min_pos, max_start_pos, and constraint length,
yield each potential row
prior is an array of:
-1 (unknown),
0 (definitely empty),
1 (definitely filled)
"""
prior_filled = np.zeros(len(prior)).astype(bool)
prior_filled[prior == 1] = True
prior_empty = np.zeros(len(prior)).astype(bool)
prior_empty[prior == 0] = True
for start_pos in range(min_pos, max_start_pos + 1):
possible = -1 * np.ones(len(prior))
possible[start_pos:start_pos + constraint_len] = 1
if start_pos + constraint_len < len(possible):
possible[start_pos + constraint_len] = 0
if start_pos > 0:
possible[start_pos - 1] = 0
# add in the prior
possible[np.logical_and(possible == -1, prior == 0)] = 0
possible[np.logical_and(possible == -1, prior == 1)] = 1
# if contradiction with prior, continue
# 1. possible changes prior = 1 to something else
# 2. possible changes prior = 0 to something else
# 3. everything is assigned in possible but there are not
# enough filled in
# 4. possible changes nothing about the prior
if np.any(possible[np.where(prior == 1)[0]] != 1) or \
np.any(possible[np.where(prior == 0)[0]] != 0) or \
np.sum(possible == 1) > total_filled or \
(np.all(possible >= 0) and np.sum(possible == 1) <
total_filled) or \
np.all(prior == possible):
continue
yield possible
Example 48
| Project: nonogram-solver Author: mprat File: nonogram.py MIT License | 5 votes |
|
def init_from_matrix(self, matrix):
"""
Args:
matrix (numpy array): array of arrays representing the solution
"""
self.solution_state = matrix
self.solution_list = zip(np.where(matrix == 1))
# TODO: finish this function
Example 49
| Project: FasterRCNN_TF_Py3 Author: upojzsb File: demo.py MIT License | 5 votes |
|
def vis_detections(im, class_name, dets, thresh=0.5):
"""Draw detected bounding boxes."""
inds = np.where(dets[:, -1] >= thresh)[0]
if len(inds) == 0:
return
im = im[:, :, (2, 1, 0)]
fig, ax = plt.subplots(figsize=(12, 12))
ax.imshow(im, aspect='equal')
for i in inds:
bbox = dets[i, :4]
score = dets[i, -1]
ax.add_patch(
plt.Rectangle((bbox[0], bbox[1]),
bbox[2] - bbox[0],
bbox[3] - bbox[1], fill=False,
edgecolor='red', linewidth=3.5)
)
ax.text(bbox[0], bbox[1] - 2,
'{:s} {:.3f}'.format(class_name, score),
bbox=dict(facecolor='blue', alpha=0.5),
fontsize=14, color='white')
ax.set_title(('{} detections with '
'p({} | box) >= {:.1f}').format(class_name, class_name,
thresh),
fontsize=14)
plt.axis('off')
plt.tight_layout()
plt.draw()
Example 50
| Project: FasterRCNN_TF_Py3 Author: upojzsb File: minibatch.py MIT License | 5 votes |
|
def get_minibatch(roidb, num_classes):
"""Given a roidb, construct a minibatch sampled from it."""
num_images = len(roidb)
# Sample random scales to use for each image in this batch
random_scale_inds = npr.randint(0, high=len(cfg.FLAGS2["scales"]),
size=num_images)
assert (cfg.FLAGS.batch_size % num_images == 0), 'num_images ({}) must divide BATCH_SIZE ({})'.format(num_images, cfg.FLAGS.batch_size)
# Get the input image blob, formatted for caffe
im_blob, im_scales = _get_image_blob(roidb, random_scale_inds)
blobs = {'data': im_blob}
assert len(im_scales) == 1, "Single batch only"
assert len(roidb) == 1, "Single batch only"
# gt boxes: (x1, y1, x2, y2, cls)
if cfg.FLAGS.use_all_gt:
# Include all ground truth boxes
gt_inds = np.where(roidb[0]['gt_classes'] != 0)[0]
else:
# For the COCO ground truth boxes, exclude the ones that are ''iscrowd''
gt_inds = np.where(roidb[0]['gt_classes'] != 0 & np.all(roidb[0]['gt_overlaps'].toarray() > -1.0, axis=1))[0]
gt_boxes = np.empty((len(gt_inds), 5), dtype=np.float32)
gt_boxes[:, 0:4] = roidb[0]['boxes'][gt_inds, :] * im_scales[0]
gt_boxes[:, 4] = roidb[0]['gt_classes'][gt_inds]
blobs['gt_boxes'] = gt_boxes
blobs['im_info'] = np.array(
[[im_blob.shape[1], im_blob.shape[2], im_scales[0]]],
dtype=np.float32)
return blobs
Example 51
| Project: FasterRCNN_TF_Py3 Author: upojzsb File: nms.py MIT License | 5 votes |
|
def nms(dets, thresh):
x1 = dets[:, 0]
y1 = dets[:, 1]
x2 = dets[:, 2]
y2 = dets[:, 3]
scores = dets[:, 4]
areas = (x2 - x1 + 1) * (y2 - y1 + 1)
order = scores.argsort()[::-1]
keep = []
while order.size > 0:
i = order[0]
keep.append(i)
xx1 = np.maximum(x1[i], x1[order[1:]])
yy1 = np.maximum(y1[i], y1[order[1:]])
xx2 = np.minimum(x2[i], x2[order[1:]])
yy2 = np.minimum(y2[i], y2[order[1:]])
w = np.maximum(0.0, xx2 - xx1 + 1)
h = np.maximum(0.0, yy2 - yy1 + 1)
inter = w * h
ovr = inter / (areas[i] + areas[order[1:]] - inter)
inds = np.where(ovr <= thresh)[0]
order = order[inds + 1]
return keep
Example 52
| Project: FasterRCNN_TF_Py3 Author: upojzsb File: test.py MIT License | 5 votes |
|
def apply_nms(all_boxes, thresh):
"""Apply non-maximum suppression to all predicted boxes output by the
test_net method.
"""
num_classes = len(all_boxes)
num_images = len(all_boxes[0])
nms_boxes = [[[] for _ in range(num_images)] for _ in range(num_classes)]
for cls_ind in range(num_classes):
for im_ind in range(num_images):
dets = all_boxes[cls_ind][im_ind]
if dets == []:
continue
x1 = dets[:, 0]
y1 = dets[:, 1]
x2 = dets[:, 2]
y2 = dets[:, 3]
scores = dets[:, 4]
inds = np.where((x2 > x1) & (y2 > y1) & (scores > cfg.FLAGS.DET_THRESHOLD))[0]
dets = dets[inds, :]
if dets == []:
continue
keep = nms(dets, thresh)
if len(keep) == 0:
continue
nms_boxes[cls_ind][im_ind] = dets[keep, :].copy()
return nms_boxes
Example 53
| Project: FasterRCNN_TF_Py3 Author: upojzsb File: py_cpu_nms.py MIT License | 5 votes |
|
def py_cpu_nms(dets, thresh):
"""Pure Python NMS baseline."""
x1 = dets[:, 0]
y1 = dets[:, 1]
x2 = dets[:, 2]
y2 = dets[:, 3]
scores = dets[:, 4]
areas = (x2 - x1 + 1) * (y2 - y1 + 1)
order = scores.argsort()[::-1]
keep = []
while order.size > 0:
i = order[0]
keep.append(i)
xx1 = np.maximum(x1[i], x1[order[1:]])
yy1 = np.maximum(y1[i], y1[order[1:]])
xx2 = np.minimum(x2[i], x2[order[1:]])
yy2 = np.minimum(y2[i], y2[order[1:]])
w = np.maximum(0.0, xx2 - xx1 + 1)
h = np.maximum(0.0, yy2 - yy1 + 1)
inter = w * h
ovr = inter / (areas[i] + areas[order[1:]] - inter)
inds = np.where(ovr <= thresh)[0]
order = order[inds + 1]
return keep
Example 54
| Project: FasterRCNN_TF_Py3 Author: upojzsb File: voc_eval.py MIT License | 5 votes |
|
def voc_ap(rec, prec, use_07_metric=False):
""" ap = voc_ap(rec, prec, [use_07_metric])
Compute VOC AP given precision and recall.
If use_07_metric is true, uses the
VOC 07 11 point method (default:False).
"""
if use_07_metric:
# 11 point metric
ap = 0.
for t in np.arange(0., 1.1, 0.1):
if np.sum(rec >= t) == 0:
p = 0
else:
p = np.max(prec[rec >= t])
ap = ap + p / 11.
else:
# correct AP calculation
# first append sentinel values at the end
mrec = np.concatenate(([0.], rec, [1.]))
mpre = np.concatenate(([0.], prec, [0.]))
# compute the precision envelope
for i in range(mpre.size - 1, 0, -1):
mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])
# to calculate area under PR curve, look for points
# where X axis (recall) changes value
i = np.where(mrec[1:] != mrec[:-1])[0]
# and sum (\Delta recall) * prec
ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])
return ap
Example 55
| Project: FasterRCNN_TF_Py3 Author: upojzsb File: coco.py MIT License | 5 votes |
|
def __init__(self, image_set, year):
imdb.__init__(self, 'coco_' + year + '_' + image_set)
# COCO specific config options
self.config = {'use_salt': True,
'cleanup': True}
# name, paths
self._year = year
self._image_set = image_set
self._data_path = osp.join(cfg.FLAGS2["data_dir"], 'coco')
# load COCO API, classes, class <-> id mappings
self._COCO = COCO(self._get_ann_file())
cats = self._COCO.loadCats(self._COCO.getCatIds())
self._classes = tuple(['__background__'] + [c['name'] for c in cats])
self._class_to_ind = dict(list(zip(self.classes, list(range(self.num_classes)))))
self._class_to_coco_cat_id = dict(list(zip([c['name'] for c in cats],
self._COCO.getCatIds())))
self._image_index = self._load_image_set_index()
# Default to roidb handler
self.set_proposal_method('gt')
self.competition_mode(False)
# Some image sets are "views" (i.e. subsets) into others.
# For example, minival2014 is a random 5000 image subset of val2014.
# This mapping tells us where the view's images and proposals come from.
self._view_map = {
'minival2014': 'val2014', # 5k val2014 subset
'valminusminival2014': 'val2014', # val2014 \setminus minival2014
'test-dev2015': 'test2015',
}
coco_name = image_set + year # e.g., "val2014"
self._data_name = (self._view_map[coco_name]
if coco_name in self._view_map
else coco_name)
# Dataset splits that have ground-truth annotations (test splits
# do not have gt annotations)
self._gt_splits = ('train', 'val', 'minival')
Example 56
| Project: FasterRCNN_TF_Py3 Author: upojzsb File: coco.py MIT License | 5 votes |
|
def _print_detection_eval_metrics(self, coco_eval):
IoU_lo_thresh = 0.5
IoU_hi_thresh = 0.95
def _get_thr_ind(coco_eval, thr):
ind = np.where((coco_eval.params.iouThrs > thr - 1e-5) &
(coco_eval.params.iouThrs < thr + 1e-5))[0][0]
iou_thr = coco_eval.params.iouThrs[ind]
assert np.isclose(iou_thr, thr)
return ind
ind_lo = _get_thr_ind(coco_eval, IoU_lo_thresh)
ind_hi = _get_thr_ind(coco_eval, IoU_hi_thresh)
# precision has dims (iou, recall, cls, area range, max dets)
# area range index 0: all area ranges
# max dets index 2: 100 per image
precision = \
coco_eval.eval['precision'][ind_lo:(ind_hi + 1), :, :, 0, 2]
ap_default = np.mean(precision[precision > -1])
print(('~~~~ Mean and per-category AP @ IoU=[{:.2f},{:.2f}] '
'~~~~').format(IoU_lo_thresh, IoU_hi_thresh))
print('{:.1f}'.format(100 * ap_default))
for cls_ind, cls in enumerate(self.classes):
if cls == '__background__':
continue
# minus 1 because of __background__
precision = coco_eval.eval['precision'][ind_lo:(ind_hi + 1), :, cls_ind - 1, 0, 2]
ap = np.mean(precision[precision > -1])
print('{:.1f}'.format(100 * ap))
print('~~~~ Summary metrics ~~~~')
coco_eval.summarize()
Example 57
| Project: FasterRCNN_TF_Py3 Author: upojzsb File: imdb.py MIT License | 5 votes |
|
def create_roidb_from_box_list(self, box_list, gt_roidb):
assert len(box_list) == self.num_images, \
'Number of boxes must match number of ground-truth images'
roidb = []
for i in range(self.num_images):
boxes = box_list[i]
num_boxes = boxes.shape[0]
overlaps = np.zeros((num_boxes, self.num_classes), dtype=np.float32)
if gt_roidb is not None and gt_roidb[i]['boxes'].size > 0:
gt_boxes = gt_roidb[i]['boxes']
gt_classes = gt_roidb[i]['gt_classes']
gt_overlaps = bbox_overlaps(boxes.astype(np.float),
gt_boxes.astype(np.float))
argmaxes = gt_overlaps.argmax(axis=1)
maxes = gt_overlaps.max(axis=1)
I = np.where(maxes > 0)[0]
overlaps[I, gt_classes[argmaxes[I]]] = maxes[I]
overlaps = scipy.sparse.csr_matrix(overlaps)
roidb.append({
'boxes': boxes,
'gt_classes': np.zeros((num_boxes,), dtype=np.int32),
'gt_overlaps': overlaps,
'flipped': False,
'seg_areas': np.zeros((num_boxes,), dtype=np.float32),
})
return roidb
Example 58
| Project: FasterRCNN_TF_Py3 Author: upojzsb File: roidb.py MIT License | 5 votes |
|
def prepare_roidb(imdb):
"""Enrich the imdb's roidb by adding some derived quantities that
are useful for training. This function precomputes the maximum
overlap, taken over ground-truth boxes, between each ROI and
each ground-truth box. The class with maximum overlap is also
recorded.
"""
roidb = imdb.roidb
if not (imdb.name.startswith('coco')):
sizes = [PIL.Image.open(imdb.image_path_at(i)).size
for i in range(imdb.num_images)]
for i in range(len(imdb.image_index)):
roidb[i]['image'] = imdb.image_path_at(i)
if not (imdb.name.startswith('coco')):
roidb[i]['width'] = sizes[i][0]
roidb[i]['height'] = sizes[i][1]
# need gt_overlaps as a dense array for argmax
gt_overlaps = roidb[i]['gt_overlaps'].toarray()
# max overlap with gt over classes (columns)
max_overlaps = gt_overlaps.max(axis=1)
# gt class that had the max overlap
max_classes = gt_overlaps.argmax(axis=1)
roidb[i]['max_classes'] = max_classes
roidb[i]['max_overlaps'] = max_overlaps
# sanity checks
# max overlap of 0 => class should be zero (background)
zero_inds = np.where(max_overlaps == 0)[0]
assert all(max_classes[zero_inds] == 0)
# max overlap > 0 => class should not be zero (must be a fg class)
nonzero_inds = np.where(max_overlaps > 0)[0]
assert all(max_classes[nonzero_inds] != 0)
Example 59
| Project: Lane-And-Vehicle-Detection Author: JustinHeaton File: main.py MIT License | 5 votes |
|
def blind_search(self, x, y, image):
'''
This function is applied in the first few frames and/or if the lane was not successfully detected
in the previous frame. It uses a slinding window approach to detect peaks in a histogram of the
binary thresholded image. Pixels in close proimity to the detected peaks are considered to belong
to the lane lines.
'''
xvals = []
yvals = []
if self.found == False:
i = 720
j = 630
histogram = np.sum(image[image.shape[0]//2:], axis=0)
if self == Right:
peak = np.argmax(histogram[image.shape[1]//2:]) + image.shape[1]//2
else:
peak = np.argmax(histogram[:image.shape[1]//2])
while j >= 0:
x_idx = np.where((((peak - 100) < x)&(x < (peak + 100))&((y > j) & (y < i))))
x_window, y_window = x[x_idx], y[x_idx]
if np.sum(x_window) != 0:
xvals.extend(x_window)
yvals.extend(y_window)
if np.sum(x_window) > 100:
peak = np.int(np.mean(x_window))
i -= 90
j -= 90
if np.sum(xvals) > 0:
self.found = True
else:
yvals = self.Y
xvals = self.X
return xvals, yvals, self.found
Example 60
| Project: mmdetection Author: open-mmlab File: sampler.py Apache License 2.0 | 5 votes |
|
def __iter__(self):
# deterministically shuffle based on epoch
g = torch.Generator()
g.manual_seed(self.epoch)
indices = []
for i, size in enumerate(self.group_sizes):
if size > 0:
indice = np.where(self.flag == i)[0]
assert len(indice) == size
indice = indice[list(torch.randperm(int(size),
generator=g))].tolist()
extra = int(
math.ceil(
size * 1.0 / self.samples_per_gpu / self.num_replicas)
) * self.samples_per_gpu * self.num_replicas - len(indice)
# pad indice
tmp = indice.copy()
for _ in range(extra // size):
indice.extend(tmp)
indice.extend(tmp[:extra % size])
indices.extend(indice)
assert len(indices) == self.total_size
indices = [
indices[j] for i in list(
torch.randperm(
len(indices) // self.samples_per_gpu, generator=g))
for j in range(i * self.samples_per_gpu, (i + 1) *
self.samples_per_gpu)
]
# subsample
offset = self.num_samples * self.rank
indices = indices[offset:offset + self.num_samples]
assert len(indices) == self.num_samples
return iter(indices)
Example 61
| Project: mmdetection Author: open-mmlab File: iou_balanced_neg_sampler.py Apache License 2.0 | 5 votes |
|
def sample_via_interval(self, max_overlaps, full_set, num_expected):
max_iou = max_overlaps.max()
iou_interval = (max_iou - self.floor_thr) / self.num_bins
per_num_expected = int(num_expected / self.num_bins)
sampled_inds = []
for i in range(self.num_bins):
start_iou = self.floor_thr + i * iou_interval
end_iou = self.floor_thr + (i + 1) * iou_interval
tmp_set = set(
np.where(
np.logical_and(max_overlaps >= start_iou,
max_overlaps < end_iou))[0])
tmp_inds = list(tmp_set & full_set)
if len(tmp_inds) > per_num_expected:
tmp_sampled_set = self.random_choice(tmp_inds,
per_num_expected)
else:
tmp_sampled_set = np.array(tmp_inds, dtype=np.int)
sampled_inds.append(tmp_sampled_set)
sampled_inds = np.concatenate(sampled_inds)
if len(sampled_inds) < num_expected:
num_extra = num_expected - len(sampled_inds)
extra_inds = np.array(list(full_set - set(sampled_inds)))
if len(extra_inds) > num_extra:
extra_inds = self.random_choice(extra_inds, num_extra)
sampled_inds = np.concatenate([sampled_inds, extra_inds])
return sampled_inds
Example 62
| Project: Kaggle-Statoil-Challenge Author: adodd202 File: utils.py MIT License | 5 votes |
|
def MinMaxBestBaseStacking(input_folder, best_base, output_path):
sub_base = pd.read_csv(best_base)
all_files = os.listdir(input_folder)
# Read and concatenate submissions
outs = [pd.read_csv(os.path.join(input_folder, f), index_col=0) for f in all_files]
concat_sub = pd.concat(outs, axis=1)
cols = list(map(lambda x: "is_iceberg_" + str(x), range(len(concat_sub.columns))))
concat_sub.columns = cols
concat_sub.reset_index(inplace=True)
# get the data fields ready for stacking
concat_sub['is_iceberg_max'] = concat_sub.iloc[:, 1:6].max(axis=1)
concat_sub['is_iceberg_min'] = concat_sub.iloc[:, 1:6].min(axis=1)
concat_sub['is_iceberg_mean'] = concat_sub.iloc[:, 1:6].mean(axis=1)
concat_sub['is_iceberg_median'] = concat_sub.iloc[:, 1:6].median(axis=1)
# set up cutoff threshold for lower and upper bounds, easy to twist
cutoff_lo = 0.67
cutoff_hi = 0.33
concat_sub['is_iceberg_base'] = sub_base['is_iceberg']
concat_sub['is_iceberg'] = np.where(np.all(concat_sub.iloc[:, 1:6] > cutoff_lo, axis=1),
concat_sub['is_iceberg_max'],
np.where(np.all(concat_sub.iloc[:, 1:6] < cutoff_hi, axis=1),
concat_sub['is_iceberg_min'],
concat_sub['is_iceberg_base']))
concat_sub[['id', 'is_iceberg']].to_csv(output_path,
index=False, float_format='%.12f')
Example 63
| Project: neural-fingerprinting Author: StephanZheng File: facenet_fgsm.py BSD 3-Clause "New" or "Revised" License | 5 votes |
|
def convert_to_classifier(self):
# Create victim_embedding placeholder
self.victim_embedding_input = tf.placeholder(
tf.float32,
shape=(None, 128))
# Squared Euclidean Distance between embeddings
distance = tf.reduce_sum(
tf.square(self.embedding_output - self.victim_embedding_input),
axis=1)
# Convert distance to a softmax vector
# 0.99 out of 4 is the distance threshold for the Facenet CNN
threshold = 0.99
score = tf.where(
distance > threshold,
0.5 + ((distance - threshold) * 0.5) / (4.0 - threshold),
0.5 * distance / threshold)
reverse_score = 1.0 - score
self.softmax_output = tf.transpose(tf.stack([reverse_score, score]))
# Save softmax layer
self.layer_names = []
self.layers = []
self.layers.append(self.softmax_output)
self.layer_names.append('probs')
Example 64
| Project: models Author: kipoi File: bio_utils.py MIT License | 5 votes |
|
def remove_post_padding(signal):
X_not_padded = len(signal) * [[]]
for i in range(len(signal)):
pad_initIdx = np.where(signal[i] == 0)
if np.size(pad_initIdx) == 0:
X_not_padded[i] = signal[i]
else:
X_not_padded[i] = signal[i][0:pad_initIdx[0][0]]
return (X_not_padded)
Example 65
| Project: programsynthesishunting Author: flexgp File: math_functions.py GNU General Public License v3.0 | 5 votes |
|
def pdiv(x, y):
"""
Koza's protected division is:
if y == 0:
return 1
else:
return x / y
but we want an eval-able expression. The following is eval-able:
return 1 if y == 0 else x / y
but if x and y are Numpy arrays, this creates a new Boolean
array with value (y == 0). if doesn't work on a Boolean array.
The equivalent for Numpy is a where statement, as below. However
this always evaluates x / y before running np.where, so that
will raise a 'divide' error (in Numpy's terminology), which we
ignore using a context manager.
In some instances, Numpy can raise a FloatingPointError. These are
ignored with 'invalid = ignore'.
:param x: numerator np.array
:param y: denominator np.array
:return: np.array of x / y, or 1 where y is 0.
"""
try:
with np.errstate(divide='ignore', invalid='ignore'):
return np.where(y == 0, np.ones_like(x), x / y)
except ZeroDivisionError:
# In this case we are trying to divide two constants, one of which is 0
# Return a constant.
return 1.0
Example 66
| Project: programsynthesishunting Author: flexgp File: math_functions.py GNU General Public License v3.0 | 5 votes |
|
def rlog(x):
"""
Koza's protected log:
if x == 0:
return 1
else:
return log(abs(x))
See pdiv above for explanation of this type of code.
:param x: argument to log, np.array
:return: np.array of log(x), or 1 where x is 0.
"""
with np.errstate(divide='ignore'):
return np.where(x == 0, np.ones_like(x), np.log(np.abs(x)))
Example 67
| Project: programsynthesishunting Author: flexgp File: math_functions.py GNU General Public License v3.0 | 5 votes |
|
def ppow(x, y):
"""pow(x, y) is undefined in the case where x negative and y
non-integer. This takes abs(x) to avoid it.
:param x: np.array, base
:param y: np.array, exponent
:return: np.array x**y, but protected
"""
return np.abs(x)**y
Example 68
| Project: programsynthesishunting Author: flexgp File: math_functions.py GNU General Public License v3.0 | 5 votes |
|
def ppow2(x, y):
"""pow(x, y) is undefined in the case where x negative and y
non-integer. This takes abs(x) to avoid it. But it preserves
sign using sign(x).
:param x: np.array, base
:param y: np.array, exponent
:return: np.array, x**y, but protected
"""
return np.sign(x) * (np.abs(x) ** y)
Example 69
| Project: b2ac Author: hbldh File: reference.py MIT License | 4 votes |
|
def fit_improved_B2AC_numpy(points):
"""Ellipse fitting in Python with improved B2AC algorithm as described in
this `paper <http://autotrace.sourceforge.net/WSCG98.pdf>`_.
This version of the fitting simply applies NumPy:s methods for calculating
the conic section, modelled after the Matlab code in the paper:
.. code-block::
function a = fit_ellipse(x, y)
D1 = [x .ˆ 2, x .* y, y .ˆ 2]; % quadratic part of the design matrix
D2 = [x, y, ones(size(x))]; % linear part of the design matrix
S1 = D1’ * D1; % quadratic part of the scatter matrix
S2 = D1’ * D2; % combined part of the scatter matrix
S3 = D2’ * D2; % linear part of the scatter matrix
T = - inv(S3) * S2’; % for getting a2 from a1
M = S1 + S2 * T; % reduced scatter matrix
M = [M(3, :) ./ 2; - M(2, :); M(1, :) ./ 2]; % premultiply by inv(C1)
[evec, eval] = eig(M); % solve eigensystem
cond = 4 * evec(1, :) .* evec(3, :) - evec(2, :) .ˆ 2; % evaluate a’Ca
a1 = evec(:, find(cond > 0)); % eigenvector for min. pos. eigenvalue
a = [a1; T * a1]; % ellipse coefficients
:param points: The [Nx2] array of points to fit ellipse to.
:type points: :py:class:`numpy.ndarray`
:return: The conic section array defining the fitted ellipse.
:rtype: :py:class:`numpy.ndarray`
"""
x = points[:, 0]
y = points[:, 1]
D1 = np.vstack([x ** 2, x * y, y ** 2]).T
D2 = np.vstack([x, y, np.ones((len(x), ), dtype=x.dtype)]).T
S1 = D1.T.dot(D1)
S2 = D1.T.dot(D2)
S3 = D2.T.dot(D2)
T = -np.linalg.inv(S3).dot(S2.T)
M = S1 + S2.dot(T)
M = np.array([M[2, :] / 2, -M[1, :], M[0, :] / 2])
eval, evec = np.linalg.eig(M)
cond = (4 * evec[:, 0] * evec[:, 2]) - (evec[:, 1] ** 2)
I = np.where(cond > 0)[0]
a1 = evec[:, I[np.argmin(cond[I])]]
return np.concatenate([a1, T.dot(a1)])
Example 70
| Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: minibatch.py MIT License | 4 votes |
|
def get_minibatch(roidb, num_classes):
"""Given a roidb, construct a minibatch sampled from it."""
num_images = len(roidb)
# Sample random scales to use for each image in this batch
random_scale_inds = npr.randint(0, high=len(cfg.TRAIN.SCALES),
size=num_images)
assert(cfg.TRAIN.BATCH_SIZE % num_images == 0), \
'num_images ({}) must divide BATCH_SIZE ({})'. \
format(num_images, cfg.TRAIN.BATCH_SIZE)
# Get the input image blob, formatted for caffe
im_blob, im_scales = _get_image_blob(roidb, random_scale_inds)
blobs = {'data': im_blob}
assert len(im_scales) == 1, "Single batch only"
assert len(roidb) == 1, "Single batch only"
# gt boxes: (x1, y1, x2, y2, cls)
#if cfg.TRAIN.USE_ALL_GT:
# Include all ground truth boxes
# gt_inds = np.where(roidb[0]['gt_classes'] != 0)[0]
#else:
# For the COCO ground truth boxes, exclude the ones that are ''iscrowd''
# gt_inds = np.where(roidb[0]['gt_classes'] != 0 & np.all(roidb[0]['gt_overlaps'].toarray() > -1.0, axis=1))[0]
#gt_boxes = np.empty((len(gt_inds), 5), dtype=np.float32)
#gt_boxes[:, 0:4] = roidb[0]['boxes'][gt_inds, :] * im_scales[0]
#gt_boxes[:, 4] = roidb[0]['gt_classes'][gt_inds]
boxes = roidb[0]['boxes'] * im_scales[0]
batch_ind = 0 * np.ones((boxes.shape[0], 1))
boxes = np.hstack((batch_ind, boxes))
DEDUP_BOXES=1./16.
if DEDUP_BOXES > 0:
v = np.array([1,1e3, 1e6, 1e9, 1e12])
hashes = np.round(boxes * DEDUP_BOXES).dot(v)
_, index, inv_index = np.unique(hashes, return_index=True,
return_inverse=True)
boxes = boxes[index, :]
blobs['boxes'] = boxes
blobs['im_info'] = np.array(
[im_blob.shape[1], im_blob.shape[2], im_scales[0]],
dtype=np.float32)
blobs['labels'] = roidb[0]['labels']
return blobs
Example 71
| Project: kaldi-python-io Author: funcwj File: _io_kernel.py Apache License 2.0 | 4 votes |
|
def uncompress(cdata, cps_type, head):
"""
In format CM(kOneByteWithColHeaders):
PerColHeader, ...(x C), ... uint8 sequence ...
first: get each PerColHeader pch for a single column
then : using pch to uncompress each float in the column
We load it seperately at a time
In format CM2(kTwoByte):
...uint16 sequence...
In format CM3(kOneByte):
...uint8 sequence...
"""
min_val, prange, num_rows, num_cols = head
# mat = np.zeros([num_rows, num_cols])
print_info('\tUncompress to matrix {} X {}'.format(num_rows, num_cols))
if cps_type == 'CM':
# checking compressed data size, 8 is the sizeof PerColHeader
assert len(cdata) == num_cols * (8 + num_rows)
chead, cmain = cdata[:8 * num_cols], cdata[8 * num_cols:]
# type uint16
pch = np.fromstring(chead, dtype=np.uint16).astype(np.float32)
pch = np.transpose(pch.reshape(num_cols, 4))
pch = pch * prange / 65535.0 + min_val
# type uint8
uint8 = np.fromstring(cmain, dtype=np.uint8).astype(np.float32)
uint8 = np.transpose(uint8.reshape(num_cols, num_rows))
# precompute index
le64_index = uint8 <= 64
gt92_index = uint8 >= 193
# le92_index = np.logical_not(np.logical_xor(le64_index, gt92_index))
return np.where(
le64_index,
uint8 * (pch[1] - pch[0]) / 64.0 + pch[0],
np.where(gt92_index,
(uint8 - 192) * (pch[3] - pch[2]) / 63.0 + pch[2],
(uint8 - 64) * (pch[2] - pch[1]) / 128.0 + pch[1]))
else:
if cps_type == 'CM2':
inc = float(prange / 65535.0)
uint_seq = np.fromstring(cdata, dtype=np.uint16).astype(np.float32)
else:
inc = float(prange / 255.0)
uint_seq = np.fromstring(cdata, dtype=np.uint8).astype(np.float32)
mat = min_val + uint_seq.reshape(num_rows, num_cols) * inc
return mat
Example 72
| Project: FasterRCNN_TF_Py3 Author: upojzsb File: test.py MIT License | 4 votes |
|
def test_net(sess, net, imdb, weights_filename, max_per_image=100, thresh=0.05):
np.random.seed(cfg.FLAGS.rng_seed)
"""Test a Fast R-CNN network on an image database."""
num_images = len(imdb.image_index)
# all detections are collected into:
# all_boxes[cls][image] = N x 5 array of detections in
# (x1, y1, x2, y2, score)
all_boxes = [[[] for _ in range(num_images)]
for _ in range(imdb.num_classes)]
output_dir = get_output_dir(imdb, weights_filename)
# timers
_t = {'im_detect': Timer(), 'misc': Timer()}
for i in range(num_images):
im = cv2.imread(imdb.image_path_at(i))
_t['im_detect'].tic()
scores, boxes = im_detect(sess, net, im)
_t['im_detect'].toc()
_t['misc'].tic()
# skip j = 0, because it's the background class
for j in range(1, imdb.num_classes):
inds = np.where(scores[:, j] > thresh)[0]
cls_scores = scores[inds, j]
cls_boxes = boxes[inds, j * 4:(j + 1) * 4]
cls_dets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])) \
.astype(np.float32, copy=False)
keep = nms(cls_dets, 0.3)
cls_dets = cls_dets[keep, :]
all_boxes[j][i] = cls_dets
# Limit to max_per_image detections *over all classes*
if max_per_image > 0:
image_scores = np.hstack([all_boxes[j][i][:, -1]
for j in range(1, imdb.num_classes)])
if len(image_scores) > max_per_image:
image_thresh = np.sort(image_scores)[-max_per_image]
for j in range(1, imdb.num_classes):
keep = np.where(all_boxes[j][i][:, -1] >= image_thresh)[0]
all_boxes[j][i] = all_boxes[j][i][keep, :]
_t['misc'].toc()
print('im_detect: {:d}/{:d} {:.3f}s {:.3f}s' \
.format(i + 1, num_images, _t['im_detect'].average_time,
_t['misc'].average_time))
det_file = os.path.join(output_dir, 'detections.pkl')
with open(det_file, 'wb') as f:
pickle.dump(all_boxes, f, pickle.HIGHEST_PROTOCOL)
print('Evaluating detections')
imdb.evaluate_detections(all_boxes, output_dir)
Example 73
| Project: FasterRCNN_TF_Py3 Author: upojzsb File: proposal_target_layer.py MIT License | 4 votes |
|
def _sample_rois(all_rois, all_scores, gt_boxes, fg_rois_per_image, rois_per_image, num_classes):
"""Generate a random sample of RoIs comprising foreground and background
examples.
"""
# overlaps: (rois x gt_boxes)
overlaps = bbox_overlaps(
np.ascontiguousarray(all_rois[:, 1:5], dtype=np.float),
np.ascontiguousarray(gt_boxes[:, :4], dtype=np.float))
gt_assignment = overlaps.argmax(axis=1)
max_overlaps = overlaps.max(axis=1)
labels = gt_boxes[gt_assignment, 4]
# Select foreground RoIs as those with >= FG_THRESH overlap
fg_inds = np.where(max_overlaps >= cfg.FLAGS.roi_fg_threshold)[0]
# Guard against the case when an image has fewer than fg_rois_per_image
# Select background RoIs as those within [BG_THRESH_LO, BG_THRESH_HI)
bg_inds = np.where((max_overlaps < cfg.FLAGS.roi_bg_threshold_high) &
(max_overlaps >= cfg.FLAGS.roi_bg_threshold_low))[0]
# Small modification to the original version where we ensure a fixed number of regions are sampled
if fg_inds.size > 0 and bg_inds.size > 0:
fg_rois_per_image = min(fg_rois_per_image, fg_inds.size)
fg_inds = npr.choice(fg_inds, size=int(fg_rois_per_image), replace=False)
bg_rois_per_image = rois_per_image - fg_rois_per_image
to_replace = bg_inds.size < bg_rois_per_image
bg_inds = npr.choice(bg_inds, size=int(bg_rois_per_image), replace=to_replace)
elif fg_inds.size > 0:
to_replace = fg_inds.size < rois_per_image
fg_inds = npr.choice(fg_inds, size=int(rois_per_image), replace=to_replace)
fg_rois_per_image = rois_per_image
elif bg_inds.size > 0:
to_replace = bg_inds.size < rois_per_image
bg_inds = npr.choice(bg_inds, size=int(rois_per_image), replace=to_replace)
fg_rois_per_image = 0
else:
import pdb
pdb.set_trace()
# The indices that we're selecting (both fg and bg)
keep_inds = np.append(fg_inds, bg_inds)
# Select sampled values from various arrays:
labels = labels[keep_inds]
# Clamp labels for the background RoIs to 0
labels[int(fg_rois_per_image):] = 0
rois = all_rois[keep_inds]
roi_scores = all_scores[keep_inds]
bbox_target_data = _compute_targets(
rois[:, 1:5], gt_boxes[gt_assignment[keep_inds], :4], labels)
bbox_targets, bbox_inside_weights = \
_get_bbox_regression_labels(bbox_target_data, num_classes)
return labels, rois, roi_scores, bbox_targets, bbox_inside_weights
Example 74
| Project: kuaa Author: rafaelwerneck File: OPF.py GNU General Public License v3.0 | 4 votes |
|
def __prim(self, A):
"""
Parameters:
A = Weighted adjacency matrix. Non connected nodes have weigh 'Inf'.
Note:
Return:
B = weighted adjacency matrix corresponding to the MST of A.
"""
root = 0
# prevents zero-weighted MSTs
A = A.astype('double')
n = A.shape[0]
if n == 0: return []
d = np.zeros(n) # type(d) = numpy.ndarray
pred = np.zeros(n, int) # type(pred) = numpy.ndarray
B = np.ones(A.shape) * float("inf") # type(B) = numpy.ndarray
b0 = root # first vertex as root. type(b0) = int
Q = range(0, n) # all vertices. type(Q) = list
Q.remove(root) # except the root.
d[Q] = A[Q, b0] # distances from root.
pred[Q] = b0 # predecessor as root.
while Q != []:
s = np.argmin(d[Q]) # function `argmin' in module `numpy.core.fromnumeric'.
closest_i = Q[s] # find vertex in Q with smallest weight from b0
Q.remove(closest_i)
b0 = closest_i
b1 = pred[closest_i]
B[b0, b1] = B[b1, b0] = A[b0, b1] # insert this edge in MST weight matrix
if Q == []: break
QA = np.array(Q) # remaining vertexes.
iii = np.where(A[QA, closest_i] < d[QA])
d[QA[iii]] = A[QA[iii], closest_i] # update weights to pred
pred[QA[iii]] = closest_i # update pred
return B
# @staticmethod
Example 75
| Project: mmdetection Author: open-mmlab File: inference.py Apache License 2.0 | 4 votes |
|
def show_result(img,
result,
class_names,
score_thr=0.3,
wait_time=0,
show=True,
out_file=None):
"""Visualize the detection results on the image.
Args:
img (str or np.ndarray): Image filename or loaded image.
result (tuple[list] or list): The detection result, can be either
(bbox, segm) or just bbox.
class_names (list[str] or tuple[str]): A list of class names.
score_thr (float): The threshold to visualize the bboxes and masks.
wait_time (int): Value of waitKey param.
show (bool, optional): Whether to show the image with opencv or not.
out_file (str, optional): If specified, the visualization result will
be written to the out file instead of shown in a window.
Returns:
np.ndarray or None: If neither `show` nor `out_file` is specified, the
visualized image is returned, otherwise None is returned.
"""
assert isinstance(class_names, (tuple, list))
img = mmcv.imread(img)
img = img.copy()
if isinstance(result, tuple):
bbox_result, segm_result = result
else:
bbox_result, segm_result = result, None
bboxes = np.vstack(bbox_result)
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(0, 256, (1, 3), dtype=np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool)
img[mask] = img[mask] * 0.5 + color_mask * 0.5
# draw bounding boxes
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
mmcv.imshow_det_bboxes(
img,
bboxes,
labels,
class_names=class_names,
score_thr=score_thr,
show=show,
wait_time=wait_time,
out_file=out_file)
if not (show or out_file):
return img
Example 76
| Project: mmdetection Author: open-mmlab File: base.py Apache License 2.0 | 4 votes |
|
def show_result(self, data, result, dataset=None, score_thr=0.3):
if isinstance(result, tuple):
bbox_result, segm_result = result
else:
bbox_result, segm_result = result, None
img_tensor = data['img'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_metas[0]['img_norm_cfg'])
assert len(imgs) == len(img_metas)
if dataset is None:
class_names = self.CLASSES
elif isinstance(dataset, str):
class_names = get_classes(dataset)
elif isinstance(dataset, (list, tuple)):
class_names = dataset
else:
raise TypeError(
'dataset must be a valid dataset name or a sequence'
' of class names, not {}'.format(type(dataset)))
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
bboxes = np.vstack(bbox_result)
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(
0, 256, (1, 3), dtype=np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool)
img_show[mask] = img_show[mask] * 0.5 + color_mask * 0.5
# draw bounding boxes
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
mmcv.imshow_det_bboxes(
img_show,
bboxes,
labels,
class_names=class_names,
score_thr=score_thr)
Example 77
| Project: mmdetection Author: open-mmlab File: transforms.py Apache License 2.0 | 4 votes |
|
def __call__(self, results):
img = results['img']
margin_h = max(img.shape[0] - self.crop_size[0], 0)
margin_w = max(img.shape[1] - self.crop_size[1], 0)
offset_h = np.random.randint(0, margin_h + 1)
offset_w = np.random.randint(0, margin_w + 1)
crop_y1, crop_y2 = offset_h, offset_h + self.crop_size[0]
crop_x1, crop_x2 = offset_w, offset_w + self.crop_size[1]
# crop the image
img = img[crop_y1:crop_y2, crop_x1:crop_x2, :]
img_shape = img.shape
results['img'] = img
results['img_shape'] = img_shape
# crop bboxes accordingly and clip to the image boundary
for key in results.get('bbox_fields', []):
bbox_offset = np.array([offset_w, offset_h, offset_w, offset_h],
dtype=np.float32)
bboxes = results[key] - bbox_offset
bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, img_shape[1] - 1)
bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, img_shape[0] - 1)
results[key] = bboxes
# filter out the gt bboxes that are completely cropped
if 'gt_bboxes' in results:
gt_bboxes = results['gt_bboxes']
valid_inds = (gt_bboxes[:, 2] > gt_bboxes[:, 0]) & (
gt_bboxes[:, 3] > gt_bboxes[:, 1])
# if no gt bbox remains after cropping, just skip this image
if not np.any(valid_inds):
return None
results['gt_bboxes'] = gt_bboxes[valid_inds, :]
if 'gt_labels' in results:
results['gt_labels'] = results['gt_labels'][valid_inds]
# filter and crop the masks
if 'gt_masks' in results:
valid_gt_masks = []
for i in np.where(valid_inds)[0]:
gt_mask = results['gt_masks'][i][crop_y1:crop_y2,
crop_x1:crop_x2]
valid_gt_masks.append(gt_mask)
results['gt_masks'] = valid_gt_masks
return results
Example 78
| Project: mmdetection Author: open-mmlab File: mean_ap.py Apache License 2.0 | 4 votes |
|
def average_precision(recalls, precisions, mode='area'):
"""Calculate average precision (for single or multiple scales).
Args:
recalls (ndarray): shape (num_scales, num_dets) or (num_dets, )
precisions (ndarray): shape (num_scales, num_dets) or (num_dets, )
mode (str): 'area' or '11points', 'area' means calculating the area
under precision-recall curve, '11points' means calculating
the average precision of recalls at [0, 0.1, ..., 1]
Returns:
float or ndarray: calculated average precision
"""
no_scale = False
if recalls.ndim == 1:
no_scale = True
recalls = recalls[np.newaxis, :]
precisions = precisions[np.newaxis, :]
assert recalls.shape == precisions.shape and recalls.ndim == 2
num_scales = recalls.shape[0]
ap = np.zeros(num_scales, dtype=np.float32)
if mode == 'area':
zeros = np.zeros((num_scales, 1), dtype=recalls.dtype)
ones = np.ones((num_scales, 1), dtype=recalls.dtype)
mrec = np.hstack((zeros, recalls, ones))
mpre = np.hstack((zeros, precisions, zeros))
for i in range(mpre.shape[1] - 1, 0, -1):
mpre[:, i - 1] = np.maximum(mpre[:, i - 1], mpre[:, i])
for i in range(num_scales):
ind = np.where(mrec[i, 1:] != mrec[i, :-1])[0]
ap[i] = np.sum(
(mrec[i, ind + 1] - mrec[i, ind]) * mpre[i, ind + 1])
elif mode == '11points':
for i in range(num_scales):
for thr in np.arange(0, 1 + 1e-3, 0.1):
precs = precisions[i, recalls[i, :] >= thr]
prec = precs.max() if precs.size > 0 else 0
ap[i] += prec
ap /= 11
else:
raise ValueError(
'Unrecognized mode, only "area" and "11points" are supported')
if no_scale:
ap = ap[0]
return ap
Example 79
| Project: mmdetection Author: open-mmlab File: iou_balanced_neg_sampler.py Apache License 2.0 | 4 votes |
|
def _sample_neg(self, assign_result, num_expected, **kwargs):
neg_inds = torch.nonzero(assign_result.gt_inds == 0)
if neg_inds.numel() != 0:
neg_inds = neg_inds.squeeze(1)
if len(neg_inds) <= num_expected:
return neg_inds
else:
max_overlaps = assign_result.max_overlaps.cpu().numpy()
# balance sampling for negative samples
neg_set = set(neg_inds.cpu().numpy())
if self.floor_thr > 0:
floor_set = set(
np.where(
np.logical_and(max_overlaps >= 0,
max_overlaps < self.floor_thr))[0])
iou_sampling_set = set(
np.where(max_overlaps >= self.floor_thr)[0])
elif self.floor_thr == 0:
floor_set = set(np.where(max_overlaps == 0)[0])
iou_sampling_set = set(
np.where(max_overlaps > self.floor_thr)[0])
else:
floor_set = set()
iou_sampling_set = set(
np.where(max_overlaps > self.floor_thr)[0])
# for sampling interval calculation
self.floor_thr = 0
floor_neg_inds = list(floor_set & neg_set)
iou_sampling_neg_inds = list(iou_sampling_set & neg_set)
num_expected_iou_sampling = int(num_expected *
(1 - self.floor_fraction))
if len(iou_sampling_neg_inds) > num_expected_iou_sampling:
if self.num_bins >= 2:
iou_sampled_inds = self.sample_via_interval(
max_overlaps, set(iou_sampling_neg_inds),
num_expected_iou_sampling)
else:
iou_sampled_inds = self.random_choice(
iou_sampling_neg_inds, num_expected_iou_sampling)
else:
iou_sampled_inds = np.array(
iou_sampling_neg_inds, dtype=np.int)
num_expected_floor = num_expected - len(iou_sampled_inds)
if len(floor_neg_inds) > num_expected_floor:
sampled_floor_inds = self.random_choice(
floor_neg_inds, num_expected_floor)
else:
sampled_floor_inds = np.array(floor_neg_inds, dtype=np.int)
sampled_inds = np.concatenate(
(sampled_floor_inds, iou_sampled_inds))
if len(sampled_inds) < num_expected:
num_extra = num_expected - len(sampled_inds)
extra_inds = np.array(list(neg_set - set(sampled_inds)))
if len(extra_inds) > num_extra:
extra_inds = self.random_choice(extra_inds, num_extra)
sampled_inds = np.concatenate((sampled_inds, extra_inds))
sampled_inds = torch.from_numpy(sampled_inds).long().to(
assign_result.gt_inds.device)
return sampled_inds
Example 80
| Project: neural-fingerprinting Author: StephanZheng File: attacks.py BSD 3-Clause "New" or "Revised" License | 4 votes |
|
def basic_iterative_method(sess, model, X, Y, eps, eps_iter, nb_iter=50,
clip_min=None, clip_max=None, batch_size=256):
"""
TODO
:param sess:
:param model: predictions or after-softmax
:param X:
:param Y:
:param eps:
:param eps_iter:
:param nb_iter:
:param clip_min:
:param clip_max:
:param batch_size:
:return:
"""
print("nb_iter",nb_iter)
# Define TF placeholders for the input and output
x = tf.placeholder(tf.float32, shape=(None,)+X.shape[1:])
y = tf.placeholder(tf.float32, shape=(None,)+Y.shape[1:])
# results will hold the adversarial inputs at each iteration of BIM;
# thus it will have shape (nb_iter, n_samples, n_rows, n_cols, n_channels)
results = np.zeros((nb_iter, X.shape[0],) + X.shape[1:])
# Initialize adversarial samples as the original samples, set upper and
# lower bounds
X_adv = X
X_min = X_adv - eps
X_max = X_adv + eps
print('Running BIM iterations...')
# "its" is a dictionary that keeps track of the iteration at which each
# sample becomes misclassified. The default value will be (nb_iter-1), the
# very last iteration.
def f(val):
return lambda: val
its = defaultdict(f(nb_iter-1))
# Out keeps track of which samples have already been misclassified
out = set()
for i in tqdm(range(nb_iter)):
adv_x = fgsm(
x, model(x), eps=eps_iter,
clip_min=clip_min, clip_max=clip_max, y=y
)
X_adv, = batch_eval(
sess, [x, y], [adv_x],
[X_adv, Y], feed={K.learning_phase(): 0},
args={'batch_size': batch_size}
)
X_adv = np.maximum(np.minimum(X_adv, X_max), X_min)
results[i] = X_adv
# check misclassifieds
predictions = model.predict_classes(X_adv, batch_size=512, verbose=0)
misclassifieds = np.where(predictions != Y.argmax(axis=1))[0]
for elt in misclassifieds:
if elt not in out:
its[elt] = i
out.add(elt)
return its, results
