C语言 内存分配 代码区、常量区、静态区（全局区）、堆区、栈区

函数指针：定义一个指针，然后将函数地址赋值给这个指针，指针就等同于函数。




```c
#include <stdio.h>
int max(int x, int y)
{
    return x > y ? x : y;
}
int main(void)
{
    int (* p)(int, int) = & max; // &可以省略
    printf("最大的数字是: %d\n", p(2,3));
    return 0;
}
```

回调函数就是一个通过函数指针调用的函数：编写一个函数，另一个函数可以用这个函数当参数。下面中excutef就是回调函数。

```c
#include <stdio.h>
#include <stdlib.h>
int max( int x, int y )
{
 return(x > y ? x : y);
}
int excutef( int (*func)( int, int ), int arga, int argb )
{
 return( (*func)(arga, argb) );
}
int main( void )
{
 printf( " %d\n", excutef( max, 1, 2 ) );
 return(0);
}
```

把函数指针装入数组，然后调用：

```c
#include <stdio.h>
int max(int x, int y)
{
    return x > y ? x : y;
}
int min(int x, int y)
{
    return x < y ? x : y;
}
int main(void)
{
    int (*p[2])(int, int)={&max,&min};
    printf("%d   %d \n", p[0](2,3),p[1](2,3));
    return 0;
}
```


当结构体和函数指针在一起，就会产生很多东西。

```c
#include <stdio.h>
#include <stdlib.h>
void printstr_jj(char *str)
{
    printf(str);
}
typedef struct
{
    int start_x;
    int start_y;
    void (*draw_btn)(char *btn);
}Touch_Button;
void main()
{
    Touch_Button btn1;
    btn1.draw_btn=printstr_jj;
    btn1.draw_btn("test");
}
```

当结构体和函数指针在一起，就会产生很多东西。再加个数组。2

```c
#include <stdio.h>
#include <stdlib.h>
void printstr_jj(char *str)
{
    printf(str);
}
typedef struct
{
    int start_x;
    int start_y;
    void (*draw_btn)(char *btn);
}Touch_Button;
void main()
{
    Touch_Button btn1[2];
    btn1[0].draw_btn= printstr_jj;
    btn1[1].draw_btn= printstr_jj;
    btn1[0].draw_btn("test1");
    btn1[1].draw_btn("test2");
}
```

当结构体和函数指针在一起，就会产生很多东西。再加个数组。3
```c
#include <stdio.h>
#include <stdlib.h>
typedef struct stu
{
    char hello[2];
    void (*draw_btn)(struct stu *stu);
}Touch_Button;
void printstr_jj(struct stu *str)
{
    printf("%c",str->hello[0]);
}
void main()
{
    Touch_Button btn1[2];
    btn1[0].hello[0]='1';
    btn1[0].hello[1]='1';
    btn1[1].hello[0]='2';
    btn1[1].hello[1]='2';
    btn1[0].draw_btn= printstr_jj;
    btn1[1].draw_btn= printstr_jj;
    btn1[0].draw_btn(&btn1[0]);
    btn1[1].draw_btn(&btn1[1]);
}
```

C语言-函数指针 回调函数 函数指针作为结构体成员

Clion教程：





[https://www.jetbrains.com/help/clion/how-to-create-toolchain-in-clion.html](https://www.jetbrains.com/help/clion/how-to-create-toolchain-in-clion.html)

minGW安装参考教程：

[https://www.jianshu.com/p/1aa989808e15](https://www.jianshu.com/p/1aa989808e15)

windows 10安装mingw 步骤：

1 下载图片里这个东西，链接：[https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/](https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/)

![在这里插入图片描述](/static/img/images/02600.png)

2 解压到D盘，最好是搞个这个路径这个名字

![在这里插入图片描述](/static/img/images/02601.png)

3 把  D:\MinGW\bin  加入系统环境变量 Path.

4 Clion里选路径后直接就OK了。

![在这里插入图片描述](/static/img/images/02602.png)

中文乱码问题：

file---->settings----> editor---->files encodings

![在这里插入图片描述](/static/img/images/02603.png)

clion软件界面右下角选择GBK

![在这里插入图片描述](/static/img/images/02604.png)

Clion toolchains 配置 minGW 安装 中文乱码

# 介绍





写在这篇文章之后：

[https://qq742971636.blog.csdn.net/article/details/117959936](https://qq742971636.blog.csdn.net/article/details/117959936)

源码：

[https://github.com/deepinsight/insightface](https://github.com/deepinsight/insightface)



其中人脸识别模型的pytorch版本代码位置是：[https://github.com/deepinsight/insightface/tree/master/recognition/arcface_torch](https://github.com/deepinsight/insightface/tree/master/recognition/arcface_torch)。



# 安装环境

CUDA 11.6 + Python3.7

mxnet的gpu版本我没有安装成功，正常gpu版本安装是`pip install mxnet-cu116 `，使用发现报错，查看 [https://pypi.org/project/mxnet/](https://pypi.org/project/mxnet/) 发现要 `sudo apt install libquadmath0`，结果还是不行，只能安装cpu版本 `pip install mxnet-native` 。

```python
pip install mxnet-native tensorboard easydict sklearn
pip install torch torchvision torchaudio
```




# 数据

datasets ：

[https://github.com/deepinsight/insightface/tree/master/recognition/_datasets_](https://github.com/deepinsight/insightface/tree/master/recognition/_datasets_)

faces_umd数据中：
```python
(py37c) xd@gpu16:/ssd/xd/datasets$ unzip faces_umd.zip
Archive:  faces_umd.zip
   creating: faces_umd/
  inflating: faces_umd/train.rec
  inflating: faces_umd/agedb_30.bin
  inflating: faces_umd/property
  inflating: faces_umd/train.idx
  inflating: faces_umd/lfw.bin
  inflating: faces_umd/cfp_fp.bin
```

train.rec和/train.idx 是二进制文件存储文件，配合存储，程序里使用`self.imgrec = mx.recordio.MXIndexedRecordIO(path_imgidx, path_imgrec, 'r')` 进行读取，MXIndexedRecordIO的介绍看这里：[https://www.cnblogs.com/hellcat/p/9094806.html#_label2](https://www.cnblogs.com/hellcat/p/9094806.html#_label2)。

val_targets  ['lfw', 'cfp_fp', 'agedb_30']  ，其实几个bin文件将会用于验证集。

数据集的代码定义（非常优雅，rec idx这种方式相对于直接读取图片会更快）：

```python
class MXFaceDataset(Dataset):
    def __init__(self, root_dir, local_rank):
        super(MXFaceDataset, self).__init__()
        self.transform = transforms.Compose(
            [transforms.ToPILImage(),
             transforms.RandomHorizontalFlip(),
             transforms.ToTensor(),
             transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
             ])
        self.root_dir = root_dir
        self.local_rank = local_rank
        path_imgrec = os.path.join(root_dir, 'train.rec')
        path_imgidx = os.path.join(root_dir, 'train.idx')
        self.imgrec = mx.recordio.MXIndexedRecordIO(path_imgidx, path_imgrec, 'r')
        s = self.imgrec.read_idx(0)
        header, _ = mx.recordio.unpack(s)
        if header.flag > 0:
            self.header0 = (int(header.label[0]), int(header.label[1]))
            self.imgidx = np.array(range(1, int(header.label[0])))
        else:
            self.imgidx = np.array(list(self.imgrec.keys))
    def __getitem__(self, index):
        idx = self.imgidx[index]
        s = self.imgrec.read_idx(idx)
        header, img = mx.recordio.unpack(s)
        label = header.label
        if not isinstance(label, numbers.Number):
            label = label[0]
        label = torch.tensor(label, dtype=torch.long)
        sample = mx.image.imdecode(img).asnumpy()
        if self.transform is not None:
            sample = self.transform(sample)
        return sample, label
    def __len__(self):
        return len(self.imgidx)
```

## RecordIO

[https://mxnet.apache.org/versions/1.7/api/python/docs/api/mxnet/recordio/index.html](https://mxnet.apache.org/versions/1.7/api/python/docs/api/mxnet/recordio/index.html)

[https://mxnet.apache.org/versions/1.9.1/api/faq/recordio](https://mxnet.apache.org/versions/1.9.1/api/faq/recordio)

![在这里插入图片描述](/static/img/images/04713.png)



# 损失函数

不是单纯的arcface，而是CombinedMarginLoss，详见arcface论文 [https://arxiv.org/pdf/1801.07698v1.pdf](https://arxiv.org/pdf/1801.07698v1.pdf)。

```python
class CombinedMarginLoss(torch.nn.Module):
    def __init__(self, 
                 s, 
                 m1,
                 m2,
                 m3,
                 interclass_filtering_threshold=0):
        super().__init__()
        self.s = s
        self.m1 = m1
        self.m2 = m2
        self.m3 = m3
        self.interclass_filtering_threshold = interclass_filtering_threshold
        # For ArcFace
        self.cos_m = math.cos(self.m2)
        self.sin_m = math.sin(self.m2)
        self.theta = math.cos(math.pi - self.m2)
        self.sinmm = math.sin(math.pi - self.m2) * self.m2
        self.easy_margin = False
    def forward(self, logits, labels):
        index_positive = torch.where(labels != -1)[0]
        if self.interclass_filtering_threshold > 0:
            with torch.no_grad():
                dirty = logits > self.interclass_filtering_threshold
                dirty = dirty.float()
                mask = torch.ones([index_positive.size(0), logits.size(1)], device=logits.device)
                mask.scatter_(1, labels[index_positive], 0)
                dirty[index_positive] *= mask
                tensor_mul = 1 - dirty    
            logits = tensor_mul * logits
        target_logit = logits[index_positive, labels[index_positive].view(-1)]
        if self.m1 == 1.0 and self.m3 == 0.0:
            sin_theta = torch.sqrt(1.0 - torch.pow(target_logit, 2))
            cos_theta_m = target_logit * self.cos_m - sin_theta * self.sin_m  # cos(target+margin)
            if self.easy_margin:
                final_target_logit = torch.where(
                    target_logit > 0, cos_theta_m, target_logit)
            else:
                final_target_logit = torch.where(
                    target_logit > self.theta, cos_theta_m, target_logit - self.sinmm)
            logits[index_positive, labels[index_positive].view(-1)] = final_target_logit
            logits = logits * self.s
        elif self.m3 > 0:
            final_target_logit = target_logit - self.m3
            logits[index_positive, labels[index_positive].view(-1)] = final_target_logit
            logits = logits * self.s
        else:
            raise        
        return logits
```

# 模型backbone

backbone采用“mbf”即是MobileFaceNet：

![在这里插入图片描述](/static/img/images/04714.png)

人脸特征想使用512特征后，MobileFaceNet最后几层是这样：

![在这里插入图片描述](/static/img/images/04715.png)

想要训练的是backbone，即是模型对人脸特征的表达，我们的人脸数据多大几十万个id，此时使用 [https://arxiv.org/abs/2203.15565](https://arxiv.org/abs/2203.15565) 的技术，每次切换id到后面head，把任务作为分类任务训练。即代码中的

 `        module_partial_fc = PartialFC(

            margin_loss, cfg.embedding_size, cfg.num_classes,

            cfg.sample_rate, cfg.fp16)`

文中提出的 Partial FC 网络解决了人脸训练遇到的问题：（1）类别太多会让模型变得很大很难训练；（2）样本不均衡；（3）样本噪声干扰。

# config/XXXX.py 含义

设置一个配置文件：

```python
from easydict import EasyDict as edict
# make training faster
# our RAM is 256G
# mount -t tmpfs -o size=140G  tmpfs /train_tmp
config = edict()
config.margin_list = (1.0, 0.0, 0.4)  # 用于损失函数
config.network = "mbf"  # 选择backbone
config.resume = False  # 恢复训练
config.output = None  # 训练出的模型的存放地址
config.embedding_size = 512  # 模型最后的特征维度
config.sample_rate = 1.0  # PartialFC中负样本中心参与计算的比例，没太明白作用
config.fp16 = True  # 数值精度，fp16方便计算速度
config.momentum = 0.9  # 覆盖base.py中的设置
config.weight_decay = 1e-4
config.batch_size = 128
config.lr = 0.1
config.verbose = 2000  # 多少个batch后进行一轮val并显示
config.dali = False  # 显卡数据加载方式
config.rec = "/ssd/xd/datasets/faces_umd"  # 数据集
config.num_classes = 8277  # 多少个人的id
config.num_image = 8277  # 多少张图
config.num_epoch = 20  # 训练多少轮
config.warmup_epoch = 0  # 训练策略，warmup多少轮
config.val_targets = ['lfw', 'cfp_fp', "agedb_30"]  # 验证数据集选择
```

# 训练推导

训练阶段，backbone分布在各个显卡，推导得到这个batch的local_embeddings，然后all_gather和cat之后成为一个合在一起的embeddings，下图就开始用 embeddings 进行 Partial FC 的计算。

![在这里插入图片描述](/static/img/images/04716.png)

重点在于 `logits = linear(norm_embeddings, norm_weight_activated)`。最终 labels和logits 计算损失。

![在这里插入图片描述](/static/img/images/04717.png)

# 模型导出

所有轮次训练完成之后即可自动将backbone导出到onnx。

![在这里插入图片描述](/static/img/images/04718.png)

# 如何得到一个较好的特征提取器

当然是选择更多id的人参与训练，可以选择将多个数据集组成同一个数据集。

insightface 人脸识别模型训练 RecordIO数据格式

深度学习





```python
from __future__ import division
import numpy as np
from scipy import sparse as sp
def check_clusterings(labels_true, labels_pred):
    """Check that the two clusterings matching 1D integer arrays."""
    labels_true = np.asarray(labels_true)
    labels_pred = np.asarray(labels_pred)
    # input checks
    if labels_true.ndim != 1:
        raise ValueError(
            "labels_true must be 1D: shape is %r" % (labels_true.shape,))
    if labels_pred.ndim != 1:
        raise ValueError(
            "labels_pred must be 1D: shape is %r" % (labels_pred.shape,))
    if labels_true.shape != labels_pred.shape:
        raise ValueError(
            "labels_true and labels_pred must have same size, got %d and %d"
            % (labels_true.shape[0], labels_pred.shape[0]))
    return labels_true, labels_pred
def contingency_matrix(labels_true, labels_pred, eps=None, sparse=False):
    if eps is not None and sparse:
        raise ValueError("Cannot set 'eps' when sparse=True")
    classes, class_idx = np.unique(labels_true, return_inverse=True)
    clusters, cluster_idx = np.unique(labels_pred, return_inverse=True)
    n_classes = classes.shape[0]
    n_clusters = clusters.shape[0]
    # Using coo_matrix to accelerate simple histogram calculation,
    # i.e. bins are consecutive integers
    # Currently, coo_matrix is faster than histogram2d for simple cases
    contingency = sp.coo_matrix((np.ones(class_idx.shape[0]),
                                 (class_idx, cluster_idx)),
                                shape=(n_classes, n_clusters),
                                dtype=np.int32)
    if sparse:
        contingency = contingency.tocsr()
        contingency.sum_duplicates()
    else:
        contingency = contingency.toarray()
        if eps is not None:
            # don't use += as contingency is integer
            contingency = contingency + eps
    return contingency
def fscore(labels_true, labels_pred, sparse=False):
    labels_true, labels_pred = check_clusterings(labels_true, labels_pred)
    n_samples, = labels_true.shape
    c = contingency_matrix(labels_true, labels_pred, sparse=True)
    tk = np.dot(c.data, c.data) - n_samples
    pk = np.sum(np.asarray(c.sum(axis=0)).ravel() ** 2) - n_samples
    qk = np.sum(np.asarray(c.sum(axis=1)).ravel() ** 2) - n_samples
    avg_pre = tk / pk
    avg_rec = tk / qk
    fscore = 2. * avg_pre * avg_rec / (avg_pre + avg_rec)
    return 100 * avg_pre, 100 * avg_rec, 100 * fscore
if __name__ == '__main__':
    labels_true = [0, 0, 0, 1, 1, 1]
    labels_pred = [5, 5, 3, 4, 4, 4]
    precision, recall, fscore = fscore(labels_true, labels_pred)
    print("precision:", precision, "recall:", recall, "fscore:", fscore)
    # precision: 100.0 recall: 66.66666666666666 fscore: 80.0
```

【深度学习】人脸聚类算法的评估指标程序，精准率、召回率、F1分数

![在这里插入图片描述](/static/img/images/00342.png)





# 基础

人脸检测：检测一张图中出现的人脸对象，属于目标检测任务；

人脸对齐（我这里特制仿射变换之类）：人脸在图像中可能是侧脸之类的，利用仿射变换可以把人脸纠正成正脸；

人脸识别：对比两张人脸图是否是同一个人的任务，人脸图是贴脸照，是人脸检测任务crop出来的人脸图，只含有人脸；

其他附属任务：利用人脸，分析年龄、性别、种族、是否佩戴口罩、是否佩戴眼镜；

其余介绍可以看[deepface](https://github.com/serengil/deepface)项目介绍。

由于deepface 中对齐做得不太好，整体效果显得较差。

深度学习 人脸识别 优秀开源项目 state-of-the-art SOTA deepface 项目 使用过程 教程

# 嵌套积分的上下限变化





一阶线性微分方程的通解是：

$$

y=\mathrm{e}^{-\int p(x) \mathrm{d} x}\left[\int \mathrm{e}^{\int p(x) \mathrm{d} x} \cdot q(x) \mathrm{d} x+C\right]

$$

也可以写为变限积分形式：

$$

y=\mathrm{e}^{-\int_{x_0}^x p(t) d t}\left[\int_{x_0}^x q(t) \mathrm{e}^{\int_{x_0}^t p(s) \mathrm{d} s} \mathrm{~d} t+C\right]

$$

我不理解写为变限积分形式的时候，为什么外面如果是dt的微元，里面的变限积分的下界是x0，上届就是t了。

解答：


在解释一阶线性微分方程的通解为何能写成变限积分形式时，我们需要理解积分上下限的选择和微元的含义。具体解释如下：

首先，我们从一阶线性微分方程的标准形式出发：

$$

\frac{dy}{dx} + p(x)y = q(x)

$$

通过使用积分因子的方法解这类方程，得到的通解为：

$$

y = \mathrm{e}^{-\int p(x) \, dx} \left[ \int \mathrm{e}^{\int p(x) \, dx} \cdot q(x) \, dx + C \right]

$$

为了更好地理解这个解的形式，我们可以回顾一下求解过程中的几个关键步骤：

1. **积分因子的引入**：

   设积分因子为 $\mu(x) = \mathrm{e}^{\int p(x) \, dx}$，通过将原方程乘以这个积分因子，可以将方程变为可分离变量的形式。

2. **方程两边积分**：

   将变换后的方程进行积分得到通解。

当我们使用变限积分的形式时，实际是应用了定积分的基本性质和积分因子的物理意义。

变限积分形式表示为：

$$

y = \mathrm{e}^{-\int_{x_0}^x p(t) \, dt} \left[ \int_{x_0}^x q(t) \mathrm{e}^{\int_{x_0}^t p(s) \, ds} \, dt + C \right]

$$

为了理解为何会这样写，我们可以进行如下推导和解释：

### 推导过程

考虑一般形式的解：

$$

y = \mathrm{e}^{-\int p(x) \, dx} \left[ \int \mathrm{e}^{\int p(x) \, dx} q(x) \, dx + C \right]

$$

定义 $\mu(x) = \mathrm{e}^{\int p(x) \, dx}$ 为积分因子，则我们可以重新写成：

$$

y = \frac{1}{\mu(x)} \left[ \int \mu(x) q(x) \, dx + C \right]

$$

由于 $\mu(x)$ 是 $\mathrm{e}^{\int p(x) \, dx}$，这也可以写成：

$$

y = \mathrm{e}^{-\int p(x) \, dx} \left[ \int \mathrm{e}^{\int p(x) \, dx} q(x) \, dx + C \right]

$$

现在，考虑用变限积分的形式重新表示这个解：

1. 定义从 $x_0$ 到 $x$ 的积分因子 $\mu(t) = \mathrm{e}^{\int_{x_0}^t p(s) \, ds}$，则 $\mu(x) = \mathrm{e}^{\int_{x_0}^x p(t) \, dt}$。

2. 将 $\mu(x)$ 替换回原公式中，可以得到：

   $$

   y = \frac{1}{\mu(x)} \left[ \int_{x_0}^x \mu(t) q(t) \, dt + C \right]

   $$

3. 进一步展开：

   $$

   y = \mathrm{e}^{-\int_{x_0}^x p(t) \, dt} \left[ \int_{x_0}^x \mathrm{e}^{\int_{x_0}^t p(s) \, ds} q(t) \, dt + C \right]

   $$

### 理解变限积分形式中的积分上下限

在变限积分形式中，内层积分的上限是 $t$，而下限是 $x_0$，外层积分的变量是 $t$。这是因为内层积分是对 $s$ 进行积分，且 $s$ 从 $x_0$ 到 $t$ 变化，而外层积分则是对 $t$ 进行积分，$t$ 从 $x_0$ 到 $x$ 变化。

这个形式的直观理解是：当我们从 $x_0$ 积分到 $x$ 时，每一步 $t$ 对应一个从 $x_0$ 到 $t$ 的内层积分。外层积分的变量 $t$ 决定了内层积分的上限，因此会有这种嵌套关系。


# 其他例题

我觉得这种嵌套的变换很有意思，是否还有其他例题或者例子可以给我，让我深入理解这种嵌套关系。

当然可以，嵌套积分的变换在数学分析和微分方程中是非常有用且常见的技巧。下面我给出几个例子和详细的解释，帮助你进一步理解这种嵌套关系。

### 例子 1: 利用变限积分计算定积分

设 $f(x)$ 是一个连续函数，我们要计算以下定积分：

$$

I = \int_{a}^{b} f(x) \, dx

$$

可以使用变限积分的思想，将这个定积分表示为一个累积函数的形式：

$$

F(x) = \int_{a}^{x} f(t) \, dt

$$

则 $I$ 可以写成：

$$

I = F(b) - F(a)

$$

#### 嵌套积分形式

我们可以用另一种方式表示这个定积分，将其嵌套形式化：

$$

I = \int_{a}^{b} f(x) \, dx = \int_{a}^{b} \left( \int_{a}^{x} \delta(t - x) f(t) \, dt \right) dx

$$

其中 $\delta(t - x)$ 是狄拉克δ函数，表示在 $t = x$ 处取值为 1，其余处为 0。这个表达式表明，我们可以将 $f(x)$ 看作一个从 $a$ 到 $x$ 的变限积分，然后再对 $x$ 积分。

### 例子 2: 一阶线性微分方程的解

还是从一阶线性微分方程出发：

$$

\frac{dy}{dx} + p(x)y = q(x)

$$

通过使用变限积分的形式，我们得到了通解：

$$

y = \mathrm{e}^{-\int_{x_0}^x p(t) \, dt} \left[ \int_{x_0}^x q(t) \mathrm{e}^{\int_{x_0}^t p(s) \, ds} \, dt + C \right]

$$

这里的嵌套积分关系可以通过逐步推导内外层积分的上下限变化来理解。

### 例子 3: 解一类特殊的二阶线性微分方程

考虑一个二阶线性微分方程：

$$

\frac{d^2y}{dx^2} + p(x)\frac{dy}{dx} + q(x)y = r(x)

$$

通过降阶方法，我们可以将其转化为两个一阶微分方程，设 $u = \frac{dy}{dx}$，则原方程可以写成：

$$

\frac{du}{dx} + p(x)u + q(x)y = r(x)

$$

和

$$

\frac{dy}{dx} = u

$$

将其解表示为变限积分形式：

1. 先解第一个方程，设 $v(x) = y$，则可以得到 $u$ 的解：

$$

u = \mathrm{e}^{-\int_{x_0}^x p(t) \, dt} \left[ \int_{x_0}^x r(t) \mathrm{e}^{\int_{x_0}^t p(s) \, ds} \, dt + C_1 \right]

$$

2. 再解第二个方程，得到 $y$ 的解：

$$

y = \int_{x_0}^x u(t) \, dt + C_2

$$

将 $u$ 的解代入得到 $y$ 的最终解，利用嵌套积分形式可以清晰地看到每一步的上下限变化。

### 例子 4: 格林函数法

在求解偏微分方程时，格林函数法常常涉及嵌套积分。例如，对于一个线性微分方程：

$$

L[y](x) = f(x)

$$

其解可以表示为：

$$

y(x) = \int_{a}^{b} G(x, t) f(t) \, dt

$$

其中 $G(x, t)$ 是格林函数。这里 $G(x, t)$ 本身通常是通过变限积分的形式定义的，如：

$$

G(x, t) = \int_{a}^{x} \delta(s - t) \, ds

$$

嵌套积分方法在这里用于构造解的形式，并可以通过改变积分上下限清晰地表示出解的范围和性质。

这些例子都展示了嵌套积分在不同数学问题中的应用，以及通过逐步变换积分上下限来构造解的过程。希望这些例子能帮助你更好地理解嵌套积分的变换和应用。

【数学】一阶线性微分方程的通解的变限积分形式

### 背景





小波变换是一种在信号处理中广泛应用的数学工具。与傅里叶变换不同，小波变换可以提供同时在时间和频率上的局部化信息。它通过缩放和平移基本小波函数来分析信号，适用于处理非平稳信号，如音频、图像和生物医学信号等。

### 公式

小波变换的基本公式如下：

1. **连续小波变换（CWT）**:

$$

W_\psi (a, b) = \frac{1}{\sqrt{|a|}} \int_{-\infty}^{\infty} x(t) \psi^*\left(\frac{t - b}{a}\right) dt

$$

2. **离散小波变换（DWT）**:

离散小波变换通过一系列滤波器实现，通常包括低通滤波器 $ h(n) $ 和高通滤波器 $ g(n) $。

### 示例题目

假设我们有一个简单的一维信号 $ x(t) = [1, 2, 3, 4, 5, 6, 7, 8] $，使用离散小波变换进行分析。

### 详细讲解

1. **选择小波函数**:

   常见的小波函数有Haar小波、Daubechies小波等。在这里，我们选择Haar小波作为例子。

2. **分解步骤**:

   - **第一级分解**: 

     使用低通滤波器和高通滤波器分别对信号进行滤波，并下采样，得到逼近系数和细节系数。

     - 逼近系数 (Approximation Coefficients): $ A_1 = [2.5, 6.5] $

     - 细节系数 (Detail Coefficients): $ D_1 = [-0.5, -0.5, -0.5, -0.5] $

   - **第二级分解**: 

     对第一级的逼近系数再进行一次低通和高通滤波并下采样。

     - 逼近系数 (Approximation Coefficients): $ A_2 = [4.5] $

     - 细节系数 (Detail Coefficients): $ D_2 = [-2] $

### Python代码求解
```python
import pywt
import numpy as np
# 原始信号
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
# 使用Haar小波进行离散小波变换
coeffs = pywt.wavedec(x, 'haar', level=2)
# 分解系数
A2, D2, D1 = coeffs
print("逼近系数 A2:", A2)
print("细节系数 D2:", D2)
print("细节系数 D1:", D1)
```

### 实际生活中的例子

在医学影像处理中，小波变换可以用于图像去噪和特征提取。例如，在处理脑电图（EEG）信号时，小波变换可以帮助提取特定频率成分，以检测异常活动如癫痫发作。与传统的傅里叶变换相比，小波变换能够在时频平面上提供更好的局部化信息，使得信号处理更为精细和准确。

【数学】什么是小波变换？

# 什么是傅里叶变换？什么是离散傅里叶变换？什么是拉普拉斯变换？





### 背景

傅里叶变换、离散傅里叶变换和拉普拉斯变换都是在信号处理和系统分析中非常重要的工具。

- **傅里叶变换（Fourier Transform）** 用于将时间或空间上的信号转换到频率域。通过傅里叶变换，我们可以分析信号的频率成分。

- **离散傅里叶变换（Discrete Fourier Transform, DFT）** 是傅里叶变换在离散信号上的实现。它用于将有限长的序列转换到频率域。

- **拉普拉斯变换（Laplace Transform）** 用于分析线性时不变系统。它将一个时间域的函数转换为复频域的函数，可以解决微分方程和控制系统问题。



### 公式

1. **傅里叶变换**

   连续函数 $f(t)$ 的傅里叶变换 $F(\omega)$ 定义为：

   $$

   F(\omega) = \int_{-\infty}^{\infty} f(t) e^{-i \omega t} \, dt

   $$

   反傅里叶变换为：

   $$

   f(t) = \frac{1}{2\pi} \int_{-\infty}^{\infty} F(\omega) e^{i \omega t} \, d\omega

   $$

2. **离散傅里叶变换（DFT）**

   序列 $x[n]$ 的离散傅里叶变换 $X[k]$ 定义为：

   $$

   X[k] = \sum_{n=0}^{N-1} x[n] e^{-i \frac{2\pi}{N} kn}

   $$

   反离散傅里叶变换为：

   $$

   x[n] = \frac{1}{N} \sum_{k=0}^{N-1} X[k] e^{i \frac{2\pi}{N} kn}

   $$

3. **拉普拉斯变换**

   函数 $f(t)$ 的拉普拉斯变换 $F(s)$ 定义为：

   $$

   F(s) = \int_{0}^{\infty} f(t) e^{-st} \, dt

   $$

   其中，$s$ 是复数，可以表示为 $s = \sigma + i\omega$。

### 示例题目

1. **傅里叶变换示例**

   求 $f(t) = e^{-t} u(t)$ 的傅里叶变换，其中 $u(t)$ 是单位阶跃函数。

2. **离散傅里叶变换示例**

   对序列 $x = [1, 2, 3, 4]$ 计算其离散傅里叶变换。

3. **拉普拉斯变换示例**

   求 $f(t) = e^{3t}$ 的拉普拉斯变换。

### 详细讲解

1. **傅里叶变换示例讲解**

   对于 $f(t) = e^{-t} u(t)$，傅里叶变换为：

   $$

   F(\omega) = \int_{0}^{\infty} e^{-t} e^{-i \omega t} \, dt = \int_{0}^{\infty} e^{-(1 + i \omega)t} \, dt

   $$

   这个积分是一个简单的指数积分，可以求得：

   $$

   F(\omega) = \frac{1}{1 + i \omega}

   $$

2. **离散傅里叶变换示例讲解**

   对于序列 $x = [1, 2, 3, 4]$，计算其离散傅里叶变换：

   $$

   X[k] = \sum_{n=0}^{3} x[n] e^{-i \frac{2\pi}{4} kn}

   $$

   具体计算为：

   $$

   X[0] = 1 + 2 + 3 + 4 = 10

   $$

   $$

   X[1] = 1 + 2e^{-i \frac{\pi}{2}} + 3e^{-i \pi} + 4e^{-i \frac{3\pi}{2}} = 1 - 2i - 3 + 4i = -2 + 2i

   $$

   $$

   X[2] = 1 + 2e^{-i \pi} + 3e^{-i 2\pi} + 4e^{-i 3\pi} = 1 - 2 + 3 - 4 = -2

   $$

   $$

   X[3] = 1 + 2e^{-i \frac{3\pi}{2}} + 3e^{-i 3\pi} + 4e^{-i \frac{9\pi}{2}} = 1 + 2i - 3 - 4i = -2 - 2i

   $$

3. **拉普拉斯变换示例讲解**

   对于 $f(t) = e^{3t}$，拉普拉斯变换为：

   $$

   F(s) = \int_{0}^{\infty} e^{3t} e^{-st} \, dt = \int_{0}^{\infty} e^{(3-s)t} \, dt

   $$

   这个积分是一个简单的指数积分，可以求得：

   $$

   F(s) = \frac{1}{s - 3} \quad \text{对于 } \text{Re}(s) > 3

   $$

### Python代码求解

```python
import numpy as np
# 离散傅里叶变换示例代码
x = np.array([1, 2, 3, 4])
X = np.fft.fft(x)
print("DFT of x:", X)
```

### 实际生活中的例子

1. **傅里叶变换**：在音频信号处理中，用于将声音分解成不同的频率分量。比如，用傅里叶变换来分析音乐中的不同音调和音符。

2. **离散傅里叶变换**：在图像处理中，用于图像的压缩和去噪。例如，JPEG图像压缩算法中使用了离散余弦变换（DCT），其原理类似于DFT。

3. **拉普拉斯变换**：在控制系统中，用于分析系统的稳定性和瞬态响应。例如，电路分析中的传递函数和机械系统的振动分析都使用拉普拉斯变换。

这些变换在工程和科学中的广泛应用，使得它们成为信号处理和系统分析中的基础工具。



# 什么是线性时不变系统


线性时不变系统（Linear Time-Invariant System，LTI系统）是控制理论和信号处理中的一个重要概念。它具有两个主要特性：线性性（Linearity）和时不变性（Time-Invariance）。理解这些特性有助于分析和设计许多实际系统。以下是对这两个特性的详细解释：

### 线性性（Linearity）

线性性包括两个方面：

1. **齐次性（Homogeneity）或比例性（Scaling）：**

   对于任意输入信号 $ x(t) $ 和常数 $ a $，系统的响应满足：

   $$

   x(t) \rightarrow y(t) \implies a \cdot x(t) \rightarrow a \cdot y(t)

   $$

2. **可加性（Additivity）或叠加性（Superposition）：**

   对于任意两个输入信号 $ x_1(t) $ 和 $ x_2(t) $，系统的响应满足：

   $$

   x_1(t) \rightarrow y_1(t) \quad \text{和} \quad x_2(t) \rightarrow y_2(t) \implies x_1(t) + x_2(t) \rightarrow y_1(t) + y_2(t)

   $$

如果一个系统同时满足齐次性和可加性，那么它就是线性的。

### 时不变性（Time-Invariance）

时不变性意味着系统的特性不会随时间变化。也就是说，如果一个系统在时刻 $ t $ 的输入 $ x(t) $ 产生输出 $ y(t) $，那么对输入信号的任意时间平移 $ x(t - \tau) $ 产生的输出应为相同时间平移的输出信号 $ y(t - \tau) $：

$$

x(t) \rightarrow y(t) \implies x(t - \tau) \rightarrow y(t - \tau)

$$

### LTI系统的分析方法

LTI系统的两个重要性质使得其分析和处理变得相对简单。以下是一些常用的方法：

1. **脉冲响应（Impulse Response）：**

   LTI系统可以通过其对单位脉冲信号 $ \delta(t) $ 的响应来完全描述。单位脉冲响应 $ h(t) $ 和任意输入 $ x(t) $ 的关系可以通过卷积积分表示：

   $$

   y(t) = (x * h)(t) = \int_{-\infty}^{\infty} x(\tau) h(t - \tau) d\tau

   $$

2. **频率响应（Frequency Response）：**

   LTI系统的频率响应可以通过其脉冲响应的傅里叶变换得到：

   $$

   H(\omega) = \mathcal{F}\{h(t)\}

   $$

   系统的输出信号的频谱是输入信号频谱和系统频率响应的乘积：

   $$

   Y(\omega) = X(\omega) \cdot H(\omega)

   $$

3. **拉普拉斯变换（Laplace Transform）：**

   对于连续时间系统，拉普拉斯变换可以用于求解系统的微分方程。系统的传递函数 $ H(s) $ 是脉冲响应的拉普拉斯变换：

   $$

   H(s) = \mathcal{L}\{h(t)\}

   $$

   输入输出关系可以表示为：

   $$

   Y(s) = H(s) \cdot X(s)

   $$

4. **Z变换（Z-Transform）：**

   对于离散时间系统，Z变换是类似的工具。系统的传递函数 $ H(z) $ 是脉冲响应的Z变换：

   $$

   H(z) = \mathcal{Z}\{h[n]\}

   $$

   输入输出关系可以表示为：

   $$

   Y(z) = H(z) \cdot X(z)

   $$

### 结论

线性时不变系统（LTI系统）通过其线性性和时不变性特性，使得分析和设计变得较为简单。利用脉冲响应、频率响应、拉普拉斯变换和Z变换等工具，可以有效地处理和理解这些系统。

【数学】什么是傅里叶变换？什么是离散傅里叶变换？什么是拉普拉斯变换？

## 傅里叶级数与傅里叶变换





### 背景

傅里叶级数和傅里叶变换是数学和工程领域中的重要工具，特别是在信号处理、图像处理和物理学中。傅里叶级数用于将周期函数表示为正弦和余弦函数的和，而傅里叶变换用于将任意函数表示为频率的函数。

### 公式

- **傅里叶级数**：给定周期函数 $f(t)$，其傅里叶级数表示为：

  $$

  f(t) = a_0 + \sum_{n=1}^{\infty} \left( a_n \cos \left( \frac{2\pi n t}{T} \right) + b_n \sin \left( \frac{2\pi n t}{T} \right) \right)

  $$

  其中：

  $$

  a_0 = \frac{1}{T} \int_{0}^{T} f(t) \, dt

  $$

  $$

  a_n = \frac{2}{T} \int_{0}^{T} f(t) \cos \left( \frac{2\pi n t}{T} \right) \, dt

  $$

  $$

  b_n = \frac{2}{T} \int_{0}^{T} f(t) \sin \left( \frac{2\pi n t}{T} \right) \, dt

  $$

- **傅里叶变换**：给定函数 $f(t)$，其傅里叶变换表示为：

  $$

  \mathcal{F}(f)(\omega) = F(\omega) = \int_{-\infty}^{\infty} f(t) e^{-i\omega t} \, dt

  $$

  其逆变换为：

  $$

  f(t) = \frac{1}{2\pi} \int_{-\infty}^{\infty} F(\omega) e^{i\omega t} \, d\omega

  $$

### 示例题目

**题目**：求周期函数 $f(t) = t$ 在区间 $[-\pi, \pi]$ 上的傅里叶级数表示。

### 详细讲解

1. **计算 $a_0$**：

   $$

   a_0 = \frac{1}{2\pi} \int_{-\pi}^{\pi} t \, dt = 0

   $$

2. **计算 $a_n$**：

   $$

   a_n = \frac{1}{\pi} \int_{-{\pi}}^{\pi} t \cos(nt) \, dt = 0

   $$

3. **计算 $b_n$**：

   $$

   b_n = \frac{1}{\pi} \int_{-\pi}^{\pi} t \sin(nt) \, dt = \frac{2(-1)^{n+1}}{n}

   $$

因此，傅里叶级数为：

$$

f(t) = \sum_{n=1}^{\infty} \frac{2(-1)^{n+1}}{n} \sin(nt)

$$

### Python代码求解
```python
import numpy as np
import matplotlib.pyplot as plt
# 定义周期函数
def f(t):
    return t
# 定义傅里叶级数展开的项数
N = 10
# 定义傅里叶级数
def fourier_series(t, N):
    result = np.zeros_like(t)
    for n in range(1, N + 1):
        result += (2 * (-1)**(n + 1) / n) * np.sin(n * t)
    return result
# 生成时间点
t = np.linspace(-np.pi, np.pi, 1000)
# 计算傅里叶级数近似
f_approx = fourier_series(t, N)
# 绘图
plt.plot(t, f(t), label='Original function')
plt.plot(t, f_approx, label='Fourier series approximation')
plt.legend()
plt.xlabel('t')
plt.ylabel('f(t)')
plt.title('Fourier Series Approximation')
plt.grid(True)
plt.show()
```

### 实际生活中的例子

在实际生活中，傅里叶变换用于信号处理，例如将音频信号转换为频谱，以分析不同频率的声音成分。傅里叶级数则在分析周期信号（如振动和电波）时非常有用。通过将复杂的周期信号分解为简单的正弦和余弦分量，可以更容易地理解和处理这些信号。


### 一个python例子

```dart
import numpy as np
import matplotlib.pyplot as plt
# 定义周期函数的频率和系数
T = 2 * np.pi  # 周期
N = 5  # 傅里叶级数的项数
# 定义时间范围
t = np.linspace(-np.pi, np.pi, 1000)
# 定义傅里叶级数的各项
def fourier_series_terms(t, N):
    terms = []
    for n in range(1, N + 1):
        term = (2 * (-1)**(n + 1) / n) * np.sin(n * t)
        terms.append(term)
    return terms
# 计算傅里叶级数的各项
terms = fourier_series_terms(t, N)
# 绘图
plt.figure(figsize=(12, 8))
# 原始函数
plt.subplot(2, 1, 1)
plt.plot(t, t, label='Original function')
plt.title('Original Function')
plt.xlabel('t')
plt.ylabel('f(t)')
plt.legend()
plt.grid(True)
# 各项的和
plt.subplot(2, 1, 2)
sum_terms = np.zeros_like(t)
for i, term in enumerate(terms):
    sum_terms += term
    plt.plot(t, sum_terms, label=f'Term {i+1}')
plt.title('Sum of Fourier Series Terms')
plt.xlabel('t')
plt.ylabel('Sum of terms')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()
```

![在这里插入图片描述](/static/img/images/02951.png)