Python numpy.float() Examples
The following are 30
code examples of numpy.float().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
numpy
, or try the search function
.
Example #1
Source File: coco.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 6 votes |
def _coco_results_one_category(self, boxes, cat_id): results = [] for im_ind, roi_rec in enumerate(self.roidb): index = roi_rec['index'] dets = boxes[im_ind].astype(np.float) if len(dets) == 0: continue scores = dets[:, -1] xs = dets[:, 0] ys = dets[:, 1] ws = dets[:, 2] - xs + 1 hs = dets[:, 3] - ys + 1 result = [{'image_id': index, 'category_id': cat_id, 'bbox': [xs[k], ys[k], ws[k], hs[k]], 'score': scores[k]} for k in range(dets.shape[0])] results.extend(result) return results
Example #2
Source File: snap.py From mlearn with BSD 3-Clause "New" or "Revised" License | 6 votes |
def evaluate(self, test_structures, ref_energies, ref_forces, ref_stresses): """ Evaluate energies, forces and stresses of structures with trained interatomic potentials. Args: test_structures ([Structure]): List of Pymatgen Structure Objects. ref_energies ([float]): List of DFT-calculated total energies of each structure in structures list. ref_forces ([np.array]): List of DFT-calculated (m, 3) forces of each structure with m atoms in structures list. m can be varied with each single structure case. ref_stresses (list): List of DFT-calculated (6, ) viriral stresses of each structure in structures list. """ predict_pool = pool_from(test_structures, ref_energies, ref_forces, ref_stresses) _, df_orig = convert_docs(predict_pool) _, df_predict = convert_docs(pool_from(test_structures)) outputs = self.model.predict(inputs=test_structures, override=True) df_predict['y_orig'] = df_predict['n'] * outputs return df_orig, df_predict
Example #3
Source File: snap.py From mlearn with BSD 3-Clause "New" or "Revised" License | 6 votes |
def train(self, train_structures, energies, forces, stresses=None, **kwargs): """ Training data with model. Args: train_structures ([Structure]): The list of Pymatgen Structure object. energies ([float]): The list of total energies of each structure in structures list. energies ([float]): List of total energies of each structure in structures list. forces ([np.array]): List of (m, 3) forces array of each structure with m atoms in structures list. m can be varied with each single structure case. stresses (list): List of (6, ) virial stresses of each structure in structures list. """ train_pool = pool_from(train_structures, energies, forces, stresses) _, df = convert_docs(train_pool) ytrain = df['y_orig'] / df['n'] self.model.fit(inputs=train_structures, outputs=ytrain, **kwargs) self.specie = Element(train_structures[0].symbol_set[0])
Example #4
Source File: metrics.py From dogTorch with MIT License | 6 votes |
def get_angle_diff(self, target, result): size = target.size() sequence_length = size[1] all_averages = np.zeros((sequence_length)).astype(np.float) for seq_id in range(sequence_length): average = AverageMeter() for batch_id in range(size[0]): for imu_id in range(size[2]): goal = Quaternion(target[batch_id, seq_id, imu_id]) out = Quaternion(result[batch_id, seq_id, imu_id]) acos = (2 * (np.dot(out.normalised.q, goal.normalised.q)**2) - 1) acos = round(acos, 6) if acos > 1 or acos < -1: pdb.set_trace() radian = math.acos(acos) average.update(radian) all_averages[seq_id] = (average.avg) return all_averages
Example #5
Source File: graph_reader.py From nmp_qc with MIT License | 6 votes |
def create_graph_mutag(file): f = open(file, 'r') lines = f.read().splitlines() f.close() # get the indices of the vertext, adj list and class idx_vertex = lines.index("#v - vertex labels") idx_edge = lines.index("#e - edge labels") idx_clss = lines.index("#c - Class") # node label vl = [int(ivl) for ivl in lines[idx_vertex+1:idx_edge]] edge_list = lines[idx_edge+1:idx_clss] g = nx.parse_edgelist(edge_list, nodetype=int, data=(('weight', float),), delimiter=",") for i in range(1, g.number_of_nodes()+1): g.node[i]['labels'] = np.array(vl[i-1]) c = int(lines[idx_clss+1]) return g, c
Example #6
Source File: metrics.py From DOTA_models with Apache License 2.0 | 6 votes |
def compute_cor_loc(num_gt_imgs_per_class, num_images_correctly_detected_per_class): """Compute CorLoc according to the definition in the following paper. https://www.robots.ox.ac.uk/~vgg/rg/papers/deselaers-eccv10.pdf Returns nans if there are no ground truth images for a class. Args: num_gt_imgs_per_class: 1D array, representing number of images containing at least one object instance of a particular class num_images_correctly_detected_per_class: 1D array, representing number of images that are correctly detected at least one object instance of a particular class Returns: corloc_per_class: A float numpy array represents the corloc score of each class """ return np.where( num_gt_imgs_per_class == 0, np.nan, num_images_correctly_detected_per_class / num_gt_imgs_per_class)
Example #7
Source File: test_imagenet_attacks.py From neural-fingerprinting with BSD 3-Clause "New" or "Revised" License | 6 votes |
def load_images(input_dir, metadata_file_path, batch_shape): """Retrieve numpy arrays of images and labels, read from a directory.""" num_images = batch_shape[0] with open(metadata_file_path) as input_file: reader = csv.reader(input_file) header_row = next(reader) rows = list(reader) row_idx_image_id = header_row.index('ImageId') row_idx_true_label = header_row.index('TrueLabel') images = np.zeros(batch_shape) labels = np.zeros(num_images, dtype=np.int32) for idx in xrange(num_images): row = rows[idx] filepath = os.path.join(input_dir, row[row_idx_image_id] + '.png') with tf.gfile.Open(filepath, 'rb') as f: image = np.array( Image.open(f).convert('RGB')).astype(np.float) / 255.0 images[idx, :, :, :] = image labels[idx] = int(row[row_idx_true_label]) return images, labels
Example #8
Source File: core.py From neuropythy with GNU Affero General Public License v3.0 | 6 votes |
def apply_cmap(zs, cmap, vmin=None, vmax=None, unit=None, logrescale=False): ''' apply_cmap(z, cmap) applies the given cmap to the values in z; if vmin and/or vmax are passed, they are used to scale z. Note that this function can automatically rescale data into log-space if the colormap is a neuropythy log-space colormap such as log_eccentricity. To enable this behaviour use the optional argument logrescale=True. ''' zs = pimms.mag(zs) if unit is None else pimms.mag(zs, unit) zs = np.asarray(zs, dtype='float') if pimms.is_str(cmap): cmap = matplotlib.cm.get_cmap(cmap) if logrescale: if vmin is None: vmin = np.log(np.nanmin(zs)) if vmax is None: vmax = np.log(np.nanmax(zs)) mn = np.exp(vmin) u = zdivide(nanlog(zs + mn) - vmin, vmax - vmin, null=np.nan) else: if vmin is None: vmin = np.nanmin(zs) if vmax is None: vmax = np.nanmax(zs) u = zdivide(zs - vmin, vmax - vmin, null=np.nan) u[np.isnan(u)] = -np.inf return cmap(u)
Example #9
Source File: datasets.py From discomll with Apache License 2.0 | 6 votes |
def iris(replication=2): f = open(path + "iris.txt") data = np.loadtxt(f, delimiter=",", dtype=np.string0) x_train = np.array(data[:, range(0, 4)], dtype=np.float) y_train = data[:, 4] for j in range(replication - 1): x_train = np.vstack([x_train, data[:, range(0, 4)]]) y_train = np.hstack([y_train, data[:, 4]]) x_train = np.array(x_train, dtype=np.float) f = open(path + "iris_test.txt") data = np.loadtxt(f, delimiter=",", dtype=np.string0) x_test = np.array(data[:, range(0, 4)], dtype=np.float) y_test = data[:, 4] for j in range(replication - 1): x_test = np.vstack([x_test, data[:, range(0, 4)]]) y_test = np.hstack([y_test, data[:, 4]]) x_test = np.array(x_test, dtype=np.float) return x_train, y_train, x_test, y_test
Example #10
Source File: datasets.py From discomll with Apache License 2.0 | 6 votes |
def breastcancer_cont(replication=2): f = open(path + "breast_cancer_wisconsin_cont.txt", "r") data = np.loadtxt(f, delimiter=",", dtype=np.string0) x_train = np.array(data[:, range(0, 9)]) y_train = np.array(data[:, 9]) for j in range(replication - 1): x_train = np.vstack([x_train, data[:, range(0, 9)]]) y_train = np.hstack([y_train, data[:, 9]]) x_train = np.array(x_train, dtype=np.float) f = open(path + "breast_cancer_wisconsin_cont_test.txt") data = np.loadtxt(f, delimiter=",", dtype=np.string0) x_test = np.array(data[:, range(0, 9)]) y_test = np.array(data[:, 9]) for j in range(replication - 1): x_test = np.vstack([x_test, data[:, range(0, 9)]]) y_test = np.hstack([y_test, data[:, 9]]) x_test = np.array(x_test, dtype=np.float) return x_train, y_train, x_test, y_test
Example #11
Source File: _op_translations.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 6 votes |
def convert_clip(node, **kwargs): """Map MXNet's Clip operator attributes to onnx's Clip operator and return the created node. """ onnx = import_onnx_modules() name = node["name"] input_idx = kwargs["index_lookup"][node["inputs"][0][0]] proc_nodes = kwargs["proc_nodes"] input_node = proc_nodes[input_idx].name attrs = node["attrs"] a_min = np.float(attrs.get('a_min', -np.inf)) a_max = np.float(attrs.get('a_max', np.inf)) clip_node = onnx.helper.make_node( "Clip", [input_node], [name], name=name, min=a_min, max=a_max ) return [clip_node]
Example #12
Source File: coco.py From cascade-rcnn_Pytorch with MIT License | 6 votes |
def _coco_results_one_category(self, boxes, cat_id): results = [] for im_ind, index in enumerate(self.image_index): dets = boxes[im_ind].astype(np.float) if dets == []: continue scores = dets[:, -1] xs = dets[:, 0] ys = dets[:, 1] ws = dets[:, 2] - xs + 1 hs = dets[:, 3] - ys + 1 results.extend( [{'image_id': index, 'category_id': cat_id, 'bbox': [xs[k], ys[k], ws[k], hs[k]], 'score': scores[k]} for k in range(dets.shape[0])]) return results
Example #13
Source File: coco.py From Collaborative-Learning-for-Weakly-Supervised-Object-Detection with MIT License | 6 votes |
def _coco_results_one_category(self, boxes, cat_id): results = [] for im_ind, index in enumerate(self.image_index): dets = boxes[im_ind].astype(np.float) if dets == []: continue scores = dets[:, -1] xs = dets[:, 0] ys = dets[:, 1] ws = dets[:, 2] - xs + 1 hs = dets[:, 3] - ys + 1 results.extend( [{'image_id': index, 'category_id': cat_id, 'bbox': [xs[k], ys[k], ws[k], hs[k]], 'score': scores[k]} for k in range(dets.shape[0])]) return results
Example #14
Source File: test_train.py From Collaborative-Learning-for-Weakly-Supervised-Object-Detection with MIT License | 6 votes |
def _project_im_rois(im_rois, scales): """Project image RoIs into the image pyramid built by _get_image_blob. Arguments: im_rois (ndarray): R x 4 matrix of RoIs in original image coordinates scales (list): scale factors as returned by _get_image_blob Returns: rois (ndarray): R x 4 matrix of projected RoI coordinates levels (list): image pyramid levels used by each projected RoI """ im_rois = im_rois.astype(np.float, copy=False) if len(scales) > 1: widths = im_rois[:, 2] - im_rois[:, 0] + 1 heights = im_rois[:, 3] - im_rois[:, 1] + 1 areas = widths * heights scaled_areas = areas[:, np.newaxis] * (scales[np.newaxis, :] ** 2) diff_areas = np.abs(scaled_areas - 224 * 224) levels = diff_areas.argmin(axis=1)[:, np.newaxis] else: levels = np.zeros((im_rois.shape[0], 1), dtype=np.int) rois = im_rois * scales[levels] return rois, levels
Example #15
Source File: envs.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 6 votes |
def preprocess(self, img): """ Preprocess a 210x160x3 uint8 frame into a 6400 (80x80) (1 x input_size) float vector. """ # Crop, down-sample, erase background and set foreground to 1. # See https://gist.github.com/karpathy/a4166c7fe253700972fcbc77e4ea32c5 img = img[35:195] img = img[::2, ::2, 0] img[img == 144] = 0 img[img == 109] = 0 img[img != 0] = 1 curr = np.expand_dims(img.astype(np.float).ravel(), axis=0) # Subtract the last preprocessed image. diff = (curr - self.prev if self.prev is not None else np.zeros((1, curr.shape[1]))) self.prev = curr return diff
Example #16
Source File: _op_translations.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 6 votes |
def convert_dropout(node, **kwargs): """Map MXNet's Dropout operator attributes to onnx's Dropout operator and return the created node. """ onnx = import_onnx_modules() name = node["name"] input_id = kwargs["index_lookup"][node["inputs"][0][0]] input_name = kwargs["proc_nodes"][input_id].name attrs = node["attrs"] probability = float(attrs["p"]) dropout_node = onnx.helper.make_node( "Dropout", [input_name], [name], ratio=probability, name=name ) return [dropout_node]
Example #17
Source File: test.py From Collaborative-Learning-for-Weakly-Supervised-Object-Detection with MIT License | 6 votes |
def _project_im_rois(im_rois, scales): """Project image RoIs into the image pyramid built by _get_image_blob. Arguments: im_rois (ndarray): R x 4 matrix of RoIs in original image coordinates scales (list): scale factors as returned by _get_image_blob Returns: rois (ndarray): R x 4 matrix of projected RoI coordinates levels (list): image pyramid levels used by each projected RoI """ im_rois = im_rois.astype(np.float, copy=False) if len(scales) > 1: widths = im_rois[:, 2] - im_rois[:, 0] + 1 heights = im_rois[:, 3] - im_rois[:, 1] + 1 areas = widths * heights scaled_areas = areas[:, np.newaxis] * (scales[np.newaxis, :] ** 2) diff_areas = np.abs(scaled_areas - 224 * 224) levels = diff_areas.argmin(axis=1)[:, np.newaxis] else: levels = np.zeros((im_rois.shape[0], 1), dtype=np.int) rois = im_rois * scales[levels] return rois, levels
Example #18
Source File: bbox.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 6 votes |
def bbox_overlaps(boxes, query_boxes): """ determine overlaps between boxes and query_boxes :param boxes: n * 4 bounding boxes :param query_boxes: k * 4 bounding boxes :return: overlaps: n * k overlaps """ n_ = boxes.shape[0] k_ = query_boxes.shape[0] overlaps = np.zeros((n_, k_), dtype=np.float) for k in range(k_): query_box_area = (query_boxes[k, 2] - query_boxes[k, 0] + 1) * (query_boxes[k, 3] - query_boxes[k, 1] + 1) for n in range(n_): iw = min(boxes[n, 2], query_boxes[k, 2]) - max(boxes[n, 0], query_boxes[k, 0]) + 1 if iw > 0: ih = min(boxes[n, 3], query_boxes[k, 3]) - max(boxes[n, 1], query_boxes[k, 1]) + 1 if ih > 0: box_area = (boxes[n, 2] - boxes[n, 0] + 1) * (boxes[n, 3] - boxes[n, 1] + 1) all_area = float(box_area + query_box_area - iw * ih) overlaps[n, k] = iw * ih / all_area return overlaps
Example #19
Source File: ops_test.py From DOTA_models with Apache License 2.0 | 5 votes |
def test_filter_with_missing_fields(self): input_boxes = tf.placeholder(tf.float32, shape=(None, 4)) input_classes = tf.placeholder(tf.int32, shape=(None,)) input_tensors = { fields.InputDataFields.groundtruth_boxes: input_boxes, fields.InputDataFields.groundtruth_classes: input_classes } valid_indices = tf.placeholder(tf.int32, shape=(None,)) feed_dict = { input_boxes: np.array([[0.2, 0.4, 0.1, 0.8], [0.2, 0.4, 1.0, 0.8]], dtype=np.float), input_classes: np.array([1, 2], dtype=np.int32), valid_indices: np.array([0], dtype=np.int32) } expected_tensors = { fields.InputDataFields.groundtruth_boxes: [[0.2, 0.4, 0.1, 0.8]], fields.InputDataFields.groundtruth_classes: [1] } output_tensors = ops.retain_groundtruth(input_tensors, valid_indices) with self.test_session() as sess: output_tensors = sess.run(output_tensors, feed_dict=feed_dict) for key in [fields.InputDataFields.groundtruth_boxes]: self.assertAllClose(expected_tensors[key], output_tensors[key]) for key in [fields.InputDataFields.groundtruth_classes]: self.assertAllEqual(expected_tensors[key], output_tensors[key])
Example #20
Source File: kaggle_mnist_input.py From tensorflow-alexnet with MIT License | 5 votes |
def load_mnist_train(validation_size=2000, batch_size=128): download_train() data = pd.read_csv(FLAGS.train_path) images = data.iloc[:, 1:].values images = images.astype(np.float) images = np.multiply(images, 1.0 / 255.0) image_size = images.shape[1] image_width = image_height = np.ceil(np.sqrt(image_size)).astype(np.uint8) images = images.reshape(-1, image_width, image_height, 1) labels_flat = data[[0]].values.ravel() labels_count = np.unique(labels_flat).shape[0] labels = dense_to_one_hot(labels_flat, labels_count) labels = labels.astype(np.uint8) validation_images = images[:validation_size] validation_labels = labels[:validation_size] train_images = images[validation_size:] train_labels = labels[validation_size:] train_range = zip(range(0, len(train_images), batch_size), range(batch_size, len(train_images), batch_size)) if len(train_images) % batch_size > 0: train_range.append((train_range[-1][1], len(train_images))) validation_indices = np.arange(len(validation_images)) return train_images, train_labels, train_range, validation_images, validation_labels, validation_indices
Example #21
Source File: vne.py From PHATE with GNU General Public License v2.0 | 5 votes |
def compute_von_neumann_entropy(data, t_max=100): """ Determines the Von Neumann entropy of data at varying matrix powers. The user should select a value of t around the "knee" of the entropy curve. Parameters ---------- t_max : int, default: 100 Maximum value of t to test Returns ------- entropy : array, shape=[t_max] The entropy of the diffusion affinities for each value of t Examples -------- >>> import numpy as np >>> import phate >>> X = np.eye(10) >>> X[0,0] = 5 >>> X[3,2] = 4 >>> h = phate.vne.compute_von_neumann_entropy(X) >>> phate.vne.find_knee_point(h) 23 """ _, eigenvalues, _ = svd(data) entropy = [] eigenvalues_t = np.copy(eigenvalues) for _ in range(t_max): prob = eigenvalues_t / np.sum(eigenvalues_t) prob = prob + np.finfo(float).eps entropy.append(-np.sum(prob * np.log(prob))) eigenvalues_t = eigenvalues_t * eigenvalues entropy = np.array(entropy) return np.array(entropy)
Example #22
Source File: imdb.py From cascade-rcnn_Pytorch with 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 #23
Source File: kaggle_mnist_input.py From tensorflow-alexnet with MIT License | 5 votes |
def download(path, url): if not os.path.exists(path): if not os.path.isdir(os.path.basename(path)): os.makedirs(os.path.basename(path)) def _progress(count, block_size, total_size): sys.stdout.write( '\r>> Downloading %s %.1f%%' % (path, float(count * block_size) / float(total_size) * 100.0)) sys.stdout.flush() file_path, _ = urllib.request.urlretrieve(url, path, _progress) print() return os.stat(file_path)
Example #24
Source File: ops_test.py From DOTA_models with Apache License 2.0 | 5 votes |
def test_invalid_target_norm_values(self): inputs = tf.random_uniform([5, 10, 12, 3]) target_norm_value = [4.0, 4.0] dim = 3 with self.assertRaisesRegexp( ValueError, 'target_norm_value must be a float or a list of floats'): ops.normalize_to_target(inputs, target_norm_value, dim)
Example #25
Source File: metrics.py From dogTorch with MIT License | 5 votes |
def calc_stat(self, target): ones = torch.sum((target == 1).view(target.size(0), -1).float(), 1) zeros = torch.sum((target == 0).view(target.size(0), -1).float(), 1) return (ones / (ones + zeros)).mean()
Example #26
Source File: ops_test.py From DOTA_models with Apache License 2.0 | 5 votes |
def test_filter_with_empty_groundtruth_boxes(self): input_boxes = tf.placeholder(tf.float32, shape=(None, 4)) input_classes = tf.placeholder(tf.int32, shape=(None,)) input_is_crowd = tf.placeholder(tf.bool, shape=(None,)) input_area = tf.placeholder(tf.float32, shape=(None,)) input_difficult = tf.placeholder(tf.float32, shape=(None,)) valid_indices = tf.placeholder(tf.int32, shape=(None,)) input_tensors = { fields.InputDataFields.groundtruth_boxes: input_boxes, fields.InputDataFields.groundtruth_classes: input_classes, fields.InputDataFields.groundtruth_is_crowd: input_is_crowd, fields.InputDataFields.groundtruth_area: input_area, fields.InputDataFields.groundtruth_difficult: input_difficult } output_tensors = ops.retain_groundtruth(input_tensors, valid_indices) feed_dict = { input_boxes: np.array([], dtype=np.float).reshape(0, 4), input_classes: np.array([], dtype=np.int32), input_is_crowd: np.array([], dtype=np.bool), input_area: np.array([], dtype=np.float32), input_difficult: np.array([], dtype=np.float32), valid_indices: np.array([], dtype=np.int32) } with self.test_session() as sess: output_tensors = sess.run(output_tensors, feed_dict=feed_dict) for key in input_tensors: if key == fields.InputDataFields.groundtruth_boxes: self.assertAllEqual([0, 4], output_tensors[key].shape) else: self.assertAllEqual([0], output_tensors[key].shape)
Example #27
Source File: ops_test.py From DOTA_models with Apache License 2.0 | 5 votes |
def test_meshgrid_multidimensional(self): np.random.seed(18) x = np.random.rand(4, 1, 2).astype(np.float32) y = np.random.rand(2, 3).astype(np.float32) xgrid, ygrid = ops.meshgrid(x, y) grid_shape = list(y.shape) + list(x.shape) self.assertEqual(xgrid.get_shape().as_list(), grid_shape) self.assertEqual(ygrid.get_shape().as_list(), grid_shape) with self.test_session() as sess: xgrid_output, ygrid_output = sess.run([xgrid, ygrid]) # Check the shape of the output grids self.assertEqual(xgrid_output.shape, tuple(grid_shape)) self.assertEqual(ygrid_output.shape, tuple(grid_shape)) # Check a few elements test_elements = [((3, 0, 0), (1, 2)), ((2, 0, 1), (0, 0)), ((0, 0, 0), (1, 1))] for xind, yind in test_elements: # These are float equality tests, but the meshgrid op should not introduce # rounding. self.assertEqual(xgrid_output[yind + xind], x[xind]) self.assertEqual(ygrid_output[yind + xind], y[yind])
Example #28
Source File: _op_translations.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 5 votes |
def convert_pad(node, **kwargs): """Map MXNet's pad operator attributes to onnx's Pad operator and return the created node. """ onnx = import_onnx_modules() name = node["name"] attrs = node["attrs"] proc_nodes = kwargs["proc_nodes"] inputs = node["inputs"] input_node_idx = kwargs["index_lookup"][inputs[0][0]] input_node = proc_nodes[input_node_idx].name mxnet_pad_width = convert_string_to_list(attrs.get("pad_width")) onnx_pad_width = transform_padding(mxnet_pad_width) pad_mode = attrs.get("mode") if pad_mode == "constant": pad_value = float(attrs.get("constant_value")) \ if "constant_value" in attrs else 0.0 node = onnx.helper.make_node( 'Pad', inputs=[input_node], outputs=[name], mode='constant', value=pad_value, pads=onnx_pad_width, name=name ) else: node = onnx.helper.make_node( 'Pad', inputs=[input_node], outputs=[name], mode=pad_mode, pads=onnx_pad_width, name=name ) return [node]
Example #29
Source File: _op_translations.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 5 votes |
def convert_lrn(node, **kwargs): """Map MXNet's LRN operator attributes to onnx's LRN operator and return the created node. """ onnx = import_onnx_modules() name = node["name"] input_idx = kwargs["index_lookup"][node["inputs"][0][0]] proc_nodes = kwargs["proc_nodes"] input_node = proc_nodes[input_idx].name attrs = node["attrs"] alpha = float(attrs["alpha"]) if "alpha" in attrs else 0.0001 beta = float(attrs["beta"]) if "beta" in attrs else 0.75 bias = float(attrs["knorm"]) if "knorm" in attrs else 1.0 size = int(attrs["nsize"]) lrn_node = onnx.helper.make_node( "LRN", inputs=[input_node], outputs=[name], name=name, alpha=alpha, beta=beta, bias=bias, size=size ) return [lrn_node]
Example #30
Source File: _op_translations.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 5 votes |
def convert_cast(node, **kwargs): """Map MXNet's Cast operator attributes to onnx's Cast operator and return the created node. """ onnx = import_onnx_modules() name = node["name"] proc_nodes = kwargs["proc_nodes"] inputs = node["inputs"] dtype = node["attrs"]["dtype"] # dtype can be mapped only with types from TensorProto # float32 is mapped to float and float64 to double in onnx # following tensorproto mapping https://github.com/onnx/onnx/blob/master/onnx/mapping.py if dtype == 'float32': dtype = 'float' elif dtype == 'float64': dtype = 'double' input_node_id = kwargs["index_lookup"][inputs[0][0]] input_node = proc_nodes[input_node_id].name node = onnx.helper.make_node( "Cast", [input_node], [name], to=getattr(onnx.TensorProto, dtype.upper()), name=name, ) return [node]