Search is not available for this dataset
repo stringlengths 2 152 ⌀ | file stringlengths 15 239 | code stringlengths 0 58.4M | file_length int64 0 58.4M | avg_line_length float64 0 1.81M | max_line_length int64 0 12.7M | extension_type stringclasses 364
values |
|---|---|---|---|---|---|---|
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/extensions/cpu/radius_neighbors/radius_neighbors.h | #pragma once
#include "../../common/torch_helper.h"
at::Tensor radius_neighbors(
at::Tensor q_points,
at::Tensor s_points,
at::Tensor q_lengths,
at::Tensor s_lengths,
float radius
);
| 195 | 15.333333 | 38 | h |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/extensions/cpu/radius_neighbors/radius_neighbors_cpu.cpp | #include "radius_neighbors_cpu.h"
void radius_neighbors_cpu(
std::vector<PointXYZ>& q_points,
std::vector<PointXYZ>& s_points,
std::vector<long>& q_lengths,
std::vector<long>& s_lengths,
std::vector<long>& neighbor_indices,
float radius
) {
std::size_t i0 = 0;
float r2 = radius * radius;
std::size_t... | 2,276 | 23.75 | 73 | cpp |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/extensions/cpu/radius_neighbors/radius_neighbors_cpu.h | #include <vector>
#include "../../extra/cloud/cloud.h"
#include "../../extra/nanoflann/nanoflann.hpp"
typedef nanoflann::KDTreeSingleIndexAdaptor<
nanoflann::L2_Simple_Adaptor<float, PointCloud>, PointCloud, 3
> my_kd_tree_t;
void radius_neighbors_cpu(
std::vector<PointXYZ>& q_points,
std::vector<PointXYZ>& s_p... | 448 | 25.411765 | 64 | h |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/extensions/extra/cloud/cloud.cpp | // Modified from https://github.com/HuguesTHOMAS/KPConv-PyTorch
#include "cloud.h"
PointXYZ max_point(std::vector<PointXYZ> points) {
PointXYZ maxP(points[0]);
for (auto p : points) {
if (p.x > maxP.x) {
maxP.x = p.x;
}
if (p.y > maxP.y) {
maxP.y = p.y;
}
if (p.z > maxP.z) {
... | 640 | 15.868421 | 63 | cpp |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/extensions/extra/cloud/cloud.h | // Modified from https://github.com/HuguesTHOMAS/KPConv-PyTorch
#pragma once
#include <vector>
#include <unordered_map>
#include <map>
#include <algorithm>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <time.h>
class PointXYZ {
public:
float x, y, z;
PointXYZ() {
x = 0;
... | 3,099 | 21.463768 | 124 | h |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/extensions/extra/nanoflann/nanoflann.hpp | /***********************************************************************
* Software License Agreement (BSD License)
*
* Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved.
* Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved.
* Copyright 2011-2016 Jose Luis Blanco (jos... | 73,133 | 34.779843 | 80 | hpp |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/__init__.py | 0 | 0 | 0 | py | |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/geotransformer/__init__.py | from geotransformer.modules.geotransformer.geotransformer import GeometricStructureEmbedding, GeometricTransformer
from geotransformer.modules.geotransformer.superpoint_matching import SuperPointMatching
from geotransformer.modules.geotransformer.superpoint_target import SuperPointTargetGenerator
from geotransformer.mo... | 477 | 78.666667 | 114 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/geotransformer/geotransformer.py | import numpy as np
import torch
import torch.nn as nn
from geotransformer.modules.ops import pairwise_distance
from geotransformer.modules.transformer import SinusoidalPositionalEmbedding, RPEConditionalTransformer
class GeometricStructureEmbedding(nn.Module):
def __init__(self, hidden_dim, sigma_d, sigma_a, ang... | 5,681 | 35.423077 | 116 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/geotransformer/local_global_registration.py | from typing import Optional
import numpy as np
import torch
import torch.nn as nn
from geotransformer.modules.ops import apply_transform
from geotransformer.modules.registration import WeightedProcrustes
from torch.autograd import Variable
import torch.nn.functional as F
# import sys
# path = r"GeoTransformer-corr-cl... | 20,850 | 49.98044 | 411 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/geotransformer/point_matching.py | import torch
import torch.nn as nn
class PointMatching(nn.Module):
def __init__(
self,
k: int,
mutual: bool = True,
confidence_threshold: float = 0.05,
use_dustbin: bool = False,
use_global_score: bool = False,
remove_duplicate: bool = False,
):
... | 4,906 | 41.301724 | 120 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/geotransformer/superpoint_matching.py | import torch
import torch.nn as nn
from geotransformer.modules.ops import pairwise_distance
class SuperPointMatching(nn.Module):
def __init__(self, num_correspondences, dual_normalization=True):
super(SuperPointMatching, self).__init__()
self.num_correspondences = num_correspondences
self... | 6,514 | 48.732824 | 119 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/geotransformer/superpoint_target.py | import numpy as np
import torch
import torch.nn as nn
class SuperPointTargetGenerator(nn.Module):
def __init__(self, num_targets, overlap_threshold):
super(SuperPointTargetGenerator, self).__init__()
self.num_targets = num_targets
self.overlap_threshold = overlap_threshold
@torch.no_g... | 1,812 | 42.166667 | 97 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/kpconv/__init__.py | from geotransformer.modules.kpconv.kpconv import KPConv
from geotransformer.modules.kpconv.modules import (
ConvBlock,
ResidualBlock,
UnaryBlock,
LastUnaryBlock,
GroupNorm,
KNNInterpolate,
GlobalAvgPool,
MaxPool,
)
from geotransformer.modules.kpconv.functional import nearest_upsample, gl... | 342 | 25.384615 | 94 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/kpconv/functional.py | import torch
from geotransformer.modules.ops import index_select
def nearest_upsample(x, upsample_indices):
"""Pools features from the closest neighbors.
WARNING: this function assumes the neighbors are ordered.
Args:
x: [n1, d] features matrix
upsample_indices: [n2, max_num] Only the f... | 2,918 | 31.076923 | 88 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/kpconv/kernel_points.py | #
#
# 0=================================0
# | Kernel Point Convolutions |
# 0=================================0
#
#
# ----------------------------------------------------------------------------------------------------------------------
#
# Functions handling the disposition of kernel points.
... | 16,726 | 35.682018 | 120 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/kpconv/kpconv.py | import math
import torch
import torch.nn as nn
from geotransformer.modules.ops import index_select
from geotransformer.modules.kpconv.kernel_points import load_kernels
class KPConv(nn.Module):
def __init__(
self,
in_channels,
out_channels,
kernel_size,
radius,
sig... | 5,257 | 38.238806 | 113 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/kpconv/modules.py | import torch
import torch.nn as nn
from geotransformer.modules.kpconv.functional import maxpool, nearest_upsample, global_avgpool, knn_interpolate
from geotransformer.modules.kpconv.kpconv import KPConv
class KNNInterpolate(nn.Module):
def __init__(self, k, eps=1e-8):
super(KNNInterpolate, self).__init__... | 7,155 | 30.663717 | 111 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/layers/__init__.py | from geotransformer.modules.layers.conv_block import ConvBlock
from geotransformer.modules.layers.factory import build_dropout_layer, build_conv_layer, build_norm_layer, build_act_layer
| 186 | 61.333333 | 122 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/layers/conv_block.py | import warnings
import torch
import torch.nn as nn
from geotransformer.modules.layers.factory import build_conv_layer, build_norm_layer, build_act_layer
class ConvBlock(nn.Module):
def __init__(
self,
in_channels,
out_channels,
kernel_size=None,
stride=1,
padding=... | 3,326 | 29.805556 | 114 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/layers/factory.py | from typing import Union, Dict, Optional, Tuple
import torch.nn as nn
NORM_LAYERS = {
'BatchNorm1d': nn.BatchNorm1d,
'BatchNorm2d': nn.BatchNorm2d,
'BatchNorm3d': nn.BatchNorm3d,
'InstanceNorm1d': nn.InstanceNorm1d,
'InstanceNorm2d': nn.InstanceNorm2d,
'InstanceNorm3d': nn.InstanceNorm3d,
... | 2,489 | 27.295455 | 86 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/loss/__init__.py | from geotransformer.modules.loss.circle_loss import CircleLoss, WeightedCircleLoss
| 84 | 27.333333 | 82 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/loss/circle_loss.py | import ipdb
import torch
import torch.nn.functional as F
import torch.nn as nn
def circle_loss(
pos_masks,
neg_masks,
feat_dists,
pos_margin,
neg_margin,
pos_optimal,
neg_optimal,
log_scale,
):
# get anchors that have both positive and negative pairs
row_masks = (torch.gt(pos_m... | 4,897 | 35.827068 | 95 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/ops/__init__.py | from geotransformer.modules.ops.grid_subsample import grid_subsample
from geotransformer.modules.ops.index_select import index_select
from geotransformer.modules.ops.pairwise_distance import pairwise_distance
from geotransformer.modules.ops.pointcloud_partition import (
get_point_to_node_indices,
point_to_node_... | 830 | 36.772727 | 82 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/ops/grid_subsample.py | import importlib
ext_module = importlib.import_module('geotransformer.ext')
def grid_subsample(points, lengths, voxel_size):
"""Grid subsampling in stack mode.
This function is implemented on CPU.
Args:
points (Tensor): stacked points. (N, 3)
lengths (Tensor): number of points in the s... | 651 | 27.347826 | 82 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/ops/index_select.py | import torch
def index_select(data: torch.Tensor, index: torch.LongTensor, dim: int) -> torch.Tensor:
r"""Advanced index select.
Returns a tensor `output` which indexes the `data` tensor along dimension `dim`
using the entries in `index` which is a `LongTensor`.
Different from `torch.index_select`, ... | 1,178 | 35.84375 | 101 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/ops/pairwise_distance.py | import torch
def pairwise_distance(
x: torch.Tensor, y: torch.Tensor, normalized: bool = False, channel_first: bool = False
) -> torch.Tensor:
r"""Pairwise distance of two (batched) point clouds.
Args:
x (Tensor): (*, N, C) or (*, C, N)
y (Tensor): (*, M, C) or (*, C, M)
normalize... | 1,205 | 36.6875 | 110 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/ops/pointcloud_partition.py | import warnings
import torch
from geotransformer.modules.ops.pairwise_distance import pairwise_distance
from geotransformer.modules.ops.index_select import index_select
def get_point_to_node_indices(points: torch.Tensor, nodes: torch.Tensor, return_counts: bool = False):
r"""Compute Point-to-Node partition indi... | 6,727 | 37.227273 | 113 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/ops/radius_search.py | import importlib
ext_module = importlib.import_module('geotransformer.ext')
def radius_search(q_points, s_points, q_lengths, s_lengths, radius, neighbor_limit):
r"""Computes neighbors for a batch of q_points and s_points, apply radius search (in stack mode).
This function is implemented on CPU.
Args:
... | 1,080 | 37.607143 | 101 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/ops/transformation.py | from typing import Optional
import torch
import torch.nn.functional as F
def apply_transform(points: torch.Tensor, transform: torch.Tensor, normals: Optional[torch.Tensor] = None):
r"""Rigid transform to points and normals (optional).
Given a point cloud P(3, N), normals V(3, N) and a transform matrix T in ... | 9,356 | 35.550781 | 118 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/ops/vector_angle.py | import torch
import numpy as np
def rad2deg(rad: torch.Tensor) -> torch.Tensor:
factor = 180.0 / np.pi
deg = rad * factor
return deg
def deg2rad(deg: torch.Tensor) -> torch.Tensor:
factor = np.pi / 180.0
rad = deg * factor
return rad
def vector_angle(x: torch.Tensor, y: torch.Tensor, dim: ... | 992 | 27.371429 | 110 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/registration/__init__.py | from geotransformer.modules.registration.matching import (
extract_correspondences_from_feats,
extract_correspondences_from_scores,
extract_correspondences_from_scores_topk,
extract_correspondences_from_scores_threshold,
dense_correspondences_to_node_correspondences,
get_node_correspondences,
... | 746 | 36.35 | 98 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/registration/matching.py | from typing import Optional
import torch
from geotransformer.modules.ops import index_select, apply_transform, pairwise_distance, get_point_to_node_indices
# Extract correspondences
@torch.no_grad()
def extract_correspondences_from_scores(
score_mat: torch.Tensor,
mutual: bool = False,
bilateral: bool... | 17,458 | 39.414352 | 118 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/registration/metrics.py | import numpy as np
import torch
from geotransformer.modules.ops import apply_transform, pairwise_distance, get_rotation_translation_from_transform
from geotransformer.utils.registration import compute_transform_mse_and_mae
def modified_chamfer_distance(raw_points, ref_points, src_points, gt_transform, transform, red... | 5,779 | 34.460123 | 116 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/registration/procrustes.py | import torch
import torch.nn as nn
import ipdb
def weighted_procrustes(
src_points,
ref_points,
weights=None,
weight_thresh=0.0,
eps=1e-5,
return_transform=False,
):
r"""Compute rigid transformation from `src_points` to `ref_points` using weighted SVD.
Modified from [PointDSC](https:/... | 3,119 | 32.913043 | 97 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/sinkhorn/__init__.py | from geotransformer.modules.sinkhorn.learnable_sinkhorn import LearnableLogOptimalTransport
| 92 | 45.5 | 91 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/sinkhorn/learnable_sinkhorn.py | import torch
import torch.nn as nn
class LearnableLogOptimalTransport(nn.Module):
def __init__(self, num_iterations, inf=1e12):
r"""Sinkhorn Optimal transport with dustbin parameter (SuperGlue style)."""
super(LearnableLogOptimalTransport, self).__init__()
self.num_iterations = num_iterati... | 3,081 | 42.408451 | 107 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/transformer/__init__.py | from geotransformer.modules.transformer.conditional_transformer import (
VanillaConditionalTransformer,
PEConditionalTransformer,
RPEConditionalTransformer,
LRPEConditionalTransformer,
)
from geotransformer.modules.transformer.lrpe_transformer import LRPETransformerLayer
from geotransformer.modules.tran... | 763 | 37.2 | 84 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/transformer/conditional_transformer.py | import torch.nn as nn
from geotransformer.modules.transformer.lrpe_transformer import LRPETransformerLayer
from geotransformer.modules.transformer.pe_transformer import PETransformerLayer
from geotransformer.modules.transformer.rpe_transformer import RPETransformerLayer
from geotransformer.modules.transformer.vanilla_... | 7,220 | 43.574074 | 118 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/transformer/lrpe_transformer.py | r"""Transformer with Learnable Relative Positional Embeddings.
Relative positional embedding is injected in each multi-head attention layer.
The shape of input tensor should be (B, N, C).
Implemented with `nn.Linear` and `nn.LayerNorm` (with affine).
"""
import torch
import torch.nn as nn
import torch.nn.functional ... | 5,871 | 38.409396 | 116 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/transformer/output_layer.py | import torch.nn as nn
from geotransformer.modules.layers import build_act_layer, build_dropout_layer
class AttentionOutput(nn.Module):
def __init__(self, d_model, dropout=None, activation_fn='ReLU'):
super(AttentionOutput, self).__init__()
self.expand = nn.Linear(d_model, d_model * 2)
sel... | 855 | 37.909091 | 78 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/transformer/pe_transformer.py | r"""Vanilla Transformer without positional embeddings.
The shape of input tensor should be (B, N, C). Implemented with `nn.Linear` and `nn.LayerNorm` (with affine).
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
from einops import rearrange
from geotransformer.modules.layers import build_drop... | 4,833 | 35.345865 | 112 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/transformer/positional_embedding.py | import numpy as np
import torch
import torch.nn as nn
from geotransformer.modules.layers import build_dropout_layer
class SinusoidalPositionalEmbedding(nn.Module):
def __init__(self, d_model):
super(SinusoidalPositionalEmbedding, self).__init__()
if d_model % 2 != 0:
raise ValueError(... | 2,484 | 36.651515 | 96 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/transformer/rpe_transformer.py | r"""Transformer with Relative Positional Embeddings.
Relative positional embedding is further projected in each multi-head attention layer.
The shape of input tensor should be (B, N, C). Implemented with `nn.Linear` and `nn.LayerNorm` (with affine).
"""
import torch
import torch.nn as nn
import torch.nn.functional a... | 5,309 | 39.227273 | 117 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/modules/transformer/vanilla_transformer.py | r"""Vanilla Transformer without positional embeddings.
The shape of input tensor should be (B, N, C). Implemented with `nn.Linear` and `nn.LayerNorm` (with affine).
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
from einops import rearrange
from geotransformer.modules.layers import build_drop... | 8,126 | 39.232673 | 119 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/transforms/__init__.py | 0 | 0 | 0 | py | |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/transforms/functional.py | import math
import random
import numpy as np
def normalize_points(points):
r"""Normalize point cloud to a unit sphere at origin."""
points = points - points.mean(axis=0)
points = points / np.max(np.linalg.norm(points, axis=1))
return points
def sample_points(points, num_samples, normals=None):
... | 5,392 | 32.08589 | 117 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/utils/__init__.py | 0 | 0 | 0 | py | |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/utils/average_meter.py | import numpy as np
class AverageMeter:
def __init__(self, last_n=None):
self._records = []
self.last_n = last_n
def update(self, result):
if isinstance(result, (list, tuple)):
self._records += result
else:
self._records.append(result)
def reset(sel... | 756 | 20.027778 | 48 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/utils/common.py | import os
import os.path as osp
import pickle
import sys
sys.path.append('/mnt/lustre/weipengjin/geotransformer')
def ensure_dir(path):
if not osp.exists(path):
os.makedirs(path)
def load_pickle(filename):
with open(filename, 'rb') as f:
data = pickle.load(f)
return data
def dump_pickle... | 2,083 | 27.547945 | 117 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/utils/data.py | from functools import partial
import numpy as np
import torch
from geotransformer.modules.ops import grid_subsample, radius_search
from geotransformer.utils.torch import build_dataloader
# Stack mode utilities
def precompute_data_stack_mode(points, lengths, num_stages, voxel_size, radius, neighbor_limits):
as... | 7,976 | 30.780876 | 120 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/utils/open3d.py | import numpy as np
import open3d as o3d
def get_color(color_name):
if color_name == 'red':
return np.asarray([1.0, 0.0, 0.0])
elif color_name == 'blue':
return np.asarray([0.0, 0.0, 1.0])
elif color_name == 'green':
return np.asarray([0.0, 1.0, 0.0])
elif color_name == 'yellow'... | 6,827 | 32.80198 | 102 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/utils/pointcloud.py | from typing import Tuple, List, Optional, Union, Any
import numpy as np
from scipy.spatial import cKDTree
from scipy.spatial.transform import Rotation
import math
# Basic Utilities
def get_nearest_neighbor(
q_points: np.ndarray,
s_points: np.ndarray,
return_index: bool = False,
):
r"""Compute the ne... | 9,576 | 31.137584 | 110 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/utils/registration.py | import warnings
import numpy as np
from scipy.spatial import cKDTree
from scipy.spatial.transform import Rotation
from geotransformer.utils.pointcloud import (
apply_transform,
get_nearest_neighbor,
get_rotation_translation_from_transform,
)
# Metrics
def compute_relative_rotation_error(gt_rotation: n... | 10,802 | 36.123711 | 113 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/utils/summary_board.py | from typing import Optional, List
from geotransformer.utils.average_meter import AverageMeter
from geotransformer.utils.common import get_print_format
class SummaryBoard:
r"""Summary board."""
def __init__(self, names: Optional[List[str]] = None, last_n: Optional[int] = None, adaptive=False):
r"""In... | 2,990 | 30.819149 | 104 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/utils/timer.py | import time
class Timer:
def __init__(self):
self.total_prepare_time = 0
self.total_process_time = 0
self.count_prepare_time = 0
self.count_process_time = 0
self.last_time = time.time()
def reset(self):
self.total_prepare_time = 0
self.total_process_tim... | 2,338 | 28.2375 | 83 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/utils/torch.py | import math
import random
from typing import Callable
from collections import OrderedDict
import numpy as np
import torch
import torch.distributed as dist
import torch.utils.data
import torch.backends.cudnn as cudnn
# Distributed Data Parallel Utilities
def all_reduce_tensor(tensor, world_size=1):
r"""Average ... | 5,365 | 28.977654 | 120 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/geotransformer/geotransformer/utils/visualization.py | import matplotlib.pyplot as plt
import numpy as np
import open3d as o3d
from sklearn.manifold import TSNE
from tqdm import tqdm
from geotransformer.utils.open3d import (
make_open3d_point_cloud,
make_open3d_axes,
make_open3d_corr_lines,
)
def draw_point_to_node(points, nodes, point_to_node, node_colors=N... | 5,831 | 35.679245 | 112 | py |
LiDAR2LiDAR | LiDAR2LiDAR-master/octree_optimize/include/calibration.hpp | /*
* Copyright (C) 2021 by Autonomous Driving Group, Shanghai AI Laboratory
* Limited. All rights reserved.
* Yan Guohang <yanguohang@pjlab.org.cn>
*/
#pragma once
#include <Eigen/Dense>
#include <array>
#include <map>
#include <memory>
#include <pcl/io/pcd_io.h>
#include <string>
#include <vector>
#include "logg... | 1,609 | 28.814815 | 77 | hpp |
LiDAR2LiDAR | LiDAR2LiDAR-master/octree_optimize/include/logging.hpp | /*
* Copyright (C) 2021 by Autonomous Driving Group, Shanghai AI Laboratory
* Limited. All rights reserved.
* Yan Guohang <yanguohang@pjlab.org.cn>
*/
#ifndef LOGGING_HPP_
#define LOGGING_HPP_
#define OUTPUT
#define __FILENAME__ \
(strrchr(__FILE__, '/') ... | 1,208 | 33.542857 | 80 | hpp |
LiDAR2LiDAR | LiDAR2LiDAR-master/octree_optimize/include/registration_icp.hpp | #pragma once
#include "logging.hpp"
#include <eigen3/Eigen/Core>
#include <eigen3/Eigen/Dense>
#include <eigen3/Eigen/Geometry>
#include <pcl/features/normal_3d.h>
#include <pcl/io/pcd_io.h>
#include <pcl/kdtree/kdtree_flann.h>
#include <pcl/octree/octree_search.h>
#include <pcl/point_cloud.h>
#include <pcl/registrati... | 2,114 | 41.3 | 77 | hpp |
LiDAR2LiDAR | LiDAR2LiDAR-master/octree_optimize/src/calibration.cpp | /*
* Copyright (C) 2021 by Autonomous Driving Group, Shanghai AI Laboratory
* Limited. All rights reserved.
* Yan Guohang <yanguohang@pjlab.org.cn>
*/
#include "calibration.hpp"
#include <pcl/common/transforms.h>
#include <pcl/conversions.h>
#include <pcl/features/normal_3d.h>
#include <pcl/filters/conditional_re... | 11,055 | 39.498168 | 80 | cpp |
LiDAR2LiDAR | LiDAR2LiDAR-master/octree_optimize/src/registration_icp.cpp | #include "registration_icp.hpp"
#include <limits>
#include <pcl/common/transforms.h>
#include <pcl/features/normal_3d.h>
#include <pcl/registration/gicp.h>
#include <pcl/registration/icp_nl.h>
#include <pcl/registration/ndt.h>
ICPRegistrator::ICPRegistrator() {
all_cloud_.reset(new pcl::PointCloud<pcl::PointXYZI>()... | 5,233 | 33.20915 | 77 | cpp |
LiDAR2LiDAR | LiDAR2LiDAR-master/octree_optimize/src/run_lidar2lidar.cpp | #include <chrono> // NOLINT
#include <iostream>
#include <pcl/common/transforms.h>
#include <thread> // NOLINT
#include <time.h>
#include "calibration.hpp"
unsigned char color_map[10][3] = {{255, 255, 255}, // "white"
{255, 0, 0}, // "red"
{0, 25... | 5,193 | 34.575342 | 80 | cpp |
null | LOCA-main/README.md | # Learning Operators with Coupled Attention
Code and data accompanying the manuscript titled "Learning Operators with Coupled Attention", authored by Georgios Kissas*, Jacob H. Seidman*, Leonardo Fe... | 3,176 | 78.425 | 1,338 | md |
null | LOCA-main/Antiderivative/DeepONet/DeepONet_Antiderivative.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from numpy.polynomial import polyutils
from jax.experimental.stax import Dense, Gelu
from jax.experimental import stax
import os
from scipy.integrate import solve_ivp
import timeit
from jax.experimental impo... | 15,651 | 35.484848 | 219 | py |
null | LOCA-main/Antiderivative/FNO/FNOAntiderivative.py | """
@author: Zongyi Li
This file is the Fourier Neural Operator for 1D problem such as the (time-independent) Burgers equation discussed in Section 5.1 in the [paper](https://arxiv.org/pdf/2010.08895.pdf).
"""
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.parameter... | 14,906 | 36.360902 | 226 | py |
null | LOCA-main/Antiderivative/FNO/utilities3.py | import torch
import numpy as np
import scipy.io
import h5py
import torch.nn as nn
import operator
from functools import reduce
from functools import partial
import os
#################################################
#
# Utilities
#
#################################################
def get_freer_gpu():
os.system(... | 9,157 | 27.798742 | 139 | py |
null | LOCA-main/Antiderivative/LOCA/LOCAAntiderivative.py | import jax
import jax.numpy as jnp
from jax.example_libraries.stax import Dense, Gelu
from jax.example_libraries import stax
from jax.example_libraries import optimizers
from jax.example_libraries.ode import odeint
from jax.config import config
import timeit
import numpy as np
from jax.numpy.linalg import norm
from j... | 16,855 | 34.711864 | 204 | py |
null | LOCA-main/Climate_Modeling/DeepONet/DeepONet_Weatherg.py | from jax.core import as_named_shape
from scipy import linalg, interpolate
from sklearn import gaussian_process as gp
from jax.example_libraries.stax import Dense, Gelu, Relu
from jax.example_libraries import stax
import os
import timeit
from jax.example_libraries import optimizers
from absl import app
from jax impor... | 15,510 | 36.831707 | 238 | py |
null | LOCA-main/Climate_Modeling/FNO/Adam.py | import math
import torch
from torch import Tensor
from typing import List, Optional
from torch.optim.optimizer import Optimizer
import os
os.environ['CUDA_VISIBLE_DEVICES']="3"
def adam(params: List[Tensor],
grads: List[Tensor],
exp_avgs: List[Tensor],
exp_avg_sqs: List[Tensor],
m... | 6,612 | 39.078788 | 120 | py |
null | LOCA-main/Climate_Modeling/FNO/utilities3.py | import torch
import numpy as np
import scipy.io
import h5py
import torch.nn as nn
import operator
from functools import reduce
from functools import partial
import os
def get_freer_gpu():
os.system('nvidia-smi -q -d Memory |grep -A4 GPU|grep Free >tmp')
memory_available = [int(x.split()[2]) for x in open('tmp... | 9,154 | 28.063492 | 139 | py |
null | LOCA-main/Climate_Modeling/FNO/weather_FNO.py | """
@author: Zongyi Li
This file is the Fourier Neural Operator for 2D problem such as the Darcy Flow discussed in Section 5.2 in the [paper](https://arxiv.org/pdf/2010.08895.pdf).
"""
import numpy as np
from numpy.linalg import norm
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.para... | 10,016 | 34.147368 | 243 | py |
null | LOCA-main/Climate_Modeling/LOCA/LOCAWeather.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from pathos.pools import ProcessPool
from scipy import linalg, interpolate
from sklearn import gaussian_process as gp
import argparse
from jax.example_libraries.stax import Dense, Gelu, Relu
from jax.example_li... | 18,853 | 35.824219 | 238 | py |
null | LOCA-main/Darcy/DeepONet/DeepONet_Darcy.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from jax.flatten_util import ravel_pytree
from jax.experimental.stax import Dense, Gelu
from jax.experimental import stax
import os
import timeit
from jax.experimental import optimizers
import jax
import jax... | 16,183 | 36.290323 | 238 | py |
null | LOCA-main/Darcy/FNO/FNODarcy.py | """
@author: Zongyi Li
This file is the Fourier Neural Operator for 2D problem such as the Darcy Flow discussed in Section 5.2 in the [paper](https://arxiv.org/pdf/2010.08895.pdf).
"""
import numpy as np
from numpy.linalg import norm
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.para... | 11,702 | 35.34472 | 242 | py |
null | LOCA-main/Darcy/FNO/utilities3.py | import torch
import numpy as np
import scipy.io
import h5py
import torch.nn as nn
import operator
from functools import reduce
from functools import partial
#################################################
#
# Utilities
#
#################################################
import os
def get_freer_gpu():
os.system(... | 9,157 | 27.798742 | 139 | py |
null | LOCA-main/Darcy/LOCA/LOCADarcy.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from pathos.pools import ProcessPool
from scipy import linalg, interpolate
from sklearn import gaussian_process as gp
import argparse
from jax.example_libraries.stax import Dense, Gelu, Relu
from jax.example_li... | 18,193 | 34.604697 | 238 | py |
null | LOCA-main/MMNIST/DeepONet/DeepONet_MNIST.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from pathos.pools import ProcessPool
from scipy import linalg, interpolate
from sklearn import gaussian_process as gp
import argparse
from jax.example_libraries.stax import Dense, Gelu, Relu
from jax.example_li... | 18,384 | 37.462343 | 238 | py |
null | LOCA-main/MMNIST/FNO/Adam.py | import math
import torch
from torch import Tensor
from typing import List, Optional
from torch.optim.optimizer import Optimizer
import os
os.environ['CUDA_VISIBLE_DEVICES']="3"
def adam(params: List[Tensor],
grads: List[Tensor],
exp_avgs: List[Tensor],
exp_avg_sqs: List[Tensor],
m... | 6,612 | 39.078788 | 120 | py |
null | LOCA-main/MMNIST/FNO/FNOMMNIST.py | """
@author: Zongyi Li
This file is the Fourier Neural Operator for 2D problem such as the Darcy Flow discussed in Section 5.2 in the [paper](https://arxiv.org/pdf/2010.08895.pdf).
"""
from jax._src.numpy.lax_numpy import arange
import numpy as np
from numpy.linalg import norm
import torch
import torch.nn as nn
import... | 12,303 | 36.060241 | 262 | py |
null | LOCA-main/MMNIST/FNO/utilities3.py | import torch
import numpy as np
import scipy.io
import h5py
import torch.nn as tnn
import operator
from functools import reduce
from functools import partial
import os
################################################
#
# Utilities
#
#################################################
def get_freer_gpu():
os.system(... | 9,283 | 28.103448 | 139 | py |
null | LOCA-main/MMNIST/LOCA/LOCAMMNIST.py |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from jax.interpreters.xla import Backend
from scipy import linalg, interpolate
from sklearn import gaussian_process as gp
import argparse
from jax.example_libraries.stax import Dense, Gelu
from jax.example_lib... | 22,479 | 36.845118 | 238 | py |
null | LOCA-main/PushForward/DeepONet/DeepONet_Pushforward.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from numpy.polynomial import polyutils
from jax.experimental.stax import Dense, Gelu
from jax.experimental import stax
import os
from scipy.integrate import solve_ivp
import timeit
from jax.experimental impo... | 13,445 | 34.384211 | 204 | py |
null | LOCA-main/PushForward/LOCA/LOCAPushforward.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import jax
import jax.numpy as jnp
from jax.example_libraries.stax import Dense, Gelu
from jax.example_libraries import stax
from jax.example_libraries import optimizers
import os
import timeit
import numpy a... | 15,898 | 33.713974 | 204 | py |
null | LOCA-main/PushForward/LOCA/LOCA_closetoDON.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import jax
import jax.numpy as jnp
from jax.example_libraries.stax import Dense, Gelu
from jax.example_libraries import stax
from jax.example_libraries import optimizers
import os
import timeit
import numpy a... | 15,231 | 33.076063 | 204 | py |
null | LOCA-main/ShallowWaters/DeepONet/DeepOnet_SW.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from pathos.pools import ProcessPool
from scipy import linalg, interpolate
from sklearn import gaussian_process as gp
import argparse
from jax.experimental.stax import Dense, Gelu, Relu
from jax.experimental im... | 19,267 | 40.083156 | 248 | py |
null | LOCA-main/ShallowWaters/FNO/Adam.py | import math
import torch
from torch import Tensor
from typing import List, Optional
from torch.optim.optimizer import Optimizer
import os
os.environ['CUDA_VISIBLE_DEVICES']="3"
def adam(params: List[Tensor],
grads: List[Tensor],
exp_avgs: List[Tensor],
exp_avg_sqs: List[Tensor],
m... | 6,612 | 39.078788 | 120 | py |
null | LOCA-main/ShallowWaters/FNO/FNOSW.py | """
@author: Zongyi Li
This file is the Fourier Neural Operator for 3D problem such as the Navier-Stokes equation discussed in Section 5.3 in the [paper](https://arxiv.org/pdf/2010.08895.pdf),
which takes the 2D spatial + 1D temporal equation directly as a 3D problem
"""
import torch
import numpy as np
import torch.n... | 12,999 | 40.800643 | 276 | py |
null | LOCA-main/ShallowWaters/LOCA/LOCAShallowWater.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from jax.core import as_named_shape
from pathos.pools import ProcessPool
from scipy import linalg, interpolate
from sklearn import gaussian_process as gp
import argparse
from jax.experimental.stax import Dense,... | 19,553 | 37.644269 | 248 | py |
signal_transformer | signal_transformer-master/README.md | # Signal Transformer
Transformer-based model for generating an efficient force/torque signal representations for haptic localization of a legged robot.
## Architecture
## Credits:
- MSc. Jakub Bednarek's https://github.com/jbed94 package - putpy_tf
- https:/... | 366 | 35.7 | 130 | md |
signal_transformer | signal_transformer-master/loss/__init__.py | 0 | 0 | 0 | py | |
signal_transformer | signal_transformer-master/loss/triplet_loss.py | import numpy as np
import tensorflow as tf
def pairwise_distances(vector):
return tf.sqrt(tf.reduce_sum((tf.expand_dims(vector, 1) - tf.expand_dims(vector, 0)) ** 2, 2))
def batch_all_triplet_loss(positions, embeddings, margin=0.1, dist_threshold=0.25):
pairwise_dist_emb = pairwise_distances(embeddings)
p... | 2,254 | 43.215686 | 98 | py |
signal_transformer | signal_transformer-master/model/__init__.py | 0 | 0 | 0 | py | |
signal_transformer | signal_transformer-master/model/encoder.py | import tensorflow as tf
from positional_encoding import PositionalEmbedding
from encoder_layer import EncoderLayer
class Encoder(tf.keras.layers.Layer):
def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size, maximum_position_encoding, rate=0.1):
super(Encoder, self).__init__()
... | 906 | 33.884615 | 115 | py |
signal_transformer | signal_transformer-master/model/encoder_layer.py | import tensorflow as tf
from multi_head_attention import MultiHeadAttention
class EncoderLayer(tf.keras.layers.Layer):
def __init__(self, d_model, num_heads, dff, rate=0.1):
super(EncoderLayer, self).__init__()
self.mha = MultiHeadAttention(d_model, num_heads)
self.ffn = tf.keras.Sequent... | 1,237 | 38.935484 | 89 | py |
signal_transformer | signal_transformer-master/model/multi_head_attention.py | import tensorflow as tf
class MultiHeadAttention(tf.keras.layers.Layer):
def __init__(self, d_model, num_heads):
super(MultiHeadAttention, self).__init__()
self.num_heads = num_heads
self.d_model = d_model
assert d_model % self.num_heads == 0
self.depth = d_model // self.... | 2,522 | 39.047619 | 123 | py |
signal_transformer | signal_transformer-master/model/positional_encoding.py | import numpy as np
import tensorflow as tf
class PositionalEmbedding(tf.keras.Model):
def __init__(self, dict_size, max_sequence_size, embedding_size):
super(PositionalEmbedding, self).__init__(name='positional_embedding')
self.embedding_size = embedding_size
self.embedding = tf.keras.lay... | 1,466 | 33.928571 | 107 | py |
signal_transformer | signal_transformer-master/model/signal_transformer.py | import tensorflow as tf
from encoder import Encoder
class SignalTransformer(tf.keras.Model):
def __init__(self, num_signals, num_layers, d_model, num_heads, dff, latent_vector_size, input_signal_length,
rate=0.1):
super(SignalTransformer, self).__init__(name='signal_transformer')
... | 2,032 | 37.358491 | 115 | py |
signal_transformer | signal_transformer-master/training/__init__.py | 0 | 0 | 0 | py |