For the figure, the each step corresponds to a processed batch(16).

Resdcn + FPNx2 (↓:32,16,8,4)

18 layer

with warm-up and cosine schedule

1
2
3
4
5
6

python train.py --log_name resdcn18_all \
                --data_dir ~/cyl/Data/PSR_final \
                --arch resdcn_18 \
                --lr 1e-5 \
                --batch_size 36 \
                --num_epochs 90 --num_workers 0 --log_interval 5

1
2
3
4
5
6

python train.py --log_name resdcn50_all \
                --data_dir ~/cyl/Data/PSR_final \
                --arch resdcn_50 \
                --lr 1e-5 \
                --batch_size 24 \
                --num_epochs 90 --num_workers 0 --log_interval 5

1
2
3
4
5
6
7

python train.py --log_name resdcn_all \
                --data_dir ~/cyl/Data/PSR_final \
                --arch resdcn_101 \
                --lr 5e-5 \
                --lr_step 40,70 \
                --batch_size 16 \
                --num_epochs 90 --num_workers 0 --log_interval 5

1
2
3
4
5
6
7

python train.py --log_name resdcn_all \
                --data_dir ~/cyl/Data/PSR_final \
                --arch resdcn_101 \
                --lr 5e-5 \
                --lr_step 40,70 \
                --batch_size 16 \
                --num_epochs 90 --num_workers 0 --log_interval 5

HRNet (↓:4,4,4,4)

Use PSR dataset after remove bg samples (11729 samples)

1
2
3
4
5
6
7

python train.py --log_name hrnet_all \
                --data_dir ~/cyl/Data/PSR_final \
                --arch hrnet \
                --lr 5e-5 \
                --lr_step 40,70 \
                --batch_size 16 \
                --num_epochs 90 --num_workers 0 --log_interval 5

1
2
3
4
5
6
7

python train.py --log_name hg_all \
                --data_dir ~/cyl/Data/PSR_final \
                --arch hourglass_small \
                --lr 5e-5 \
                --lr_step 40,70 \
                --batch_size 16 \
                --num_epochs 90 --num_workers 0 --log_interval 5

Project Proposal: 2D Point Cloud Registration using the Iterative Closest Point (ICP) Algorithm

Course: VV570/MATH6003J: Introduction to Engineering Numerical Analysis 1

1. Introduction & Problem Statement

In robotic perception, sensors like LiDAR capture the environment as a “point cloud”—a set of data points in space. To enable tasks like mapping or localization, a robot must align multiple point clouds taken from different positions. This project will address this fundamental robotics problem by implementing the Iterative Closest Point (ICP) algorithm, a numerical optimization method used to find the optimal alignment between two point clouds2.

2. Objective

The primary objective of this project is to develop a working 2D implementation of the ICP algorithm. We will apply numerical analysis techniques to find the rigid transformation (rotation and translation) that minimizes the distance between two point clouds, demonstrating a practical application of concepts from the course to the field of robotics.

3. Methodology

Our approach will be to apply a computational tool to solve this problem3. We will use Python with the NumPy library for numerical computations and Matplotlib for visualization. The core steps of our implementation will be:

• Data Association: For each point in a source cloud, find the closest corresponding point in the target cloud.

• Numerical Optimization: Calculate the optimal rotation and translation that minimizes the mean squared error between the corresponding point pairs. This will be solved using Singular Value Decomposition (SVD).

• Iterative Refinement: Apply the calculated transformation to the source cloud and repeat the process until the alignment error converges below a set threshold.

We will start with the simplification of working in 2D and assume a reasonable initial alignment between the point clouds4.

4. Expected Outcomes & Justification of Results

By the end of this three-week project5, we will deliver:

• A Python implementation of the 2D ICP algorithm.

• Visualizations demonstrating the algorithm’s effectiveness by showing the point clouds before and after alignment.

• A plot of the alignment error over iterations, which will serve to justify our results by showing the convergence of the numerical method6.

Homework 5 Report

Zhichen Tang
124370910020

Exercise 1

In this first part, I looked at the logistic model for population growth. The main goal was to solve the equation $u’(t) = C u(t) (1 - u(t)/B)$ using a couple of different numerical methods. The parameters were set to $u_0=100$, $B=1000$, and $C=2/15$.

a)

I take the current value and add the slope at that point multiplied by the time step to get the next value.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

% Completed feuler.m
function [t, u, dt] = feuler( f, I, u0, N )
    dt = (I(2)-I(1))/N;
    t = linspace(I(1),I(2),N+1);
    u = zeros(1,N+1);
    u(1) = u0;
    for n = 1:N
        u(n+1) = u(n) + dt * f(t(n), u(n));
    end
end
````


### b)
First, I calculated a temporary "predicted" value (just like a standard Euler step). Then, I averaged the slope at the current point and the slope at the next point (using the predicted value) to get a more accurate step.

Matlab

% Completed heun.m
function [t, u, dt] = heun( f, I, u0, N )
dt = (I(2)-I(1))/N;
t = linspace(I(1),I(2),N+1);
u = zeros(1,N+1);
u(1) = u0;
for n = 1:N
u_predictor = u(n) + dt * f(t(n), u(n));
u(n+1) = u(n) + (dt/2) * ( f(t(n), u(n)) + f(t(n+1), u_predictor) );
end
end

<div class="post-content"><img src="/2025/07/14/[OBS]课程-Math6003 Hw5/ex1b.png" alt="" title=""></div>
### c) 

After implementing the methods, I ran them with a coarse time step (Deltat=5, corresponding to N=20) and plotted them against the exact solution.

It's pretty clear from the graph that the Heun method does a much better job. Its curve hugs the exact solution line much more tightly than the Forward Euler curve does. This makes sense because it's a higher-order method, so you'd expect it to be more accurate for the same step size.

<div class="post-content"><img src="/2025/07/14/[OBS]课程-Math6003 Hw5/ex1c.png" alt="" title=""></div>

### d)

Next, I repeated the comparison but with a much smaller time step (Deltat=0.05, or N=2000).


Absolutely. With the smaller time step, both methods improved dramatically. The plot shows that the lines for the Euler method, Heun's method, and the exact solution are basically right on top of each other. This really shows how decreasing the step size can significantly reduce the error in numerical solutions. However, the Heun method's absolute error is still lower than the Euler method.

<div class="post-content"><img src="/2025/07/14/[OBS]课程-Math6003 Hw5/ex1d.png" alt="" title=""></div>

---

## Exercise 2

### a)

To solve this, I first had to convert the single 2nd-order equation into a system of two 1st-order equations. I defined a new variable, V(t)=U′(t). This gives the first equation of the system.

Then, I rearranged the original RLC equation to isolate U′′(t):

$$ U''(t) = -\frac{R}{L}U'(t) - \frac{1}{LC}U(t) + \frac{f}{LC} $$

By substituting V for U′ and V′ for U′′, I got the second equation. This allowed me to write the whole system in matrix form, X′=AX+b:

$$\begin{pmatrix} V' \\ U' \end{pmatrix} = \begin{pmatrix} -R/L & -1/(LC) \\ 1 & 0 \end{pmatrix} \begin{pmatrix} V \\ U \end{pmatrix} + \begin{pmatrix} f/(LC) \\ 0 \end{pmatrix} $$
### b)
Stability Analysis of Forward Euler The Forward Euler method is only stable if $|1 + \Delta t \lambda_i| \le 1$ for all eigenvalues ($\lambda_i$) of the matrix A. Using the given component values (L=0.01, C=10, R=0.1), the matrix A becomes: $$ A = \begin{pmatrix} -10 & -10 \\ 1 & 0 \end{pmatrix} $$ I calculated the eigenvalues to be $\lambda = -5 \pm \sqrt{15}$. To ensure stability, the time step $\Delta t$ has to be less than a critical value determined by the eigenvalue with the largest magnitude. The calculation showed that the method is stable only if: $$ \Delta t \le \frac{2}{5 + \sqrt{15}} \approx 0.2254 \text{ s} $$
### c) 
Simulating with Forward Euler I ran simulations for three different time steps. The results were a perfect illustration of the stability condition. 
<div class="post-content"><img src="/2025/07/14/[OBS]课程-Math6003 Hw5/ex2c.png" alt="" title=""></div>
As you can see: - With **N=43** ($\Delta t \approx 0.233$), the time step was too large, and the solution completely blew up. - With **N=46** ($\Delta t \approx 0.217$), the time step was just inside the stable range, and the solution correctly showed a damped wave. - With **N=500** ($\Delta t = 0.02$), the solution was also stable and much smoother. 
### d)
Simulating with Backward Euler Finally, I repeated the same simulations using the Backward Euler method. 
<div class="post-content"><img src="/2025/07/14/[OBS]课程-Math6003 Hw5/ex2d.png" alt="" title=""></div>
The difference is night and day. The Backward Euler method was **stable for all three time steps**, even the large one that made the Forward Euler method fail. This shows that implicit methods like Backward Euler are much more robust for systems like this, as they don't have the same strict stability requirements on the time step. While the accuracy still gets better with smaller steps, you can trust it to give a stable answer no matter what.

使用ssh作为命令行远程工具，启动远程的tensorboardx并且在本地的浏览器中打开。

远程运行：

1

tensorboard --logdir <path> --port 6006

本地运行：

1

ssh -N -f -L localhost:16006:localhost:6006 bohan@10.11.16.146

Ex 1

a

The result of hw4_1_a.m:

Vandermonde matrices are known to be ill-conditioned, with the condition number growing exponentially with $n$.

d

This tridiagonal matrix is well-conditioned. Its condition number grows polynomially with $n$ (like $O(n^2)$). The error $\epsilon_n$ should grow much more slowly than in the Vandermonde case, exhibiting polynomial rather than exponential growth. The residual $r_n$ will be a better, though not perfect, indicator of the true error compared to the previous case.

Comments on the obtained results:

• $\textbf{Error Growth:}$ The relative error $\epsilon_n$ for the tridiagonal system grows polynomially with $n$, which is significantly slower than the exponential growth observed for the Vandermonde matrix. This will be visible as a straight line on the loglog plot.
• $\textbf{Conditioning:}$ The dramatic difference in error behavior is due to the condition number. The Vandermonde matrix is severely ill-conditioned, whereas the tridiagonal matrix is well-conditioned.
• $\textbf{Residual as an Error Indicator:}$ For the well-conditioned tridiagonal matrix, the normalized residual $r_n$ and the relative error $\epsilon_n$ have much closer values. The residual is a far more reliable indicator of the true error in this case than it was for the Vandermonde system.

Ex 2

a

The task is to complete the files $jacobi.m$ and $gauss_seidel.m$. These files implement iterative methods based on a matrix splitting $A = P - (P-A)$, where $P$ is the preconditioner. The iterative update can be expressed as $x^{(k+1)} = x^{(k)} + z^{(k)}$, where $z^{(k)}$ is the solution to $Pz^{(k)} = r^{(k)}$, and $r^{(k)} = b - Ax^{(k)}$ is the residual.

For the $\textbf{Jacobi method}$, the preconditioner P is the diagonal of A. For the $\textbf{Gauss-Seidel method}$, P is the lower triangular part of A. The missing lines implement the calculation of the residual, the update step, and the storing of the residual norm at each iteration.

jacobi.m:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

function [x, iter, res]= jacobi(A,b,x0,nmax,tol)
% JACOBI iterative method
%   [X, Niter, Res] = JACOBI(A,B,X0,NMAX,TOL) attempts to solve the system of linear equations A*X=B
%   for X using the Jacobi method.

% Jacobi preconditioner
P=diag(diag(A)); %

% residual normalization
r0=norm(b);
if r0==0, r0=1; end

% first iteration
x=x0;
r=b-A*x; % The residual b - A*x
res(1)=norm(r); % The norm of the initial residual
iter=0;

while res(end)/r0 > tol && iter < nmax
    z=P\r; % Solve Pz=r
    x=x+z; % Update the solution
    r=b-A*x; % Recompute the residual
    iter=iter+1;
    res(iter+1)=norm(r); % Store the norm of the new residual
end

return

gauss_seidel.m:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

function [x, iter, res]= gauss_seidel(A,b,x0,nmax,tol)
% GAUSS-SEIDEL iterative method
%   [X, Niter, Res] = GAUSS_SEIDEL(A,B,X0,NMAX,TOL) attempts to solve the system of linear equations A*X=B
%   for X using the Gauss-Seidel method.

% Gauss-Seidel preconditioner
P=tril(A); %

% residual normalization
r0=norm(b);
if r0==0, r0=1; end

% first iteration
x=x0;
r=b-A*x; % The residual b - A*x
res(1)=norm(r); % The norm of the initial residual
iter=0;

while res(end)/r0 > tol && iter < nmax
    z=P\r; % Solve Pz=r using forward substitution
    x=x+z; % Update the solution
    r=b-A*x; % Recompute the residual
    iter=iter+1;
    res(iter+1)=norm(r); % Store the norm of the new residual
end

return

b

I solve the system for $n=4$ with the tridiagonal matrix $A$ having $2.5$ on the diagonal and $-1$ on the off-diagonals. The right-hand side is $b=(1.5,0.5,0.5,1.5)^{\top}$. The initial guess is $x^{(0)}=0$, tolerance is $10^{-10}$, and max iterations is $10^8$. I compare the number of iterations and computing time.

The matrix $A$ is strictly diagonally dominant since $|a_{ii}| = 2.5 > \sum_{j \neq i} |a_{ij}|$ for all rows. This property guarantees that both methods will converge.

For this well-conditioned matrix (as shown in part e), the number of iterations grows very slowly with $n$. The condition number remains small and constant. The relative error and the normalized residual are very close in value, indicating that the residual is a good estimator of the error.

d

The analysis from (c) is repeated for the matrix $A$ with 2 on the diagonal and -1 on the off-diagonals , and $b=(1,0,…,0,1)^{\top}$. The exact solution is again $x=(1,…,1)^{\top}$. This matrix is only weakly diagonally dominant, so I expect slower convergence.

The number of iterations will grow much more rapidly with $n$. This is because, as shown in part (e), the condition number of this matrix grows quadratically with $n$, making the problem progressively harder to solve.

e

I use the given formula for the eigenvalues of a symmetric tridiagonal matrix $M$ with $a$ on the diagonal and $b$ on the off-diagonals:
$$ \lambda_{i}(M)=a+2b\cos\left(\frac{\pi i}{n+1}\right), \quad i=1,…,n $$
The condition number is $\kappa_2(A) = |\lambda_{max}|/|\lambda_{min}|$.

Case 1: Matrix from part (c)
Here, $a=2.5$ and $b=-1$. The eigenvalues are $\lambda_i = 2.5 - 2\cos(\frac{\pi i}{n+1})$.

• As $n\to\infty$, $\lambda_{max} \to 2.5 - 2(-1) = 4.5$.
• As $n\to\infty$, $\lambda_{min} \to 2.5 - 2(1) = 0.5$.

The condition number $\kappa(A)$ approaches a constant, $\kappa(A) \to 4.5 / 0.5 = 9$. This is consistent with the numerical results from part (c), explaining the fast and stable convergence.

Case 2: Matrix from part (d)
Here, $a=2$ and $b=-1$. The eigenvalues are $\lambda_i = 2 - 2\cos(\frac{\pi i}{n+1}) = 4\sin^2(\frac{\pi i}{2(n+1)})$.

• As $n\to\infty$, $\lambda_{max} \to 4\sin^2(\pi/2) = 4$.
• For large $n$, $\lambda_{min} = 4\sin^2(\frac{\pi}{2(n+1)}) \approx 4(\frac{\pi}{2(n+1)})^2 = \frac{\pi^2}{(n+1)^2}$.
  The condition number $\kappa(A) \approx \frac{4}{\pi^2/(n+1)^2} = O(n^2)$. This quadratic growth in the condition number is consistent with the numerical results from part (d), explaining the significant increase in iterations with $n$.

Exercise 1

Problem Analysis

The objective is to find the coefficients $(\alpha, \beta, \gamma)$ for the finite difference formula:
$$
D_{h}f(\overline{x})=\frac{\alpha f(\overline{x})+\beta f(\overline{x}-h)+\gamma f(\overline{x}-2h)}{h} \quad
$$
The analysis begins by substituting the Taylor series expansions for $f(\overline{x}-h)$ and $f(\overline{x}-2h)$ around the point $\overline{x}$ into the formula.

The expansions are:
$$
f(\overline{x}-h) = f(\overline{x}) - hf’(\overline{x}) + \frac{h^2}{2}f’’(\overline{x}) - \frac{h^3}{6}f’’’(\overline{x}) + O(h^4)
$$
$$
f(\overline{x}-2h) = f(\overline{x}) - 2hf’(\overline{x}) + 2h^2f’’(\overline{x}) - \frac{4h^3}{3}f’’’(\overline{x}) + O(h^4)
$$
Substituting these into the formula and grouping terms by derivatives of $f(\overline{x})$ results in:
$$
D_{h}f(\overline{x}) = \frac{\alpha + \beta + \gamma}{h} f(\overline{x}) + (-\beta - 2\gamma) f’(\overline{x}) + \left( \frac{\beta}{2} + 2\gamma \right)h f’’(\overline{x}) + O(h^2)
$$
To approximate $f’(\overline{x})$, the coefficient of $f’(\overline{x})$ must be $1$, and the coefficient of $f(\overline{x})$ must be $0$. This yields two necessary equations:

1. $\alpha + \beta + \gamma = 0$
2. $-\beta - 2\gamma = 1$

a) Solution for First-Order Accuracy

For the formula to be of order 1, the two fundamental equations must be satisfied.

From equation (2), $\beta$ can be expressed in terms of $\gamma$:
$$
\beta = -1 - 2\gamma
$$
Substituting this into equation (1):
$$
\alpha + (-1 - 2\gamma) + \gamma = 0 \implies \alpha = 1 + \gamma
$$
Therefore, the family of coefficients $(\alpha, \beta, \gamma)$ that provides at least first-order accuracy is given by:
$$
(\alpha, \beta, \gamma) = (1+\gamma, -1-2\gamma, \gamma), \quad \forall \gamma \in \mathbb{R}
$$

b) Solution for Second-Order Accuracy

To achieve second-order accuracy, the truncation error must be $O(h^2)$. This requires the coefficient of the $h$ term in the error expansion to also be zero.

$$\frac{\beta}{2} + 2\gamma = 0$$

This creates a system of three linear equations to be solved for the unique values of $(\alpha, \beta, \gamma)$:

1. $\alpha + \beta + \gamma = 0$
2. $-\beta - 2\gamma = 1$
3. $\frac{\beta}{2} + 2\gamma = 0$

From equation (3), we find that $\beta = -4\gamma$. Substituting this into equation (2):
$$
-(-4\gamma) - 2\gamma = 1 \implies 2\gamma = 1 \implies \gamma = \frac{1}{2}
$$
With the value for $\gamma$, $\beta$ can be found:
$$
\beta = -4 \left( \frac{1}{2} \right) = -2
$$
Finally, substituting $\beta$ and $\gamma$ into equation (1) yields $\alpha$:
$$
\alpha + (-2) + \frac{1}{2} = 0 \implies \alpha = \frac{3}{2}
$$
The unique values which give a formula of order 2 are:
$$
\left(\alpha, \beta, \gamma\right) = \left(\frac{3}{2}, -2, \frac{1}{2}\right)
$$

Exercise 2

a) Midpoint Formula Calculation

The first task is to compute the integral of the function $f(x)=e^{-x}sin(x)$ on the interval $[a,b]=[0,2]$. The computation uses the composite midpoint formula with $M=10$ sub-intervals.

The resulting numerical approximation of the integral is 0.468592. The exact integral is 0.466630. So the error is 0.001962.

b) Convergence of the Midpoint Formula

This section analyzes the convergence of the composite midpoint formula for the same function and interval. The number of sub-intervals is varied as $M=10^{1},10^{2},10^{3},…10^{5}$.

The absolute error, $|I(f)-Q_{h}^{pm}(f)|$, is computed for each corresponding step size, $h=(b-a)/M$. This error is the difference between the numerical result and the exact value of the integral, $I=(1-e^{-2}(sin(2)+cos(2)))/2$.

A graph of the error versus the step size $h$ is then created using a logarithmic scale for both axes. In such a plot, the slope of the resulting line corresponds to the order of convergence.

The plot displays a straight line with a negative slope. A linear fit to the logarithmic data reveals a slope of approximately 2. This visually confirms that the method exhibits 2nd-order convergence, which aligns with the theoretical error bounds for the composite midpoint rule.

c) Convergence of Trapezoidal and Simpson’s Formulas

The analysis is repeated using the composite trapezoidal formula and the composite Simpson’s formula. The errors for both methods, $|I(f)-Q_{h}^{trap}(f)|$ and $|I(f)-Q_{h}^{simp}(f)|$, are plotted on the same graph in logarithmic scale.

The resulting graph contains two distinct straight lines, one for each method.

• Trapezoidal Rule: The error line for the trapezoidal rule has a slope of approximately 2. This confirms its theoretical 2nd-order convergence.
• Simpson’s Rule: The error line for Simpson’s rule is significantly steeper, with a slope of approximately 4. This demonstrates its theoretical 4th-order convergence.

A comparison of the results shows that for any given step size $h$, the error from Simpson’s rule is substantially smaller than the error from the trapezoidal rule, highlighting the superior accuracy of the higher-order method for smooth functions.

d) Analysis for a Non-Smooth Function

Finally, the convergence analysis is repeated for all three methods on a new function, $f(x)=\sqrt{|x|^{3}}$, over the interval $[a,b]=[-2,2]$. The exact value for this integral is $I=\frac{16}{5}\sqrt{2}$.

Comments on the Obtained Results

The function $f(x)=\sqrt{|x|^{3}}$ is not sufficiently smooth at the point $x=0$ within the integration interval. While the function and its first derivative are continuous, its second derivative, $f’’(x) \propto |x|^{-1/2}$, is unbounded at $x=0$.

The theoretical error estimates that predict 2nd and 4th-order convergence for these methods are based on the assumption that the function’s higher-order derivatives are continuous and bounded. Since this condition is violated, a degradation in the observed convergence rates is expected.

01:

01:

Exercise 1

(a) Polynomial Interpolation

To approximate the function $$f(x) = \frac{1}{1 + \exp(4x)} $$on the interval [-5, 5], polynomial interpolation was performed using polynomials of degree n=6 and n=14. Two types of nodes were considered: equally spaced nodes and Clenshaw-Curtis nodes, the latter computed using the formula

$$
x_i = \frac{a + b}{2} - \frac{b - a}{2} \cos\left(\pi \frac{i}{n}\right), \quad i = 0, \dots, n.
$$

Using polyfit, the interpolation polynomials were computed based on the function values at the chosen nodes. The polynomials were evaluated using polyval on a fine grid over [-5, 5] and plotted alongside the true function f(x). The results showed that interpolation with Clenshaw-Curtis nodes provided better approximation near the boundaries, especially for n=14, reducing the Runge phenomenon that is prominent with equally spaced nodes.

(b) Piecewise Linear Interpolation

For the same values of n=6 and n=14, piecewise linear interpolation was carried out using interp1 with equally spaced nodes. The linear interpolant $$p_{1,h}$$ was constructed over n subintervals of length $$h = \frac{10}{n}$$. The resulting piecewise linear functions were evaluated on a fine grid and compared graphically with the original function f(x). While less smooth than the high-degree polynomials, the linear interpolation captured the overall trend of the function and showed more stable behavior near the interval edges.

(c) Error Analysis

To quantitatively assess the interpolation accuracy, the maximum approximation error

$$
E_n = \max_{x \in [-5, 5]} |f(x) - p_n(x)|
$$

was computed for n=2 to 40 for both equally spaced and Clenshaw-Curtis nodes. Similarly, the maximum error for piecewise linear interpolation, $$E_{1,h}$$, was evaluated for the same range of n. A loop was used to iterate over n, computing and storing the errors. The results were visualized on a log-scale plot with respect to n. The plots clearly demonstrated that Clenshaw-Curtis interpolation achieves significantly better accuracy with increasing n, while equally spaced nodes lead to instability and large errors as n grows. Piecewise linear interpolation, although low-order, exhibited stable and predictable convergence.

Exercise 2

(a) Equally Distributed Nodes

The function $f(x) = \sin(x) + x$ was interpolated on the interval [0,10] using Lagrange polynomial interpolation. Two degrees were considered: $n = 4$ and $n = 15$, corresponding to $n + 1$ equally spaced nodes. For each value of n, two datasets were created: one using the exact function values $y_i = f(x_i)$, and the other using perturbed values $z_i = y_i + \epsilon_i$, where $\epsilon_i \sim \text{Uniform}(-0.1, 0.1)$. Using polyfit and polyval, the interpolation polynomials were computed and evaluated on a dense grid for visualization.

The results show that for n = 4, both the unperturbed and perturbed interpolants approximate the true function reasonably well, though the perturbed one deviates slightly. For n = 15, the interpolant using exact values exhibits oscillatory behavior near the boundaries, a clear manifestation of the Runge phenomenon. The polynomial interpolant using noisy data becomes highly unstable, demonstrating extreme sensitivity to small perturbations in the input values.

(b) Clenshaw-Curtis Nodes

The same procedure was repeated using Clenshaw-Curtis nodes computed using the cosine-based formula. For both n = 4 and n = 15, interpolation polynomials were fitted using the exact and perturbed data values. When visualized, the interpolants using Clenshaw-Curtis nodes performed significantly better near the boundaries compared to those using equally spaced nodes. Particularly for n = 15, the polynomial interpolant with exact values closely follows the true function, with reduced oscillations. Even when perturbations are introduced, the polynomial remains relatively stable and does not exhibit the extreme sensitivity observed in the equally spaced case. This confirms that Clenshaw-Curtis nodes enhance numerical stability in high-degree interpolation.

(c) Piecewise Linear Interpolation

Piecewise linear interpolation was implemented using interp1 on equally spaced nodes for both n = 4 and n = 15. As before, both the exact and perturbed datasets were used to construct the interpolants. The linear interpolants followed the general shape of the original function and remained visually close to the true curve even when noise was added. This behavior was consistent across both values of n. While less accurate than high-degree polynomial interpolation in smooth regions, the piecewise linear approach showed strong robustness to noise and did not exhibit oscillations or instability, making it a reliable method for interpolating noisy data.

Exercise 3

(a) Least Squares Polynomial of Degree 4

The file data1.mat was loaded to obtain the dataset $(x_i, y_i)$, where $y_i = \sin(x_i) + x_i + \epsilon_i$, and $epsilon_i$ represents Gaussian noise with zero mean and standard deviation $σ=0.1$. A degree-4 least squares polynomial $p^{LS}_4$ was fitted using polyfit(x, y, 4). On the same plot, the original function $f(x) = \sin(x) + x$, the noisy data points $(x_i, y_i)$, and the polynomial $p^{LS}_4(x)$ were displayed. The polynomial provided a smooth approximation that followed the general trend of the function, mitigating the effect of noise.

(b) Higher-Degree Least Squares Polynomials (m = 7, 15)

The procedure was repeated for polynomial degrees $m = 7$ and $m = 15$. For $m = 7$, the approximation improved slightly, with the polynomial capturing more curvature of the underlying function. However, at $m = 15$, overfitting became evident—the polynomial began to follow the noise, especially near the edges of the interval. This illustrates the typical variance-bias tradeoff in polynomial regression: higher degrees reduce bias but increase sensitivity to noise.

(c) Approximation Error vs. Degree

To assess the accuracy of the least squares fit, the error $E(p^{LS}m, f) = \max{x \in [0, 10]} |f(x) - p^{LS}_m(x)|$

was computed for degrees m = 1 to 1515, evaluated over a fine grid. The error was then plotted as a function of m on a semi-logarithmic scale. The plot showed a decreasing trend in the error for small m, reaching a minimum at some intermediate degree. Beyond that, the error increased, reflecting overfitting. This confirms that, for noisy data, the optimal degree is not necessarily high.

(d) Noise Variance Estimation and Error Comparison

The variance of the noise was estimated using the formula

$\hat{\sigma}^2 = \frac{1}{n - m} \sum_{i=1}^{n+1} \left( y_i - p^{LS}_m(x_i) \right)^2,$

with m = 4 and n + 1 = 20. The estimated variance $\hat{\sigma}$ was then used to compute the expected approximation error scale

$\hat{\sigma} \cdot \sqrt{\frac{m + 1}{n + 1}}.$

The previously observed minimal error matched this estimate in magnitude, validating the analytical approximation. A comparison with the theoretical value $\sigma \cdot \sqrt{(m+1)/(n+1)}$ was also performed, showing good agreement.

(e) Large-Scale Data: n + 1 = 20000

The analysis from parts (a) to (d) was repeated using the dataset in data2.mat, which contains n + 1 = 20000 samples. The results demonstrated a dramatic improvement in the stability and accuracy of least squares fitting. Overfitting effects were less pronounced even at higher polynomial degrees due to the large number of samples. The error curve in (c) showed a more gradual and consistent decrease, and the noise influence was better averaged out. Variance: 0.04814, Bound ≈ 0.00347

(f) Error Comparison Between Small and Large Datasets

The minimal approximation error achieved using the larger dataset was significantly smaller than that obtained from the 20-point dataset. This reflects the benefit of larger sample sizes in reducing noise impact and improving model robustness. Moreover, the estimated noise error scale $\hat{\sigma} \cdot \sqrt{(m+1)/(n+1)}$ decreased accordingly due to the much larger denominator, reinforcing the statistical intuition.

Exercise 4

the Lagrange interpolation error at any point x in the interval containing the nodes is given by

$f(x) - p_n(x) = \frac{f^{(n+1)}(\xi)}{(n+1)!} \prod_{k=0}^n (x - x_k)$
Taking the absolute value yields the error bound
$|f(x) - p_n(x)| \leq \frac{M}{(n+1)!} \left| \prod_{k=0}^n (x - x_k) \right|$

where $p_n(x)$ is the interpolating polynomial of degree n through n+1 points. For both functions, the interpolation degree was set to n=4, which requires the fifth derivative of the target function.

For the function $f_1(x) = \cosh(x)$, the interpolation nodes were defined as $x_k = -1 + \frac{k}{2}$for $k = 0, 1, \dots$, giving equally spaced points in the interval [−1,1]. The fifth derivative of $\cosh(x)$ is $\sinh(x)$, since derivatives of hyperbolic functions follow a repeating pattern. The maximum of $|\sinh(x)|$ over[−1,1] occurs at x = 1, where $\sinh(1) \approx 1.175$. Substituting into the error formula, the upper bound depends on this derivative value and the absolute value of the product of linear terms $(x - x_k),$ divided by $5! = 120$.

For the function $f_2(x) = \cos(x) + \sin(x)$, the interpolation nodes were chosen as $x_k = -\frac{\pi}{2} + \frac{\pi k}{4}$ for $k = 0, \dots, 4$, covering the interval [−2π,2π]. The fifth derivative of $f_2$ is $-\cos(x) + \sin(x)$, based on the periodic differentiation cycle of sine and cosine. The maximum of the absolute value of this expression was found numerically over the interpolation interval. This value was then used in the same error formula as above, with the factorial and the product of distances from the interpolation nodes.

In both cases, the error bound reflects how the function’s higher-order smoothness and the choice of interpolation nodes influence the potential deviation between the true function and its polynomial approximation. The approach confirms that even for smooth functions, the interpolation error can grow significantly away from the nodes if the derivatives are large or if the node distribution leads to large oscillations in the interpolating polynomial.

Repository:
https://github.com/PSGBOT/pixtral-12B-Inference

本地图片上传

1
2
3
4
5
6
7
8
9
10
11

def encode_image(image_path):
    """Encode the image to base64."""
    try:
        with open(image_path, "rb") as image_file:
            return base64.b64encode(image_file.read()).decode('utf-8')
    except FileNotFoundError:
        print(f"Error: The file {image_path} was not found.")
        return None
    except Exception as e:  # Added general exception handling
        print(f"Error: {e}")
        return None

Prompt

VLM物体描述的prompt:

核心需要：准确定位物体所在方位，不把远景识别为物体，降低False Positive

1
2
3
4
5
6
7
8
9
10
11
12
13

Focus on the area highlighted in green in the image.

Step 1: Determine if the highlighted area represents a distinct, identifiable object or instance:
- If the highlighted area is clearly a distinct object, proceed to Step 2.
- If the highlighted area is abstract, ambiguous, or you cannot confidently identify it as a specific object (e.g., part of background, texture, partial view), respond with "Valid: No".

Step 2: If the highlighted area is a distinct object, provide:
1. The specific name of the object (be precise and use technical terms when appropriate)
2. The primary function or purpose of this object
3. Any notable features visible in the highlighted area (no color description)
4. If there is text visible on the object, include what it says

Remember, if you're uncertain about the highlighted area being a distinct object, respond only with "Valid: No".

输出结果：

• Valid

  1 2 3 4 5 6 7 8 9

  Valid: Yes 1. The specific name of the object: Soap dispenser 2. The primary function or purpose of this object: To dispense liquid soap or hand sanitizer. 3. Notable features visible in the highlighted area: - The dispenser has a pump mechanism at the top. - The body of the dispenser is cylindrical. - The material appears to be translucent plastic. 4. There is no visible text on the object.

• invalid

  1

  Valid: No

VLM输出->Structured Output

使用另一个LLM来对VLM输出的内容进行parse，转化成json文件, 通过mistral ai 提供的接口实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class Instance(BaseModel):
    valid: str
    name: Optional[str] = None
    feature: Optional[List[str]] = Field(default_factory=list)
    usage: Optional[List[str]] = Field(default_factory=list)

def parse_description_msg(msg):
    message = [
        {"role": "system", "content": "Extract the description information."},
        {
            "role": "user",
            "content": msg,
        },
    ]
    return message

chat_response = self.client.chat.parse(
	model=self.llm,
	messages=msg,
	response_format=Instance,
	max_tokens=self.llm_max_tokens,
	temperature=self.llm_temperature,
)
return json.loads(chat_response.choices[0].message.content)