feat:add cifar10mini just 1000 nodes

.gitignore

@@ -3,5 +3,5 @@ _pycache_
 model-CIFAR10
 
 #cifar10
-cifar-10-batches-py
-cifar-10-python.tar.gz
+**/cifar-10-batches-py/
+**/cifar-10-python.tar.gz

ResNet-CIFAR10/Classification-mini/dataset/index.json

@@ -0,0 +1,1006 @@
+{
+    "train": [
+        0,
+        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,
+        28,
+        29,
+        30,
+        31,
+        32,
+        33,
+        34,
+        35,
+        36,
+        37,
+        38,
+        39,
+        40,
+        41,
+        42,
+        43,
+        44,
+        45,
+        46,
+        47,
+        48,
+        49,
+        50,
+        51,
+        52,
+        53,
+        54,
+        55,
+        56,
+        57,
+        58,
+        59,
+        60,
+        61,
+        62,
+        63,
+        64,
+        65,
+        66,
+        67,
+        68,
+        69,
+        70,
+        71,
+        72,
+        73,
+        74,
+        75,
+        76,
+        77,
+        78,
+        79,
+        80,
+        81,
+        82,
+        83,
+        84,
+        85,
+        86,
+        87,
+        88,
+        89,
+        90,
+        91,
+        92,
+        93,
+        94,
+        95,
+        96,
+        97,
+        98,
+        99,
+        100,
+        101,
+        102,
+        103,
+        104,
+        105,
+        106,
+        107,
+        108,
+        109,
+        110,
+        111,
+        112,
+        113,
+        114,
+        115,
+        116,
+        117,
+        118,
+        119,
+        120,
+        121,
+        122,
+        123,
+        124,
+        125,
+        126,
+        127,
+        128,
+        129,
+        130,
+        131,
+        132,
+        133,
+        134,
+        135,
+        136,
+        137,
+        138,
+        139,
+        140,
+        141,
+        142,
+        143,
+        144,
+        145,
+        146,
+        147,
+        148,
+        149,
+        150,
+        151,
+        152,
+        153,
+        154,
+        155,
+        156,
+        157,
+        158,
+        159,
+        160,
+        161,
+        162,
+        163,
+        164,
+        165,
+        166,
+        167,
+        168,
+        169,
+        170,
+        171,
+        172,
+        173,
+        174,
+        175,
+        176,
+        177,
+        178,
+        179,
+        180,
+        181,
+        182,
+        183,
+        184,
+        185,
+        186,
+        187,
+        188,
+        189,
+        190,
+        191,
+        192,
+        193,
+        194,
+        195,
+        196,
+        197,
+        198,
+        199,
+        200,
+        201,
+        202,
+        203,
+        204,
+        205,
+        206,
+        207,
+        208,
+        209,
+        210,
+        211,
+        212,
+        213,
+        214,
+        215,
+        216,
+        217,
+        218,
+        219,
+        220,
+        221,
+        222,
+        223,
+        224,
+        225,
+        226,
+        227,
+        228,
+        229,
+        230,
+        231,
+        232,
+        233,
+        234,
+        235,
+        236,
+        237,
+        238,
+        239,
+        240,
+        241,
+        242,
+        243,
+        244,
+        245,
+        246,
+        247,
+        248,
+        249,
+        250,
+        251,
+        252,
+        253,
+        254,
+        255,
+        256,
+        257,
+        258,
+        259,
+        260,
+        261,
+        262,
+        263,
+        264,
+        265,
+        266,
+        267,
+        268,
+        269,
+        270,
+        271,
+        272,
+        273,
+        274,
+        275,
+        276,
+        277,
+        278,
+        279,
+        280,
+        281,
+        282,
+        283,
+        284,
+        285,
+        286,
+        287,
+        288,
+        289,
+        290,
+        291,
+        292,
+        293,
+        294,
+        295,
+        296,
+        297,
+        298,
+        299,
+        300,
+        301,
+        302,
+        303,
+        304,
+        305,
+        306,
+        307,
+        308,
+        309,
+        310,
+        311,
+        312,
+        313,
+        314,
+        315,
+        316,
+        317,
+        318,
+        319,
+        320,
+        321,
+        322,
+        323,
+        324,
+        325,
+        326,
+        327,
+        328,
+        329,
+        330,
+        331,
+        332,
+        333,
+        334,
+        335,
+        336,
+        337,
+        338,
+        339,
+        340,
+        341,
+        342,
+        343,
+        344,
+        345,
+        346,
+        347,
+        348,
+        349,
+        350,
+        351,
+        352,
+        353,
+        354,
+        355,
+        356,
+        357,
+        358,
+        359,
+        360,
+        361,
+        362,
+        363,
+        364,
+        365,
+        366,
+        367,
+        368,
+        369,
+        370,
+        371,
+        372,
+        373,
+        374,
+        375,
+        376,
+        377,
+        378,
+        379,
+        380,
+        381,
+        382,
+        383,
+        384,
+        385,
+        386,
+        387,
+        388,
+        389,
+        390,
+        391,
+        392,
+        393,
+        394,
+        395,
+        396,
+        397,
+        398,
+        399,
+        400,
+        401,
+        402,
+        403,
+        404,
+        405,
+        406,
+        407,
+        408,
+        409,
+        410,
+        411,
+        412,
+        413,
+        414,
+        415,
+        416,
+        417,
+        418,
+        419,
+        420,
+        421,
+        422,
+        423,
+        424,
+        425,
+        426,
+        427,
+        428,
+        429,
+        430,
+        431,
+        432,
+        433,
+        434,
+        435,
+        436,
+        437,
+        438,
+        439,
+        440,
+        441,
+        442,
+        443,
+        444,
+        445,
+        446,
+        447,
+        448,
+        449,
+        450,
+        451,
+        452,
+        453,
+        454,
+        455,
+        456,
+        457,
+        458,
+        459,
+        460,
+        461,
+        462,
+        463,
+        464,
+        465,
+        466,
+        467,
+        468,
+        469,
+        470,
+        471,
+        472,
+        473,
+        474,
+        475,
+        476,
+        477,
+        478,
+        479,
+        480,
+        481,
+        482,
+        483,
+        484,
+        485,
+        486,
+        487,
+        488,
+        489,
+        490,
+        491,
+        492,
+        493,
+        494,
+        495,
+        496,
+        497,
+        498,
+        499,
+        500,
+        501,
+        502,
+        503,
+        504,
+        505,
+        506,
+        507,
+        508,
+        509,
+        510,
+        511,
+        512,
+        513,
+        514,
+        515,
+        516,
+        517,
+        518,
+        519,
+        520,
+        521,
+        522,
+        523,
+        524,
+        525,
+        526,
+        527,
+        528,
+        529,
+        530,
+        531,
+        532,
+        533,
+        534,
+        535,
+        536,
+        537,
+        538,
+        539,
+        540,
+        541,
+        542,
+        543,
+        544,
+        545,
+        546,
+        547,
+        548,
+        549,
+        550,
+        551,
+        552,
+        553,
+        554,
+        555,
+        556,
+        557,
+        558,
+        559,
+        560,
+        561,
+        562,
+        563,
+        564,
+        565,
+        566,
+        567,
+        568,
+        569,
+        570,
+        571,
+        572,
+        573,
+        574,
+        575,
+        576,
+        577,
+        578,
+        579,
+        580,
+        581,
+        582,
+        583,
+        584,
+        585,
+        586,
+        587,
+        588,
+        589,
+        590,
+        591,
+        592,
+        593,
+        594,
+        595,
+        596,
+        597,
+        598,
+        599,
+        600,
+        601,
+        602,
+        603,
+        604,
+        605,
+        606,
+        607,
+        608,
+        609,
+        610,
+        611,
+        612,
+        613,
+        614,
+        615,
+        616,
+        617,
+        618,
+        619,
+        620,
+        621,
+        622,
+        623,
+        624,
+        625,
+        626,
+        627,
+        628,
+        629,
+        630,
+        631,
+        632,
+        633,
+        634,
+        635,
+        636,
+        637,
+        638,
+        639,
+        640,
+        641,
+        642,
+        643,
+        644,
+        645,
+        646,
+        647,
+        648,
+        649,
+        650,
+        651,
+        652,
+        653,
+        654,
+        655,
+        656,
+        657,
+        658,
+        659,
+        660,
+        661,
+        662,
+        663,
+        664,
+        665,
+        666,
+        667,
+        668,
+        669,
+        670,
+        671,
+        672,
+        673,
+        674,
+        675,
+        676,
+        677,
+        678,
+        679,
+        680,
+        681,
+        682,
+        683,
+        684,
+        685,
+        686,
+        687,
+        688,
+        689,
+        690,
+        691,
+        692,
+        693,
+        694,
+        695,
+        696,
+        697,
+        698,
+        699,
+        700,
+        701,
+        702,
+        703,
+        704,
+        705,
+        706,
+        707,
+        708,
+        709,
+        710,
+        711,
+        712,
+        713,
+        714,
+        715,
+        716,
+        717,
+        718,
+        719,
+        720,
+        721,
+        722,
+        723,
+        724,
+        725,
+        726,
+        727,
+        728,
+        729,
+        730,
+        731,
+        732,
+        733,
+        734,
+        735,
+        736,
+        737,
+        738,
+        739,
+        740,
+        741,
+        742,
+        743,
+        744,
+        745,
+        746,
+        747,
+        748,
+        749,
+        750,
+        751,
+        752,
+        753,
+        754,
+        755,
+        756,
+        757,
+        758,
+        759,
+        760,
+        761,
+        762,
+        763,
+        764,
+        765,
+        766,
+        767,
+        768,
+        769,
+        770,
+        771,
+        772,
+        773,
+        774,
+        775,
+        776,
+        777,
+        778,
+        779,
+        780,
+        781,
+        782,
+        783,
+        784,
+        785,
+        786,
+        787,
+        788,
+        789,
+        790,
+        791,
+        792,
+        793,
+        794,
+        795,
+        796,
+        797,
+        798,
+        799,
+        800,
+        801,
+        802,
+        803,
+        804,
+        805,
+        806,
+        807,
+        808,
+        809,
+        810,
+        811,
+        812,
+        813,
+        814,
+        815,
+        816,
+        817,
+        818,
+        819,
+        820,
+        821,
+        822,
+        823,
+        824,
+        825,
+        826,
+        827,
+        828,
+        829,
+        830,
+        831,
+        832,
+        833,
+        834,
+        835,
+        836,
+        837,
+        838,
+        839,
+        840,
+        841,
+        842,
+        843,
+        844,
+        845,
+        846,
+        847,
+        848,
+        849,
+        850,
+        851,
+        852,
+        853,
+        854,
+        855,
+        856,
+        857,
+        858,
+        859,
+        860,
+        861,
+        862,
+        863,
+        864,
+        865,
+        866,
+        867,
+        868,
+        869,
+        870,
+        871,
+        872,
+        873,
+        874,
+        875,
+        876,
+        877,
+        878,
+        879,
+        880,
+        881,
+        882,
+        883,
+        884,
+        885,
+        886,
+        887,
+        888,
+        889,
+        890,
+        891,
+        892,
+        893,
+        894,
+        895,
+        896,
+        897,
+        898,
+        899,
+        900,
+        901,
+        902,
+        903,
+        904,
+        905,
+        906,
+        907,
+        908,
+        909,
+        910,
+        911,
+        912,
+        913,
+        914,
+        915,
+        916,
+        917,
+        918,
+        919,
+        920,
+        921,
+        922,
+        923,
+        924,
+        925,
+        926,
+        927,
+        928,
+        929,
+        930,
+        931,
+        932,
+        933,
+        934,
+        935,
+        936,
+        937,
+        938,
+        939,
+        940,
+        941,
+        942,
+        943,
+        944,
+        945,
+        946,
+        947,
+        948,
+        949,
+        950,
+        951,
+        952,
+        953,
+        954,
+        955,
+        956,
+        957,
+        958,
+        959,
+        960,
+        961,
+        962,
+        963,
+        964,
+        965,
+        966,
+        967,
+        968,
+        969,
+        970,
+        971,
+        972,
+        973,
+        974,
+        975,
+        976,
+        977,
+        978,
+        979,
+        980,
+        981,
+        982,
+        983,
+        984,
+        985,
+        986,
+        987,
+        988,
+        989,
+        990,
+        991,
+        992,
+        993,
+        994,
+        995,
+        996,
+        997,
+        998,
+        999
+    ],
+    "test": [],
+    "validation": []
+}

ResNet-CIFAR10/Classification-mini/dataset/info.json

@@ -0,0 +1,4 @@
+{
+    "model": "ResNet18",
+    "classes":["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]
+}

ResNet-CIFAR10/Classification-mini/dataset/labels.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a206deac3a30252ca2263d264fe73e6d244cf744aa7d7648ec1ecb2f40365c83
+size 8128

ResNet-CIFAR10/Classification-mini/epochs/epoch_1/embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53a846d7369254a97a6d25b961c270aba6eb1f2412b965abbdac99f947bdef20
+size 2048128

ResNet-CIFAR10/Classification-mini/epochs/epoch_1/model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:632e71f73fd7e91427ae7751fef67868bff2121b7dfb8eb725920b986f616557
+size 44769410

ResNet-CIFAR10/Classification-mini/epochs/epoch_1/predictions.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:684dd330d3801670400ae7d55ea86025da71abefc71bc24dad3dfb6acff14c1a
+size 40128

ResNet-CIFAR10/Classification-mini/epochs/epoch_2/embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:546e774f16d8c03b5031660f33252398485e5a7745893bb5d76d692fd002a94e
+size 2048128

ResNet-CIFAR10/Classification-mini/epochs/epoch_2/model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b35d6b4f69c3222a40639005b29af06c8452a47b526ac429c7e4d6b1a78469db
+size 44769410

ResNet-CIFAR10/Classification-mini/epochs/epoch_2/predictions.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6d02b608c6460d2e05148c0425a63813fe2e7bb0b5f9e191a1040c9e38748cc
+size 40128

ResNet-CIFAR10/Classification-mini/epochs/epoch_3/embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f90aebde34e956f5ebf243c048eff51cf2545e0dc2566821c858f000373fa64
+size 2048128

ResNet-CIFAR10/Classification-mini/epochs/epoch_3/model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2681f986928109f1e7d52633b206c310155ca5f7692cd0bba22826c59082fc9a
+size 44769410

ResNet-CIFAR10/Classification-mini/epochs/epoch_3/predictions.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c5d782cd395927cc26d438b9512d866d2b25ecd60d3e9357bc20c295dc7db96b
+size 40128

ResNet-CIFAR10/Classification-mini/epochs/layer_info.json

@@ -0,0 +1 @@
+{"layer_id": "avg_pool", "dim": 512}

ResNet-CIFAR10/Classification-mini/epochs/train.log

@@ -0,0 +1,6 @@
+2025-06-02 13:08:33,621 - train - INFO - 开始训练 ResNet18
+2025-06-02 13:08:33,622 - train - INFO - 总轮数: 3, 学习率: 0.1, 设备: cuda:0
+2025-06-02 13:08:47,699 - train - INFO - Epoch: 1 | Train Loss: 1.928 | Train Acc: 30.18% | Test Loss: 1.567 | Test Acc: 41.58%
+2025-06-02 13:09:02,228 - train - INFO - Epoch: 2 | Train Loss: 1.351 | Train Acc: 50.83% | Test Loss: 1.492 | Test Acc: 51.06%
+2025-06-02 13:09:16,149 - train - INFO - Epoch: 3 | Train Loss: 1.055 | Train Acc: 62.12% | Test Loss: 1.285 | Test Acc: 57.01%
+2025-06-02 13:09:16,746 - train - INFO - 训练完成!

ResNet-CIFAR10/Classification-mini/readme.md

@@ -0,0 +1,54 @@
+# ResNet-CIFAR10 训练与特征提取
+
+这个项目实现了ResNet模型在CIFAR10数据集上的训练，并集成了特征提取和可视化所需的功能。
+
+## time_travel_saver数据提取器
+```python
+     #保存可视化训练过程所需要的文件
+        if (epoch + 1) % interval  == 0 or (epoch == 0): 
+            # 创建一个专门用于收集embedding的顺序dataloader
+            ordered_trainloader = torch.utils.data.DataLoader(
+                trainloader.dataset,
+                batch_size=trainloader.batch_size,
+                shuffle=False,
+                num_workers=trainloader.num_workers
+            )
+            epoch_save_dir = os.path.join(save_dir, f'epoch_{epoch+1}') #epoch保存路径
+            save_model = time_travel_saver(model, ordered_trainloader, device, epoch_save_dir, model_name, 
+                         show=True, layer_name='avg_pool', auto_save_embedding=True)
+                        #show:是否显示模型的维度信息
+                        #layer_name:选择要提取特征的层,如果为None,则提取符合维度范围的层
+                        #auto_save_embedding:是否自动保存特征向量 must be True
+            save_model.save_checkpoint_embeddings_predictions() #保存模型权重、特征向量和预测结果到epoch_x
+            if epoch == 0:
+                save_model.save_lables_index(path = "../dataset") #保存标签和索引到dataset
+```
+
+
+## 项目结构
+
+- `./scripts/train.yaml`：训练配置文件，包含批次大小、学习率、GPU设置等参数
+- `./scripts/train.py`：训练脚本，执行模型训练并自动收集特征数据
+- `./model/`：保存训练好的模型权重
+- `./epochs/`：保存训练过程中的高维特征向量、预测结果等数据
+
+## 使用方法
+
+1. 配置 `train.yaml` 文件设置训练参数
+2. 执行训练脚本：
+   ```
+   python train.py
+   ```
+3. 训练完成后，可以在以下位置找到相关数据：
+   - 模型权重：`./epochs/epoch_{n}/model.pth`
+   - 特征向量：`./epochs/epoch_{n}/embeddings.npy`
+   - 预测结果：`./epochs/epoch_{n}/predictions.npy`
+   - 标签数据：`./dataset/labels.npy`
+   - 数据索引：`./dataset/index.json`
+
+## 数据格式
+
+- `embeddings.npy`：形状为 [n_samples, feature_dim] 的特征向量
+- `predictions.npy`：形状为 [n_samples, n_classes] 的预测概率
+- `labels.npy`：形状为 [n_samples] 的真实标签
+- `index.json`：包含训练集、测试集和验证集的索引信息

ResNet-CIFAR10/Classification-mini/scripts/dataset_utils.py

@@ -0,0 +1,59 @@
+import torch
+import torchvision
+import torchvision.transforms as transforms
+import os
+
+#加载数据集
+
+def get_cifar10_dataloaders(batch_size=128, num_workers=2, local_dataset_path=None, shuffle=False):
+    """获取CIFAR10数据集的数据加载器
+    
+    Args:
+        batch_size: 批次大小
+        num_workers: 数据加载的工作进程数
+        local_dataset_path: 本地数据集路径，如果提供则使用本地数据集，否则下载
+        
+    Returns:
+        trainloader: 训练数据加载器
+        testloader: 测试数据加载器
+    """
+    # 数据预处理
+    transform_train = transforms.Compose([
+        transforms.RandomCrop(32, padding=4),
+        transforms.RandomHorizontalFlip(),
+        transforms.ToTensor(),
+        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+    ])
+
+    transform_test = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+    ])
+
+    # 设置数据集路径
+    if local_dataset_path:
+        print(f"使用本地数据集: {local_dataset_path}")
+        # 检查数据集路径是否有数据集，没有的话则下载
+        cifar_path = os.path.join(local_dataset_path, 'cifar-10-batches-py')
+        download = not os.path.exists(cifar_path) or not os.listdir(cifar_path)
+        dataset_path = local_dataset_path
+    else:
+        print("未指定本地数据集路径，将下载数据集")
+        download = True
+        dataset_path = '../dataset'
+
+    # 创建数据集路径
+    if not os.path.exists(dataset_path):
+        os.makedirs(dataset_path)
+
+    trainset = torchvision.datasets.CIFAR10(
+        root=dataset_path, train=True, download=download, transform=transform_train)
+    trainloader = torch.utils.data.DataLoader(
+        trainset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)
+
+    testset = torchvision.datasets.CIFAR10(
+        root=dataset_path, train=False, download=download, transform=transform_test)
+    testloader = torch.utils.data.DataLoader(
+        testset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)
+
+    return trainloader, testloader

ResNet-CIFAR10/Classification-mini/scripts/get_raw_data.py

@@ -0,0 +1,82 @@
+#读取数据集，在../dataset/raw_data下按照数据集的完整排序,1.png,2.png,3.png,...保存
+
+import os
+import numpy as np
+import torchvision
+import torchvision.transforms as transforms
+from PIL import Image
+from tqdm import tqdm
+
+def unpickle(file):
+    """读取CIFAR-10数据文件"""
+    import pickle
+    with open(file, 'rb') as fo:
+        dict = pickle.load(fo, encoding='bytes')
+    return dict
+
+def save_images_from_cifar10(dataset_path, save_dir):
+    """从CIFAR-10数据集中保存图像
+    
+    Args:
+        dataset_path: CIFAR-10数据集路径
+        save_dir: 图像保存路径
+    """
+    # 创建保存目录
+    os.makedirs(save_dir, exist_ok=True)
+    
+    # 获取训练集数据
+    train_data = []
+    train_labels = []
+    
+    # 读取训练数据
+    for i in range(1, 6):
+        batch_file = os.path.join(dataset_path, f'data_batch_{i}')
+        if os.path.exists(batch_file):
+            print(f"读取训练批次 {i}")
+            batch = unpickle(batch_file)
+            train_data.append(batch[b'data'])
+            train_labels.extend(batch[b'labels'])
+    
+    # 合并所有训练数据
+    if train_data:
+        train_data = np.vstack(train_data)
+        train_data = train_data.reshape(-1, 3, 32, 32).transpose(0, 2, 3, 1)
+    
+    # 读取测试数据
+    test_file = os.path.join(dataset_path, 'test_batch')
+    # if os.path.exists(test_file):
+    #     print("读取测试数据")
+    #     test_batch = unpickle(test_file)
+    #     test_data = test_batch[b'data']
+    #     test_labels = test_batch[b'labels']
+    #     test_data = test_data.reshape(-1, 3, 32, 32).transpose(0, 2, 3, 1)
+    # else:
+    test_data = []
+    test_labels = []
+    
+    # 合并训练和测试数据
+    all_data = np.concatenate([train_data, test_data]) if len(test_data) > 0 and len(train_data) > 0 else (train_data if len(train_data) > 0 else test_data)
+    all_labels = train_labels + test_labels if len(test_labels) > 0 and len(train_labels) > 0 else (train_labels if len(train_labels) > 0 else test_labels)
+    
+    # 保存图像
+    print(f"保存 {len(all_data)} 张图像...")
+    for i, (img, label) in enumerate(tqdm(zip(all_data, all_labels), total=len(all_data))):
+        img = Image.fromarray(img)
+        img.save(os.path.join(save_dir, f"{i}.png"))
+    
+    print(f"完成! {len(all_data)} 张图像已保存到 {save_dir}")
+
+if __name__ == "__main__":
+    # 设置路径
+    dataset_path = "../dataset/cifar-10-batches-py"
+    save_dir = "../dataset/raw_data"
+    
+    # 检查数据集是否存在，如果不存在则下载
+    if not os.path.exists(dataset_path):
+        print("数据集不存在，正在下载...")
+        os.makedirs("../dataset", exist_ok=True)
+        transform = transforms.Compose([transforms.ToTensor()])
+        trainset = torchvision.datasets.CIFAR10(root="../dataset", train=True, download=True, transform=transform)
+    
+    # 保存图像
+    save_images_from_cifar10(dataset_path, save_dir)

ResNet-CIFAR10/Classification-mini/scripts/get_representation.py

@@ -0,0 +1,272 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import os
+import json
+from tqdm import tqdm
+
+class time_travel_saver:
+    """可视化数据提取器
+    
+    用于保存模型训练过程中的各种数据，包括：
+    1. 模型权重 (.pth)
+    2. 高维特征 (representation/*.npy)
+    3. 预测结果 (prediction/*.npy)
+    4. 标签数据 (label/labels.npy)
+    """
+    
+    def __init__(self, model, dataloader, device, save_dir, model_name, 
+                auto_save_embedding=False, layer_name=None,show = False):
+        """初始化
+        
+        Args:
+            model: 要保存的模型实例
+            dataloader: 数据加载器（必须是顺序加载的）
+            device: 计算设备(cpu or gpu)
+            save_dir: 保存根目录
+            model_name: 模型名称
+        """
+        self.model = model
+        self.dataloader = dataloader
+        self.device = device
+        self.save_dir = save_dir
+        self.model_name = model_name
+        self.auto_save = auto_save_embedding
+        self.layer_name = layer_name
+
+        if show and not layer_name:
+            layer_dimensions = self.show_dimensions()
+            # print(layer_dimensions)
+        
+    def show_dimensions(self):
+        """显示模型中所有层的名称和对应的维度
+        
+        这个函数会输出模型中所有层的名称和它们的输出维度，
+        帮助用户选择合适的层来提取特征。
+        
+        Returns:
+            layer_dimensions: 包含层名称和维度的字典
+        """
+        activation = {}
+        layer_dimensions = {}
+        
+        def get_activation(name):
+            def hook(model, input, output):
+                activation[name] = output.detach()
+            return hook
+        
+        # 注册钩子到所有层
+        handles = []
+        for name, module in self.model.named_modules():
+            if isinstance(module, nn.Module) and not isinstance(module, nn.ModuleList) and not isinstance(module, nn.ModuleDict):
+                handles.append(module.register_forward_hook(get_activation(name)))
+        
+        self.model.eval()
+        with torch.no_grad():
+            # 获取一个batch来分析每层的输出维度
+            inputs, _ = next(iter(self.dataloader))
+            inputs = inputs.to(self.device)
+            _ = self.model(inputs)
+            
+            # 分析所有层的输出维度
+            print("\n模型各层的名称和维度:")
+            print("-" * 50)
+            print(f"{'层名称':<40} {'特征维度':<15} {'输出形状'}")
+            print("-" * 50)
+            
+            for name, feat in activation.items():
+                if feat is None:
+                    continue
+                
+                # 获取特征维度（展平后）
+                feat_dim = feat.view(feat.size(0), -1).size(1)
+                layer_dimensions[name] = feat_dim
+                # 打印层信息
+                shape_str = str(list(feat.shape))
+                print(f"{name:<40} {feat_dim:<15} {shape_str}")
+            
+            print("-" * 50)
+            print("注: 特征维度是将输出张量展平后的维度大小")
+            print("你可以通过修改time_travel_saver的layer_name参数来选择不同的层")
+            print("例如：layer_name='avg_pool'或layer_name='layer4'等")
+        
+        # 移除所有钩子
+        for handle in handles:
+            handle.remove()
+        
+        return layer_dimensions
+
+    def _extract_features_and_predictions(self):
+        """提取特征和预测结果
+        
+        Returns:
+            features: 高维特征 [样本数, 特征维度]
+            predictions: 预测结果 [样本数, 类别数]
+        """
+        features = []
+        predictions = []
+        indices = []
+        activation = {}
+        
+        def get_activation(name):
+            def hook(model, input, output):
+                # 只在需要时保存激活值，避免内存浪费
+                if name not in activation or activation[name] is None:
+                    activation[name] = output.detach()
+            return hook
+        
+        # 根据层的名称或维度来选择层
+
+        # 注册钩子到所有层
+        handles = []
+        for name, module in self.model.named_modules():
+            if isinstance(module, nn.Module) and not isinstance(module, nn.ModuleList) and not isinstance(module, nn.ModuleDict):
+                handles.append(module.register_forward_hook(get_activation(name)))
+        
+        self.model.eval()
+        with torch.no_grad():
+            # 首先获取一个batch来分析每层的输出维度
+            inputs, _ = next(iter(self.dataloader))
+            inputs = inputs.to(self.device)
+            _ = self.model(inputs)
+            
+            # 如果指定了层名，则直接使用该层
+            if self.layer_name is not None:
+                if self.layer_name not in activation:
+                    raise ValueError(f"指定的层 {self.layer_name} 不存在于模型中")
+                
+                feat = activation[self.layer_name]
+                if feat is None:
+                    raise ValueError(f"指定的层 {self.layer_name} 没有输出特征")
+                
+                suitable_layer_name = self.layer_name
+                suitable_dim = feat.view(feat.size(0), -1).size(1)
+                print(f"使用指定的特征层: {suitable_layer_name}, 特征维度: {suitable_dim}")
+            else:
+                # 找到维度在指定范围内的层
+                target_dim_range = (256, 2048)
+                suitable_layer_name = None
+                suitable_dim = None
+                
+                # 分析所有层的输出维度
+                for name, feat in activation.items():
+                    if feat is None:
+                        continue
+                    feat_dim = feat.view(feat.size(0), -1).size(1)
+                    if target_dim_range[0] <= feat_dim <= target_dim_range[1]:
+                        suitable_layer_name = name
+                        suitable_dim = feat_dim
+                        break
+                
+                if suitable_layer_name is None:
+                    raise ValueError("没有找到合适维度的特征层")
+                    
+                print(f"自动选择的特征层: {suitable_layer_name}, 特征维度: {suitable_dim}")
+            
+            # 保存层信息
+            layer_info = {
+                'layer_id': suitable_layer_name,
+                'dim': suitable_dim
+            }
+            layer_info_path = os.path.join(os.path.dirname(self.save_dir), 'layer_info.json')
+            with open(layer_info_path, 'w') as f:
+                json.dump(layer_info, f)
+            
+            # 清除第一次运行的激活值
+            activation.clear()
+            
+            # 现在处理所有数据
+            for batch_idx, (inputs, _) in enumerate(tqdm(self.dataloader, desc="提取特征和预测结果")):
+                inputs = inputs.to(self.device)
+                outputs = self.model(inputs)  # 获取预测结果
+                
+                # 获取并处理特征
+                feat = activation[suitable_layer_name]
+                flat_features = torch.flatten(feat, start_dim=1)
+                features.append(flat_features.cpu().numpy())
+                predictions.append(outputs.cpu().numpy())
+                
+                # 清除本次的激活值
+                activation.clear()
+        
+        # 移除所有钩子
+        for handle in handles:
+            handle.remove()
+        
+        if len(features) > 0:
+            features = np.vstack(features)
+            predictions = np.vstack(predictions)
+            return features, predictions
+        else:
+            return np.array([]), np.array([])
+    
+    def save_lables_index(self, path):
+        """保存标签数据和索引信息
+        
+        Args:
+            path: 保存路径
+        """
+        os.makedirs(path, exist_ok=True)
+        labels_path = os.path.join(path, 'labels.npy')
+        index_path = os.path.join(path, 'index.json')
+        
+        # 尝试从不同的属性获取标签
+        try:
+            if hasattr(self.dataloader.dataset, 'targets'):
+                # CIFAR10/CIFAR100使用targets属性
+                labels = np.array(self.dataloader.dataset.targets)
+            elif hasattr(self.dataloader.dataset, 'labels'):
+                # 某些数据集使用labels属性
+                labels = np.array(self.dataloader.dataset.labels)
+            else:
+                # 如果上面的方法都不起作用，则从数据加载器中收集标签
+                labels = []
+                for _, batch_labels in self.dataloader:
+                    labels.append(batch_labels.numpy())
+                labels = np.concatenate(labels)
+            
+            # 保存标签数据
+            np.save(labels_path, labels)
+            print(f"标签数据已保存到 {labels_path}")
+            
+            # 创建数据集索引
+            num_samples = len(labels)
+            indices = list(range(num_samples))
+            
+            # 创建索引字典
+            index_dict = {
+                "train": indices,  # 所有数据默认为训练集
+                "test": [],        # 初始为空
+                "validation": []   # 初始为空
+            }
+            
+            # 保存索引到JSON文件
+            with open(index_path, 'w') as f:
+                json.dump(index_dict, f, indent=4)
+            
+            print(f"数据集索引已保存到 {index_path}")
+            
+        except Exception as e:
+            print(f"保存标签和索引时出错: {e}")
+
+    def save_checkpoint_embeddings_predictions(self, model = None):
+        """保存所有数据"""
+        if model is not None:
+            self.model = model
+        # 保存模型权重
+        os.makedirs(self.save_dir, exist_ok=True)
+        model_path = os.path.join(self.save_dir,'model.pth')
+        torch.save(self.model.state_dict(), model_path)
+        
+        if self.auto_save:
+            # 提取并保存特征和预测结果
+            features, predictions = self._extract_features_and_predictions()
+            
+            # 保存特征 
+            np.save(os.path.join(self.save_dir, 'embeddings.npy'), features)
+            # 保存预测结果
+            np.save(os.path.join(self.save_dir, 'predictions.npy'), predictions)
+            print("\n保存了以下数据:")
+            print(f"- 模型权重: {model_path}")
+            print(f"- 特征向量: [样本数: {features.shape[0]}, 特征维度: {features.shape[1]}]")
+            print(f"- 预测结果: [样本数: {predictions.shape[0]}, 类别数: {predictions.shape[1]}]")

ResNet-CIFAR10/Classification-mini/scripts/model.py

@@ -0,0 +1,308 @@
+'''
+ResNet in PyTorch.
+
+ResNet(深度残差网络)是由微软研究院的Kaiming He等人提出的深度神经网络架构。
+主要创新点是引入了残差学习的概念,通过跳跃连接解决了深层网络的退化问题。
+
+主要特点:
+1. 引入残差块(Residual Block),使用跳跃连接
+2. 使用Batch Normalization进行归一化
+3. 支持更深的网络结构(最深可达152层)
+4. 在多个计算机视觉任务上取得了突破性进展
+
+Reference:
+[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
+    Deep Residual Learning for Image Recognition. arXiv:1512.03385
+'''
+import torch
+import torch.nn as nn
+
+class BasicBlock(nn.Module):
+    """基础残差块
+    
+    用于ResNet18/34等浅层网络。结构为:
+    x -> Conv -> BN -> ReLU -> Conv -> BN -> (+) -> ReLU
+         |------------------------------------------|
+         
+    Args:
+        in_channels: 输入通道数
+        out_channels: 输出通道数
+        stride: 步长,用于下采样,默认为1
+        
+    注意:基础模块没有通道压缩,expansion=1
+    """
+    expansion = 1
+    
+    def __init__(self, in_channels, out_channels, stride=1):
+        super(BasicBlock,self).__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(True),
+            nn.Conv2d(out_channels,out_channels, kernel_size=3, stride=1, padding=1, bias=False),
+            nn.BatchNorm2d(out_channels)
+        )
+        
+        # 如果输入输出维度不等,则使用1x1卷积层来改变维度
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_channels != self.expansion * out_channels:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_channels, self.expansion * out_channels, kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(self.expansion * out_channels),
+            )
+            
+    def forward(self, x):
+        out = self.features(x)
+        out += self.shortcut(x)
+        out = torch.relu(out)
+        return out
+    
+
+class Bottleneck(nn.Module):
+    """瓶颈残差块
+    
+    用于ResNet50/101/152等深层网络。结构为:
+    x -> 1x1Conv -> BN -> ReLU -> 3x3Conv -> BN -> ReLU -> 1x1Conv -> BN -> (+) -> ReLU
+         |-------------------------------------------------------------------|
+         
+    Args:
+        in_channels: 输入通道数
+        zip_channels: 压缩后的通道数
+        stride: 步长,用于下采样,默认为1
+        
+    注意:通过1x1卷积先压缩通道数,再还原,expansion=4
+    """
+    expansion = 4
+    
+    def __init__(self, in_channels, zip_channels, stride=1):
+        super(Bottleneck, self).__init__()
+        out_channels = self.expansion * zip_channels
+        self.features = nn.Sequential(
+            # 1x1卷积压缩通道
+            nn.Conv2d(in_channels, zip_channels, kernel_size=1, bias=False),
+            nn.BatchNorm2d(zip_channels),
+            nn.ReLU(inplace=True),
+            # 3x3卷积提取特征
+            nn.Conv2d(zip_channels, zip_channels, kernel_size=3, stride=stride, padding=1, bias=False),
+            nn.BatchNorm2d(zip_channels),
+            nn.ReLU(inplace=True),
+            # 1x1卷积还原通道
+            nn.Conv2d(zip_channels, out_channels, kernel_size=1, bias=False),
+            nn.BatchNorm2d(out_channels)
+        )
+        
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_channels != out_channels:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(out_channels)
+            )
+            
+    def forward(self, x):
+        out = self.features(x)
+        out += self.shortcut(x)
+        out = torch.relu(out)
+        return out
+    
+class ResNet(nn.Module):
+    """ResNet模型
+    
+    网络结构:
+    1. 一个卷积层用于特征提取
+    2. 四个残差层,每层包含多个残差块
+    3. 平均池化和全连接层进行分类
+    
+    对于CIFAR10,特征图大小变化为:
+    (32,32,3) -> [Conv] -> (32,32,64) -> [Layer1] -> (32,32,64) -> [Layer2] 
+    -> (16,16,128) -> [Layer3] -> (8,8,256) -> [Layer4] -> (4,4,512) -> [AvgPool] 
+    -> (1,1,512) -> [FC] -> (num_classes)
+    
+    Args:
+        block: 残差块类型(BasicBlock或Bottleneck)
+        num_blocks: 每层残差块数量的列表
+        num_classes: 分类数量,默认为10
+        verbose: 是否打印中间特征图大小
+        init_weights: 是否初始化权重
+        dropout: 是否在全连接层前使用dropout
+    """
+    def __init__(self, block, num_blocks, num_classes=10, verbose=False, init_weights=True, dropout=False):
+        super(ResNet, self).__init__()
+        self.verbose = verbose
+        self.in_channels = 64
+        
+        # 第一层卷积
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True)
+        )
+        
+        # 四个残差层
+        self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
+        self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
+        self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
+        self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)
+        
+        # 分类层
+        self.avg_pool = nn.AvgPool2d(kernel_size=4)
+        if dropout:
+            self.dropout = nn.Dropout(p=0.5)
+        else:
+            self.dropout = nn.Identity()
+        self.classifier = nn.Linear(512 * block.expansion, num_classes)
+
+        if init_weights:
+            self._initialize_weights()
+            
+    def _make_layer(self, block, out_channels, num_blocks, stride):
+        """构建残差层
+        
+        Args:
+            block: 残差块类型
+            out_channels: 输出通道数
+            num_blocks: 残差块数量
+            stride: 第一个残差块的步长(用于下采样)
+            
+        Returns:
+            nn.Sequential: 残差层
+        """
+        strides = [stride] + [1] * (num_blocks - 1)
+        layers = []
+        for stride in strides:
+            layers.append(block(self.in_channels, out_channels, stride))
+            self.in_channels = out_channels * block.expansion
+        return nn.Sequential(*layers)
+    
+    def forward(self, x):
+        """前向传播
+        
+        Args:
+            x: 输入张量,[N,3,32,32]
+            
+        Returns:
+            out: 输出张量,[N,num_classes]
+        """
+        out = self.features(x)
+        if self.verbose:
+            print('block 1 output: {}'.format(out.shape))
+            
+        out = self.layer1(out)        
+        if self.verbose:
+            print('block 2 output: {}'.format(out.shape))
+            
+        out = self.layer2(out)
+        if self.verbose:
+            print('block 3 output: {}'.format(out.shape))
+            
+        out = self.layer3(out)
+        if self.verbose:
+            print('block 4 output: {}'.format(out.shape))
+            
+        out = self.layer4(out)
+        if self.verbose:
+            print('block 5 output: {}'.format(out.shape))
+            
+        out = self.avg_pool(out)
+        out = out.view(out.size(0), -1)
+        out = self.dropout(out)
+        out = self.classifier(out)
+        return out
+
+    def feature(self,x):
+        """前向传播
+        
+        Args:
+            x: 输入张量,[N,3,32,32]
+            
+        Returns:
+            out: 输出张量,[N,num_classes]
+        """
+        out = self.features(x)
+        if self.verbose:
+            print('block 1 output: {}'.format(out.shape))
+            
+        out = self.layer1(out)        
+        if self.verbose:
+            print('block 2 output: {}'.format(out.shape))
+            
+        out = self.layer2(out)
+        if self.verbose:
+            print('block 3 output: {}'.format(out.shape))
+            
+        out = self.layer3(out)
+        if self.verbose:
+            print('block 4 output: {}'.format(out.shape))
+            
+        out = self.layer4(out)
+        if self.verbose:
+            print('block 5 output: {}'.format(out.shape))
+            
+        out = self.avg_pool(out)
+        out = out.view(out.size(0), -1)
+        return out
+    
+    def prediction(self, x):
+        out = self.classifier(x)
+        return out
+        
+    def _initialize_weights(self):
+        """初始化模型权重
+        
+        采用kaiming初始化方法:
+        - 卷积层权重采用kaiming_normal_初始化
+        - BN层参数采用常数初始化
+        - 线性层采用正态分布初始化
+        """
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                nn.init.constant_(m.bias, 0)
+
+def ResNet18(verbose=False, num_classes=10, dropout=False):
+    """ResNet-18模型
+    
+    Args:
+        verbose: 是否打印中间特征图大小
+        num_classes: 分类数量
+        dropout: 是否在全连接层前使用dropout
+    """
+    return ResNet(BasicBlock, [2,2,2,2], num_classes=num_classes, verbose=verbose, dropout=dropout)
+
+def ResNet34(verbose=False, num_classes=10, dropout=False):
+    """ResNet-34模型"""
+    return ResNet(BasicBlock, [3,4,6,3], num_classes=num_classes, verbose=verbose, dropout=dropout)
+
+def ResNet50(verbose=False):
+    """ResNet-50模型"""
+    return ResNet(Bottleneck, [3,4,6,3], verbose=verbose)
+
+def ResNet101(verbose=False):
+    """ResNet-101模型"""
+    return ResNet(Bottleneck, [3,4,23,3], verbose=verbose)
+
+def ResNet152(verbose=False):
+    """ResNet-152模型"""
+    return ResNet(Bottleneck, [3,8,36,3], verbose=verbose)
+
+def test():
+    """测试函数"""
+    net = ResNet34()
+    x = torch.randn(2,3,32,32)
+    y = net(x)
+    print('Output shape:', y.size())
+    
+    # 打印模型结构
+    from torchinfo import summary
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    net = net.to(device)
+    summary(net,(2,3,32,32))
+
+if __name__ == '__main__':
+    test()

ResNet-CIFAR10/Classification-mini/scripts/train.py

@@ -0,0 +1,225 @@
+import sys
+import os
+import yaml
+from pathlib import Path
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import time
+import logging
+import numpy as np
+from tqdm import tqdm
+
+
+from dataset_utils import get_cifar10_dataloaders
+from model import ResNet18
+from get_representation import time_travel_saver
+
+def setup_logger(log_file):
+    """配置日志记录器，如果日志文件存在则覆盖
+    
+    Args:
+        log_file: 日志文件路径
+        
+    Returns:
+        logger: 配置好的日志记录器
+    """
+    # 创建logger
+    logger = logging.getLogger('train')
+    logger.setLevel(logging.INFO)
+    
+    # 移除现有的处理器
+    if logger.hasHandlers():
+        logger.handlers.clear()
+    
+    # 创建文件处理器，使用'w'模式覆盖现有文件
+    fh = logging.FileHandler(log_file, mode='w')
+    fh.setLevel(logging.INFO)
+    
+    # 创建控制台处理器
+    ch = logging.StreamHandler()
+    ch.setLevel(logging.INFO)
+    
+    # 创建格式器
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    fh.setFormatter(formatter)
+    ch.setFormatter(formatter)
+    
+    # 添加处理器
+    logger.addHandler(fh)
+    logger.addHandler(ch)
+    
+    return logger
+
+def train_model(model, trainloader, testloader, epochs=200, lr=0.1, device='cuda:0',
+               save_dir='./epochs', model_name='model', interval=1):
+    """通用的模型训练函数
+    Args:
+        model: 要训练的模型
+        trainloader: 训练数据加载器
+        testloader: 测试数据加载器
+        epochs: 训练轮数
+        lr: 学习率
+        device: 训练设备，格式为'cuda:N'，其中N为GPU编号（0,1,2,3）
+        save_dir: 模型保存目录
+        model_name: 模型名称
+        interval: 模型保存间隔
+    """
+    # 检查并设置GPU设备
+    if not torch.cuda.is_available():
+        print("CUDA不可用，将使用CPU训练")
+        device = 'cpu'
+    elif not device.startswith('cuda:'):
+        device = f'cuda:0'
+    
+    # 确保device格式正确
+    if device.startswith('cuda:'):
+        gpu_id = int(device.split(':')[1])
+        if gpu_id >= torch.cuda.device_count():
+            print(f"GPU {gpu_id} 不可用，将使用GPU 0")
+            device = 'cuda:0'
+    
+    # 设置保存目录
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir)
+    
+    # 设置日志文件路径
+    log_file = os.path.join(os.path.dirname(save_dir),'epochs', 'train.log')
+    if not os.path.exists(os.path.dirname(log_file)):
+        os.makedirs(os.path.dirname(log_file))
+    
+    logger = setup_logger(log_file)
+    
+    # 损失函数和优化器
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9, weight_decay=5e-4)
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
+    
+    # 移动模型到指定设备
+    model = model.to(device)
+    best_acc = 0
+    start_time = time.time()
+    
+    logger.info(f'开始训练 {model_name}')
+    logger.info(f'总轮数: {epochs}, 学习率: {lr}, 设备: {device}')
+    
+    for epoch in range(epochs):
+        # 训练阶段
+        model.train()
+        train_loss = 0
+        correct = 0
+        total = 0
+        
+        train_pbar = tqdm(trainloader, desc=f'Epoch {epoch+1}/{epochs} [Train]')
+        for batch_idx, (inputs, targets) in enumerate(train_pbar):
+            inputs, targets = inputs.to(device), targets.to(device)
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = criterion(outputs, targets)
+            loss.backward()
+            optimizer.step()
+            
+            train_loss += loss.item()
+            _, predicted = outputs.max(1)
+            total += targets.size(0)
+            correct += predicted.eq(targets).sum().item()
+            
+            # 更新进度条
+            train_pbar.set_postfix({
+                'loss': f'{train_loss/(batch_idx+1):.3f}',
+                'acc': f'{100.*correct/total:.2f}%'
+            })
+        
+        # 保存训练阶段的准确率
+        train_acc = 100.*correct/total
+        train_correct = correct
+        train_total = total
+        
+        # 测试阶段
+        model.eval()
+        test_loss = 0
+        correct = 0
+        total = 0
+        
+        test_pbar = tqdm(testloader, desc=f'Epoch {epoch+1}/{epochs} [Test]')
+        with torch.no_grad():
+            for batch_idx, (inputs, targets) in enumerate(test_pbar):
+                inputs, targets = inputs.to(device), targets.to(device)
+                outputs = model(inputs)
+                loss = criterion(outputs, targets)
+                
+                test_loss += loss.item()
+                _, predicted = outputs.max(1)
+                total += targets.size(0)
+                correct += predicted.eq(targets).sum().item()
+        
+                # 更新进度条
+                test_pbar.set_postfix({
+                    'loss': f'{test_loss/(batch_idx+1):.3f}',
+                    'acc': f'{100.*correct/total:.2f}%'
+                })
+        
+        # 计算测试精度
+        acc = 100.*correct/total
+        
+        # 记录训练和测试的损失与准确率
+        logger.info(f'Epoch: {epoch+1} | Train Loss: {train_loss/(len(trainloader)):.3f} | Train Acc: {train_acc:.2f}% | '
+                   f'Test Loss: {test_loss/(batch_idx+1):.3f} | Test Acc: {acc:.2f}%')
+        
+        # 保存可视化训练过程所需要的文件
+        if (epoch + 1) % interval  == 0 or (epoch == 0): 
+            # 只使用前1000个样本进行保存
+            subset_indices = list(range(1000))  # 只取前1000个样本的索引
+            subset_dataset = torch.utils.data.Subset(trainloader.dataset, subset_indices)
+            
+            # 创建一个只包含前1000个样本的顺序dataloader
+            ordered_trainloader = torch.utils.data.DataLoader(
+                subset_dataset,
+                batch_size=trainloader.batch_size,
+                shuffle=False,
+                num_workers=trainloader.num_workers
+            )
+            
+            epoch_save_dir = os.path.join(save_dir, f'epoch_{epoch+1}')
+            save_model = time_travel_saver(model, ordered_trainloader, device, epoch_save_dir, model_name, 
+                         show=True, layer_name='avg_pool', auto_save_embedding=True)
+            save_model.save_checkpoint_embeddings_predictions()
+            if epoch == 0:
+                save_model.save_lables_index(path = "../dataset")
+            
+        scheduler.step()
+    
+    logger.info('训练完成!')
+
+def main():
+    # 加载配置文件
+    config_path = Path(__file__).parent / 'train.yaml'
+    with open(config_path) as f:
+        config = yaml.safe_load(f)
+    
+    # 创建模型
+    model = ResNet18(num_classes=10)
+    
+    # 获取数据加载器
+    trainloader, testloader = get_cifar10_dataloaders(
+        batch_size=128, 
+        num_workers=2, 
+        local_dataset_path=config['dataset_path'],
+        shuffle=True    
+    )
+    
+    # 训练模型
+    train_model(
+        model=model,
+        trainloader=trainloader,
+        testloader=testloader,
+        epochs=config['epochs'],
+        lr=config['lr'],
+        device=f'cuda:{config["gpu"]}',
+        save_dir='../epochs',
+        model_name='ResNet18',
+        interval=config['interval']
+    )
+
+if __name__ == '__main__':
+    main()

ResNet-CIFAR10/Classification-mini/scripts/train.yaml

@@ -0,0 +1,7 @@
+batch_size: 128
+num_workers: 2
+dataset_path: ../dataset
+epochs: 3
+gpu: 0
+lr: 0.1
+interval: 1