]]>2025-01-12T00:00:00.000Z2024 - FracGMhttps://stephlin.github.io/projects/2024-FracGM.html2024-11-26T15:39:58.000ZBang-Shien Chen,
Yu-Kai Lin,
Jian-Yu Chen,
Chih-Wei Huang,
Jann-Long Chern,
Ching-Cherng Sun,
FracGM: A Fast Fractional Programming Technique for Geman-McClure Robust Estimator.
IEEE Robotics and Automation Letters (RA-L), vol. 9, no. 12, pp. 11666 -- 11673, Dec. 2024.]]>Bang-Shien Chen,
Yu-Kai Lin,
Jian-Yu Chen,
Chih-Wei Huang,
Jann-Long Chern,
Ching-Cherng Sun,
FracGM: A Fast Fractional Programming Technique for Geman-McClure Robust Estimator.
IEEE Robotics and Automation Letters (RA-L), vol. 9, no. 12, pp. 11666 -- 11673, Dec. 2024.
Robust estimation is essential in computer vision, robotics, and navigation,
aiming to minimize the impact of outlier measurements for improved accuracy. We
present a fast algorithm for Geman-McClure robust estimation, FracGM, leveraging
fractional programming techniques. This solver reformulates the original
non-convex fractional problem to a convex dual problem and a linear equation
system, iteratively solving them in an alternating optimization pattern.
Compared to graduated non-convexity approaches, this strategy exhibits a faster
convergence rate and better outlier rejection capability. In addition, the
global optimality of the proposed solver can be guaranteed under given
conditions. We demonstrate the proposed FracGM solver with Wahba's rotation
problem and 3-D point-cloud registration along with relaxation pre-processing
and projection post-processing. Compared to state-of-the-art algorithms, when
the outlier rates increase from 20% to 80%, FracGM shows 53% and 88% lower
rotation and translation increases. In real-world scenarios, FracGM achieves
better results in 13 out of 18 outcomes, while having a 19.43% improvement in
the computation time.
For more details, please refer to the following links:
]]>2024-10-22T00:00:00.000ZAbout Mehttps://stephlin.github.io/about-me.html2025-01-18T09:03:40.000Z
]]>2024-09-15T00:00:00.000Z2022 - KCPhttps://stephlin.github.io/projects/2022-KCP.html2024-09-15T15:10:50.000ZYu-Kai Lin,
Wen-Chieh Lin,
Chieh-Chih Wang,
K-Closest Points and Maximum Clique Pruning for Efficient and Effective 3-D Laser Scan Matching.
IEEE Robotics and Automation Letters (RA-L), vol.7, no. 2, pp. 1471 -- 1477, Apr. 2022.
]]>Yu-Kai Lin,
Wen-Chieh Lin,
Chieh-Chih Wang,
K-Closest Points and Maximum Clique Pruning for Efficient and Effective 3-D Laser Scan Matching.
IEEE Robotics and Automation Letters (RA-L), vol.7, no. 2, pp. 1471 -- 1477, Apr. 2022.
We propose K-Closest Points (KCP), an efficient and effective laser scan
matching approach inspired by LOAM and TEASER++. The efficiency of KCP comes
from a feature point extraction approach utilizing the multi-scale curvature and
a heuristic matching method based on the k-closest points. The effectiveness of
KCP comes from the integration of the feature point matching approach and the
maximum clique pruning. We compare KCP against well-known scan matching
approaches on synthetic and real-world LiDAR data (nuScenes dataset). In the
synthetic data experiment, KCP-TEASER reaches a state-of-the-art
root-mean-square transformation error (0.006m, 0.014deg) with average
computational time 49ms. In the real-world data experiment, KCP-TEASER achieves
an average error of (0.018m, 0.101deg) with average computational time 77ms. This
shows its efficiency and effectiveness in real-world scenarios. Through
theoretic derivation and empirical experiments, we also reveal the outlier
correspondence penetration issue of the maximum clique pruning that it may still
contain outlier correspondences.
For more details, please refer to the following links:
]]>2022-03-31T00:00:00.000Z2023 - LIO-SEGMOThttps://stephlin.github.io/projects/2023-LIO-SEGMOT.html2024-09-15T15:10:50.000ZYu-Kai Lin,
Wen-Chieh Lin,
Chieh-Chih Wang,
Asynchronous State Estimation of Simultaneous Ego-motion Estimation and Multiple Object Tracking for LiDAR-Inertial Odometry.
2023 International Conference on Robotics and Automation (ICRA), pp. 10616--10622, May 2023.
]]>Yu-Kai Lin,
Wen-Chieh Lin,
Chieh-Chih Wang,
Asynchronous State Estimation of Simultaneous Ego-motion Estimation and Multiple Object Tracking for LiDAR-Inertial Odometry.
2023 International Conference on Robotics and Automation (ICRA), pp. 10616--10622, May 2023.
We propose LiDAR-Inertial Odometry via Simultaneous EGo-motion estimation and
Multiple Object Tracking (LIO-SEGMOT), an optimization-based odometry approach
targeted for dynamic environments. LIO-SEGMOT is formulated as a state
estimation approach with asynchronous state update of the odometry and the
object tracking. That is, LIO-SEGMOT can provide continuous object tracking
results while preserving the keyframe selection mechanism in the odometry
system. Meanwhile, a hierarchical criterion is designed to properly couple
odometry and object tracking, preventing system instability due to poor
detections. We compare LIO-SEGMOT against the baseline model LIO-SAM, a
state-of-the-art LIO approach, under dynamic environments of the KITTI raw
dataset and the self-collected Hsinchu dataset. The former experiment shows that
LIO-SEGMOT obtains an average improvement 1.61% and 5.41% of odometry accuracy
in terms of absolute translational and rotational trajectory errors. The latter
experiment also indicates that LIO-SEGMOT obtains an average improvement 6.97%
and 4.21% of odometry accuracy.
For more information, please refer to the following links:
]]>2023-03-31T00:00:00.000Z2024 - AI-Enhanced GNSS/INShttps://stephlin.github.io/projects/2024-MTK-GNSS.html2024-09-15T15:20:08.000ZAn-Lin Tao,
Yu-Kai Lin,
Hau-Hsiang Chan,
Li-Min Lin,
Pei-Shan Kao,
AI-Enhanced Smartphone-Based GNSS/INS Integration: Improved Vehicular/Pedestrian Navigation in Challenging Scenarios Using Machine Learning.
ION GNSS+ 2024 (Session C4: Positioning Technologies and Machine Learning), Sep. 2024.
]]>An-Lin Tao,
Yu-Kai Lin,
Hau-Hsiang Chan,
Li-Min Lin,
Pei-Shan Kao,
AI-Enhanced Smartphone-Based GNSS/INS Integration: Improved Vehicular/Pedestrian Navigation in Challenging Scenarios Using Machine Learning.
ION GNSS+ 2024 (Session C4: Positioning Technologies and Machine Learning), Sep. 2024.
The utilization of mobile phone positioning for navigation has become a
fundamental aspect of modern life. However, enabling mobile phones to provide
positioning in urban areas presents greater challenges due to the need to
minimize hardware size and costs, in contrast to traditional GNSS receivers. The
effective integration of inertial navigation units (IMU) and GNSS has emerged as
a critical issue.
MediaTek, as a provider of a wide range of mobile products, has collected data
on challenging scenarios worldwide through customer feedback. Leveraging a
substantial volume of data, the appropriate integration of artificial
intelligence (AI) and the utilization of machine learning (ML) technology have
the potential to enhance positioning accuracy across diverse scenarios. Several
years ago, MediaTek integrated various machine learning techniques to fuse GNSS
with multiple IMU sensors. However, integrating GNSS with IMU across different
usage scenarios presents four primary challenges:
Requiring sensor calibration.
Determining the relationship between the user's mobile phone and the carrier (such as a vehicle or pedestrian, etc.).
Classifying the accuracy of GNSS observations in challenging environments.
Adjusting the parameters of GNSS and IMU through EKF in different scenarios.
This paper will provide a method to use machine learning in real-time to solve
the above-mentioned problems with limited platform computing capacity. The
specific contributions are delineated as follows:
Static identification using machine learning: Overcoming disparities among
various usage scenarios and diverse sensors to furnish users with consistent
positioning results while simultaneously conducting sensor calibration.
State identification using machine learning: Identifying whether the user is
driving, walking, or running, and integrating distinct algorithms to optimize
sensor integration with GNSS based on varying usage states.
Observation filtering using machine learning: Training on a comprehensive
dataset to predict accurate GNSS observation quality, selecting high-quality
observations, excluding abnormal ones, and furnishing accuracy indicators
integrated with sensors.
Adjusting key parameters of the integrated system using machine learning:
Automatically optimizing the numerous parameters of sensors and GNSS within a
tightly-coupled Kalman filter, rapidly achieving equilibrium upon the
introduction of new sensors or GNSS signals.
Ultimately, this paper will present the performance disparities before and after
applying the proposed method:
The average accuracy of static detection can be increased by 23%.
For high-vibration scenes, the improvement can reach up to 87%;
The accuracy of state recognition can achieve 98%;
The accuracy of GNSS observation selection can be boosted by 30%.
Finally, the user positioning accuracy is enhanced by 10%.
By leveraging the techniques expounded in this paper, MediaTek's products can
furnish mobile phone users with more precise navigation services across various
environments.
For more information, please refer to the following link:
]]>2024-09-15T00:00:00.000ZChecking Sum of Squares (SOS) Polynomials with CVXPYhttps://stephlin.github.io/posts/Optimization/Sum-of-squares.html2024-09-15T15:10:50.000ZThis post aims at introducing a programming way to check if a polynomial is sum of squares.
]]>This post aims at introducing a programming way to check if a polynomial is sum of squares.
Background Knowledge of Sum of Squares Polynomials
Formally we say a polynomial is sum of squares if
exist several polynomials such that
It is
well-known
that a polynomial of maximum total degree is sum of squares if and only
if there is a positive semidefinite matrix such that
where is a vector of monomial basis with maximum total degree .
This property allows us to check if an unknwon polynomial is sum of squares, by
performing a semidefinite programming.
Semidefinite Programming by Python
From here we use SymPy for algebraic
calculation and CVXPY for semidefinite programming.
This program (in primal form) does not need any energy function since we only
check the feasibility under constraints .
For example, if our testing funtion is
then firstly we construct the polynomial
from collections import defaultdictimport sympy as smpfrom sympy.abc import x, y, zgens = [x, y, z]f = 2 _ x**4 - 5 / 2 _ x**3 * y + x**2 _ y _ z - 2 _ x _ z**3 + 5 * y**4 + z**4f = f.as_poly(gens)# rewrite polynomial as defaultdict formatf_poly = defaultdict(int)for monom, coeff in zip(f.monoms(), f.coeffs()): f_poly[monom] += coeff
and corresponding (expected) sum of squares representation
Now we would like to subtract the target polynomial by polynomial constructed by
a positive semidefinite matrix, and forced the result function to be zero.
constraint_poly = sos_poly.copy()for monom, coeff in f_poly.items(): constraint_poly[monom] -= coeffconstraints = []for coeff in constraint_poly.values(): if not isinstance(coeff, int) and not isinstance(coeff, float): constraints.append(coeff == 0)
Finally we construct the corresponding problem and solve it.
problem = cp.Problem(cp.Minimize(0), constraints=constraints)problem.solve(solver='MOSEK', verbose=True)
Now we consider another function . Obviously this is not
a sum of squares polynomial. In this case we follow the above procedure and we
can get the following result
From this post we are able to check if a function is a sum of squares polynomial
by performing a corresponding semidefinite programming. It means that we do not
need to find such polynomials manually but just simply run some optimization
algorithm (e.g. interior-point method). However we note that the matrix space
complexity w.r.t. total degree is exponential.
]]>2020-10-03T00:00:00.000ZContext Management in Pythonhttps://stephlin.github.io/posts/Python/Context-management.html2024-09-15T15:10:50.000Z在執行程式的時候通常會需要存取資源，一般來說資源的來源可能是檔案、遠端連線、或是某種 Socket。當程式在調用資源的時候基本上包含兩個動作：
請求資源使用權 (以檔案來說就是讀或寫之類的)、以及
釋放資源使用權。
本篇我們將整理在 Python 中面對資源存取問題時，透過 with 的常見作法、其物件意涵、以及內建套件 contextlib 的一些使用時機。
本篇我們將整理在 Python 中面對資源存取問題時，透過 with 的常見作法、其物件意涵、以及內建套件 contextlib 的一些使用時機。
單一檔案存取
假設我們有一個檔案 input.txt：
Hello world! I am a file.This is a new line.
透過 Python 我們可以透過以下程式碼實現讀檔並輸出到終端機上：
# access `input.txt` file with reading permissionobj = open('input.txt', 'r')# read content and print to stdoutprint(obj.read())# release file resourceobj.close()
而透過 with 關鍵字可以幫助程式碼在這個過程中更簡潔：
with open('input.txt', 'r') as f: print(f.read())
到目前為止是大家在學習 Python 的時候幾乎會碰觸到的課題，接下來我們將討論 with 在 Python 當中的物件意涵。
With 關鍵字在 Python 中的物件意涵
我們同樣盯著上面的範例程式碼看，實際上他相當於以下語法結構：
import sys# with open('input.txt', 'r') as f:obj = open('input.txt', 'r')f = obj.__enter__()exc = True # a flag to determine if process trap into the except blocktry: # inside the with block print(f.read())except: # go to here if there is an exception happened inside the block # set flag as False to avoid double-free exc = False # collect exception information exc_type, exc_val, exc_tb = sys.exit_info() if not obj.__exit__(exc_type, exc_val, exc_tb): raisefinally: if exc: # in this way there is no exception exc_type = exc_val = exc_tb = None obj.__exit__(exc_type, exc_val, exc_tb)
在這段程式碼中，我們會發現：
在進入 with 區塊前，Python 會初始化 obj 物件並觸發 __enter__ 方法以存取資源，並且將其回傳值賦予到 f；
而當程序離開 with 區塊時，Python 會觸發 obj 物件的 __exit__ 方法以釋放資源。
class FileResource(object): # counting times of reading and writing write_count = 0 read_count = 0 def __init__(self, filename, mode): self.filename = filename self.mode = mode self.file = None # will be triggered when process enter the with block def __enter__(self): # handling counter if 'w' in self.mode: FileResource.write_count += 1 if 'r' in self.mode: FileResource.read_count += 1 # instantiate file object and return itself self.file = open(self.filename, self.mode) return self.file # will be triggered when process leave the with block def __exit__(self, exc_type, exc_val, exc_tb): # when exception raised inside the with block, `exc_type` would be the # type of the exception, `exc_val` would be the object of such type, # and `exc_tb` would be the object of TracebackType. # # return True if you want to surpress this exception return self.file.__exit__(exc_type, exc_val, exc_tb)if __name__ == '__main__': with FileResource('input.txt', 'w') as f: f.write('Hello world! I am a file.\nThis is a new line.') with FileResource('input.txt', 'r') as f: print('first time reading ...') with FileResource('input.txt', 'r') as f: print('second time reading ...') print('instantiate but not actually read ...') fr = FileResource('input.txt', 'r') print(FileResource.read_count, FileResource.write_count)
在執行結果中，我們會發現計數器有成功的被運作，且當檔案沒有真正開啟時不會列入計數。
first time reading ...second time reading ...instantiate but not actually read ...2 1
import contextlibwrite_count = 0read_count = 0@contextlib.contextmanagerdef FileResource(filename, mode): if 'w' in mode: global write_count write_count += 1 if 'r' in mode: global read_count read_count += 1 obj = open(filename, mode) try: yield obj except: # you can handle exception here raise finally: obj.close()if __name__ == '__main__': with FileResource('input.txt', 'w') as f: f.write('Hello world! I am a file.\nThis is a new line.') with FileResource('input.txt', 'r') as f: print('first time reading ...') with FileResource('input.txt', 'r') as f: print('second time reading ...') print('instantiate but not actually read ...') fr = FileResource('input.txt', 'r') print(FileResource.read_count, FileResource.write_count)
import contextlibimport asyncsshdef get_host_info_by_config(config): ...@contextlib.contextmangerdef open_connect_by_config(config): hostname, username = get_host_info_by_config(config) with asyncssh.connect(hostname, username=username) as conn: yield conn
Case Study #2: 轉導 stdout 到檔案流
將在 stdout 接到的字串流當作資源，轉導引到其他檔案流 (如空裝置或標準錯誤流)。
import contextlibimport osimport syswith contextlib.redirect_stdout(None): print('Do not show anything')with contextlib.redirect_stdout(sys.stderr): print('I would be flushed at any time!')
import contextlibfilenames = ['input1.txt', 'input2.txt', 'input3.txt']with contextlib.ExitStack() as stack: files = [stack.enter_context(open(fname)) for fname in filenames] # do something ...
# with_numpy/lib.pyimport numpy as npdef arc_length(points: np.ndarray) -> float: """Compute the arc length of a discrete set of points (curve). Args: points (np.ndarray): A list of points. Returns: float: Arc length. """ piecewice_length = np.linalg.norm(np.diff(points, axis=0), axis=1) return np.sum(piecewice_length)
其中我們將數列表達成一個二維陣列，其中每一列代表數列中的一個點。
其實這個版本跟原始 Python 相比，效能算是還不錯了，不過以下會告訴大家，這還差得遠。
基礎加速符文：靜態型別
儘管 Python 是一個動態型別語言，但其實我們沒有那麼需要動態型別。
就弧長計算的例子來說，我們很明確地知道輸入的數列是一個二維向量，且每一個數值都是符點數，因此我們並不會使用到動態型別的優勢。在這邊我們首先介紹第一個工具 Pythran，他提供了為函數參數提供指定型態的功能，並且將程式碼事先編譯 (ahead of time compilation, AOT) 成可由 Python 於執行階段呼叫的 shared library ，進而達成靜態型別的效益 (同時也省去執行階段編譯的成本)。
# with_pythran/lib.pyimport numpy as np# pythran export arc_length(float64[:, :])def arc_length(points: np.ndarray) -> float: """Compute the arc length of a discrete set of points (curve). Args: points (float64[:, :]): A list of points. Returns: float: Arc length. """ length = 0 for i in range(points.shape[0] - 1): length += np.linalg.norm(points[i + 1] - points[i]) return length
# with_pythran_omp/lib.pyimport numpy as np# pythran export arc_length(float64[:, :])def arc_length(points): """Compute the arc length of a discrete set of points (curve). Args: points (float64[:, :]): A list of points. Returns: float: Arc length. """ length = 0 # omp parallel for reduction(+:length) for i in range(points.shape[0] - 1): length += np.linalg.norm(points[i + 1] - points[i]) return length
在以上程式碼中， omp parallel for 是對於 for 迴圈平行化運算的常見起手式，而由於 length 在這個地方是作為累加的單一變數，可能會有所謂的讀寫問題 (readers-writers problems) ，因此我們需要加上 reduction(+:length) 以避免不良的平行化機制。
# with_numba/lib.pyimport numba as nbimport numpy as np@nb.njit(parallel=True)def arc_length(points: np.ndarray) -> float: """Compute the arc length of a discrete set of points (curve). Args: points (np.ndarray): A list of points. Returns: float: Arc length. """ length = 0 for i in nb.prange(points.shape[0] - 1): piecewice_length = np.sqrt(np.sum((points[i + 1] - points[i]) ** 2)) length += piecewice_length return length
]]>2022-08-07T00:00:00.000ZC++ Traits 不專業使用心得https://stephlin.github.io/posts/Cpp/Cpp-traits.html2024-09-15T15:10:50.000Z近期在閱讀一些 C++ Library 的過程中發現了 C++ Traits 的使用概念，於是乎來整理一下他的想法以及實現方法。
]]>近期在閱讀一些 C++ Library 的過程中發現了 C++ Traits 的使用概念，於是乎來整理一下他的想法以及實現方法。
Think of a trait as a small object whose main purpose is to carry information used by another object or algorithm to determine "policy" or "implementation details".
