# pattern-recognition-homework

**Repository Path**: loxs/pattern-recognition-homework

## Basic Information

- **Project Name**: pattern-recognition-homework
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2021-11-05
- **Last Updated**: 2022-11-15

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 模式识别课程作业
## 环境配置
python 3.8
```bash
pip install numpy
pip install scikit-learn
pip install scikit-opt
pip install pandas
pip install matplotlib
pip install joblib
pip install struct
pip install glob
pip3 install torch torchvision torchaudio # 附加题需要库
```

## 单变量搜索法测试代码

修改main.py为[import 部分保留，下同不再累述]
```python
one = one_variable()
feature = one.get_feature(特征数)
model = KNN(feature)
model.train()
model.test()
```
运行：`python main.py`

运行结果

| 特征数 | 训练时间  | 训练集准确率 | 训练集测试时间 | 测试集准确率  | 测试集测试时间 |
|-----|-------|--------|---------|---------|---------|
| 10  | 0.32s | 51.28% | 1.35s   | 29.25%  | 0.19s   |
| 50  | 0.84s | 94.39% | 50.44s  | 85.64%  | 7.26s   |
| 100 | 1.06s | 98.52% | 133.20s | 95.00%; | 17.82s  |
| 300 | 2.04s | 99.20% | 393.98s | 97.89%  | 49.76s  |

## 前向搜索法

修改main.py为
```python
forward_search()
```
运行`python main.py`

运行结果

| k  | time   | best_feature | valid_acc | test_acc | test_time |
|----|--------|--------|-----------|----------|-----------|
| 0  | 112.45 | 386    | 0.04      | 0.02     | 0.07      |
| 1  | 61.06  | 382    | 0.09      | 0.05     | 0.04      |
| 2  | 52.24  | 306    | 0.17      | 0.11     | 0.04      |
| 3  | 52.87  | 432    | 0.33      | 0.22     | 0.04      |
| 4  | 55.78  | 300    | 0.48      | 0.31     | 0.06      |
| 5  | 59.39  | 232    | 0.59      | 0.41     | 0.09      |
| 6  | 63.16  | 240    | 0.7       | 0.48     | 0.14      |
| 7  | 86.36  | 266    | 0.77      | 0.56     | 0.2       |
| 8  | 69.95  | 414    | 0.84      | 0.62     | 0.29      |
| 9  | 75.38  | 428    | 0.87      | 0.67     | 0.38      |
| 10 | 79.59  | 216    | 0.89      | 0.71     | 0.47      |
| 11 | 104.92 | 204    | 0.91      | 0.74     | 0.61      |
| 12 | 109.09 | 192    | 0.93      | 0.77     | 0.76      |
| 13 | 117.06 | 278    | 0.94      | 0.8      | 0.92      |
| 14 | 113.08 | 168    | 0.95      | 0.8      | 1.01      |
| 15 | 126.2  | 31     | 0.96      | 0.79     | 1.11      |
| 16 | 126.57 | 48     | 0.96      | 0.81     | 1.29      |
| 17 | 133.83 | 314    | 0.97      | 0.83     | 1.47      |
| 18 | 140.29 | 22     | 0.97      | 0.83     | 1.56      |
| 19 | 158.57 | 82     | 0.97      | 0.84     | 1.81      |
| 20 | 164.08 | 292    | 0.98      | 0.85     | 1.86      |
| 21 | 167.1  | 0      | 0.98      | 0.84     | 2.35      |
| 22 | 407.94 | 7      | 0.98      | 0.85     | 2.48      |
| 23 | 413.41 | 197    | 0.98      | 0.85     | 2.89      |
| 24 | 510.61 | 90     | 0.98      | 0.85     | 3.05      |
| 25 | 515.66 | 21     | 0.98      | 0.85     | 3.13      |
| 26 | 524.08 | 130    | 0.98      | 0.85     | 3.34      |
| 27 | 521.45 | 241    | 0.99      | 0.86     | 3.65      |
| 28 | 535.51 | 12     | 0.99      | 0.86     | 3.85      |
| 29 | 537.39 | 8      | 0.99      | 0.86     | 4.05      |
| 30 | 544.33 | 16     | 0.99      | 0.87     | 4.28      |
| 31 | 650.97 | 55     | 0.99      | 0.86     | 4.83      |


## 改进拉斯维加斯算法

修改main.py为
```python
improve_lvw()
```
运行：`python main.py`

训练结果
| k  | time   | valid_acc | test_acc | test_time |
|----|--------|-----------|----------|-----------|
| 0  | 274.35 | 0.94      | 0.88     | 7.73      |
| 1  | 262.2  | 0.95      | 0.9      | 6.31      |
| 2  | 251.11 | 0.95      | 0.9      | 6.59      |
| 3  | 239.96 | 0.96      | 0.9      | 6.95      |
| 4  | 248.18 | 0.96      | 0.9      | 6.31      |
| 5  | 227.5  | 0.96      | 0.92     | 6.78      |
| 6  | 232.83 | 0.96      | 0.89     | 5.49      |
| 7  | 214.57 | 0.96      | 0.89     | 5.47      |
| 8  | 206.7  | 0.96      | 0.89     | 5.86      |
| 9  | 202.26 | 0.96      | 0.89     | 5.72      |
| 10 | 198.13 | 0.96      | 0.89     | 5.64      |
| 11 | 197.67 | 0.96      | 0.9      | 5.89      |
| 12 | 196.01 | 0.96      | 0.9      | 5.89      |
| 13 | 212.11 | 0.96      | 0.9      | 5.77      |

## PCA+KNN
修改main.py为
```python
model = PCAKNN(n_components = 特征数)
model.train()
model.test()
```
运行：`python main.py`

运行结果

| 特征数 | 训练时间  | 训练集准确率 | 训练集测试时间 | 测试集准确率 | 测试集测试时间 |
|-----|-------|--------|---------|--------|---------|
| 10  | 1.05s | 94.70% | 2.01s   | 85.31% | 0.35s   |
| 50  | 1.55s | 99.30% | 39.16s  | 97.39% | 7.45s   |
| 100 | 1.91s | 99.30% | 105.9s  | 97.64% | 16.84s  |
| 300 | 4.31s | 99.50% | 358.56s | 97.75% | 51.52s  |

## LDA+KNN
修改main.py为
```python
model = LDAKNN(n_components = 特征数)
model.train()
model.test()
```
运行：`python main.py`

运行结果

| 特征数 | 训练时间  | 训练集准确率 | 训练集测试时间 | 测试集准确率 | 测试集测试时间 |
|-----|-------|--------|---------|--------|---------|
| 10  | 1.78s | 96.80% | 1.72s   | 90.25% | 0.31s   |
| 50  | 1.85s | 99.40% | 39.32s  | 98.17% | 7.02s   |
| 100 | 1.95s | 99.60% | 128.34s | 98.22% | 19.39s  |
| 200 | 2.13s | 99.60% | 308.96s | 97.64% | 49.76s  |

## PCA+PROB
这个是另外实现的一种算法没有在报告中提及，利用了经验分布来进行分类。

修改main.py为
```python
model = PCAPROB()
model.train()
model.test()
```
运行：`python main.py`

## 3层神经网络代码

修改main.py为
```python
model = Model(hidden_length = 隐藏数)
model.train()
model.test()
```
运行：`python main.py`

运行结果：

| 隐藏数 | 训练时间    | 训练集准确率 | 训练集测试时间 | 测试集准确率  | 测试集测试时间 | 验证集准确率 |
|-----|---------|--------|---------|---------|---------|--------|
| 50  | 37.71s  | 99.92% | 0.18s   | 96.69%  | 0.03s   | 99.92% |
| 100 | 91.54s  | 99.91% | 0.24s   | 97.56%  | 0.04s   | 99.10% |
| 200 | 95.65s  | 99.92% | 0.32s   | 97.61%  | 0.05s   | 99.27% |
| 400 | 245.73s | 99.75% | 0.48s]  | 97.11s% | 0.08s   | 98.92% |

## 附加题

如文档中所述

修改main.py为
```python
from additional import select
```
修改 `additional/select.py`16行`width = 1`为想要的图像宽，完成第一个模型。

运行：`python main.py`

修改main.py为
```python
# from additional import select
from additional import CNNModel
```
修改 `additional/CNNModel.py`12行`width = 1`为想要的图像宽度。

运行：`python main.py`

结果如下：

| 宽度      | 顺序损失   | GA损失   | 特征重构时间（s） | 未重构test准确率 | 未重构valid准确率 | 重构test准确率 | 重构valid准确率 |
|---------|--------|--------|-----------|------------|-------------|-----------|------------|
| 1       | 10     | 8.26   | 62.56     | 0.94       | 0.972       | 0.95      | 0.983      |
| 2       | 9.68   | 9.09   | 47.19     | 0.92       | 0.97        | 0.9       | 0.956      |
| 4       | 8.55   | 9.34   | 78.16     | 0.91       | 0.966       | 0.88      | 0.944      |
| 5       | 10.88  | 9.34   | 78.67     | 0.86       | 0.928       | 0.86      | 0.936      |
| 8       | 9.3    | 9.55   | 82.74     | 0.84       | 0.927       | 0.85      | 0.930      |
| 10      | 10.18  | 9.47   | 77.32     | 0.85       | 0.927       | 0.85      | 0.928      |
| 11      | 10.77  | 9.54   | 75.47     | 0.83       | 0.903       | 0.83      | 0.926      |
| 20      | 9.44   | 9.67   | 91.06     | 0.89       | 0.942       | 0.85      | 0.912      |
| 22      | 10.18  | 9.7    | 86.22     | 0.87       | 0.941       | 0.82      | 0.905      |
| 40      | 9.78   | 9.85   | 95.34     | 0.84       | 0.905       | 0.84      | 0.92       |
| 44      | 9.79   | 9.74   | 80.23     | 0.86       | 0.918       | 0.83      | 0.91       |
| 55      | 10.67  | 9.58   | 78.93     | 0.87       | 0.93        | 0.85      | 0.927      |
| 88      | 9.79   | 9.54   | 73.67     | 0.87       | 0.935       | 0.87      | 0.93       |
| 110     | 10.09  | 9.61   | 72.22     | 0.89       | 0.943       | 0.89      | 0.95       |
| 220     | 9.99   | 9.56   | 75.41     | 0.91       | 0.957       | 0.92      | 0.963      |
| 440     | 10     | 8.36   | 51.79     | 0.93       | 0.982       | 0.94      | 0.98       |
| average | 9.943  | 9.388  | 75.436    | 0.880      | 0.940       | 0.871     | 0.938      |

用这种方法是基于一个假设：图像是比较光滑的，噪点没有那么多。

顺序损失：直接将440维度的特征reshape到指定长宽的光滑度损失（相邻像素差绝对值和）

GA损失：直接将440维度的特征，经过遗传算法然后reshape到指定长宽的光滑度损失（相邻像素差绝对值和）

特征重构时间：遗传算法(GA)训练时间

未重构准确率是指直接将440维度的特征reshape到指定长宽，输入到CNN模型当中得到的准确率

重构准确率是指先将440维度特征通过遗传算法得到的特征排列方式进行排列，然后reshape到指定长宽，输入到CNN模型当中得到的准确率。