test4

实战代码/AlexNet作业/AlexNet作业/AlexNet作业.txt

+1. 查阅总结sigmoid和softmax激活函数的联系和区别
+1. 查阅总结sigmoid和softmax激活函数的联系和区别
+
+2. 整理自己的AlexNet论文笔记
+
+3.复现课上代码
+

实战代码/AlexNet作业/AlexNet作业/alexNet.py

+from turtle import forward
+from turtle import forward
+from numpy import isin
+import torch
+import torch.nn as nn
+import sys
+
+class AelxNet(nn.Module):
+    def __init__(self,num_classes,input_channels,init_weights=True):
+        super().__init__()
+        self.features = nn.Sequential(
+            #224*224*3 ---> 11*11*3 ---> 
+            nn.Conv2d(in_channels=input_channels,out_channels=48,kernel_size=11,stride=4,padding=2),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=3,stride=2),
+
+            nn.Conv2d(in_channels=48,out_channels=128,kernel_size=5,stride=1,padding=2),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=3,stride=2),
+
+            nn.Conv2d(in_channels=128,out_channels=192,kernel_size=3,stride=1,padding=1),
+            nn.ReLU(),
+
+            nn.Conv2d(in_channels=192,out_channels=192,kernel_size=3,stride=1,padding=1),
+            nn.ReLU(),
+
+            nn.Conv2d(in_channels=192,out_channels=128,kernel_size=3,stride=1,padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=3,stride=2)
+
+        )
+        self.classsifier = nn.Sequential(
+            nn.Dropout(p=0.5),
+            nn.Linear(in_features=128*6*6,out_features=2048),
+            nn.ReLU(),
+
+            nn.Dropout(p=0.5),
+            nn.Linear(in_features=2048,out_features=2048),
+            nn.ReLU(),
+
+            nn.Dropout(p=0.5),
+            nn.Linear(in_features=2048,out_features=num_classes),
+            nn.ReLU(),
+
+        )
+
+        if init_weights:
+            self._init_weights()
+
+        def __nit_weights():
+            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.Linear):
+                    nn.init.normal_(m.weight, 0, 0.01)
+                    nn.init.constant_(m.bias, 0)
+
+    def forward(self,x):
+        assert x.shape[2] == 224 and x.shape[3] == 224, 'error'
+        x = self.features(x)
+        x = torch.flatten(x,start_dim=1)
+        x = self.classsifier(x)
+
+        return x
+
+
+
+        

实战代码/AlexNet作业（补充）/AlexNet/AlexNet.py

+import torch.nn as nn
+import torch.nn as nn
+import torch
+
+
+class AlexNet(nn.Module):
+    def __init__(self, num_classes=1000, init_weights=False):
+        super(AlexNet, self).__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 48, kernel_size=11, stride=4, padding=2),  # input[3, 224, 224]  output[48, 55, 55]
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[48, 27, 27]
+
+            nn.Conv2d(48, 128, kernel_size=5, padding=2),           # output[128, 27, 27]
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[128, 13, 13]
+
+            nn.Conv2d(128, 192, kernel_size=3, padding=1),          # output[192, 13, 13]
+            nn.ReLU(inplace=True),
+
+            nn.Conv2d(192, 192, kernel_size=3, padding=1),          # output[192, 13, 13]
+            nn.ReLU(inplace=True),
+
+            nn.Conv2d(192, 128, kernel_size=3, padding=1),          # output[128, 13, 13]
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[128, 6, 6]
+        )
+        self.classifier = nn.Sequential(
+            nn.Dropout(p=0.5),
+            nn.Linear(128 * 6 * 6, 2048),
+            nn.ReLU(inplace=True),
+
+            nn.Dropout(p=0.5),
+            nn.Linear(2048, 2048),
+            nn.ReLU(inplace=True),
+            
+            nn.Linear(2048, num_classes),
+        )
+        if init_weights:
+            self._initialize_weights()
+
+    def forward(self, x):
+        x = self.features(x)
+        x = torch.flatten(x, start_dim=1)
+        x = self.classifier(x)
+        return x
+
+    def _initialize_weights(self):
+        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.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                nn.init.constant_(m.bias, 0)
\ No newline at end of file

实战代码/AlexNet作业（补充）/AlexNet/README.md

+# AlexNet花朵分类
+# AlexNet花朵分类
+
+这是一个使用AlexNet模型进行花朵分类的训练脚本。它使用了PyTorch库来定义模型、加载数据集、训练模型等。
+
+## 依赖
+
+- Python 3.x
+- PyTorch
+- torchvision
+
+## 数据集准备
+
+1. 下载花朵分类数据集，并将其放置在适当的位置。
+
+2. 数据集文件夹结构应如下所示：
+├── AlexNet
+├── flower
+│ ├── flower_photos
+│ │ ├── class1
+│ │ ├── class2
+│ │ ├── ...
+│ │ └── classN
+│ ├── train
+│ │ ├── class1
+│ │ ├── class2
+│ │ ├── ...
+│ │ └── classN
+│ └── val
+│ ├── class1
+│ ├── class2
+│ ├── ...
+│ └── classN
+- `train`文件夹包含训练集图像，每个类别的图像应放在对应的子文件夹中。
+- `val`文件夹包含验证集图像，也按照类别分别放置在子文件夹中。
+
+3. 在`train.py`文件中的`data_path`变量中设置数据集的绝对路径。
+
+## 使用方法
+
+运行以下命令开始训练模型：
+
+python train.py
+
+## 参数调整
+
+- 可以在`main.py`文件中根据需要调整以下参数：
+  - `batch_size`：每个批次的样本数量。
+  - `lr`：学习率。
+  - `epochs`：训练的总轮数。
+  - `save_path`：保存模型的路径。
+  - ...
+
+## 模型保存
+
+训练过程中，模型会在验证集上表现优于之前的最佳模型时进行保存。模型会保存在`classification/AlexNet/checkpoints/AlexNet_for_flower.pth`路径下。
+
+## 注意事项
+
+- 在运行代码之前，请确保已安装所需的依赖项。
+- 请根据实际情况设置数据集路径和其他参数。
+- 请确保拥有足够的计算资源和训练时间。
+
+如果有任何问题或需要进一步帮助，请随时提问。
+
+

实战代码/AlexNet作业（补充）/AlexNet/train.py

+import os
+import os
+import sys
+import json
+
+import torch
+import torch.nn as nn
+from torchvision import transforms, datasets, utils
+import matplotlib.pyplot as plt
+import numpy as np
+import torch.optim as optim
+from tqdm import tqdm
+
+from AlexNet import AlexNet
+
+data_path = os.path.abspath(os.path.join(os.getcwd(), "flower"))   # 注意数据集路径, 指定到flower这一目录级别
+if os.path.exists(data_path) is False:
+    print('dataset path error')
+
+def main():
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    print("using {} device.".format(device))
+
+    data_transform = {
+        "train": transforms.Compose([transforms.RandomResizedCrop(224),
+                                     transforms.RandomHorizontalFlip(),
+                                     transforms.ToTensor(),
+                                     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
+        "val": transforms.Compose([transforms.Resize((224, 224)),  # val不需要任何数据增强
+                                   transforms.ToTensor(),
+                                   transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}
+
+ 
+ 
+    assert os.path.exists(data_path), "{} path does not exist.".format(data_path)
+
+    # 使用ImageFlolder加载数据集中的图像，并使用指定的预处理处理图像， ImageFlolder会同时返回图像和对应的标签。
+    train_dataset = datasets.ImageFolder(root=os.path.join(data_path, "train"), transform=data_transform["train"])
+    validate_dataset = datasets.ImageFolder(root=os.path.join(data_path, "val"), transform=data_transform["val"])
+    train_num = len(train_dataset)
+    val_num = len(validate_dataset)
+
+    # 使用class_to_idx给类别一个index，作为训练时的标签： {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
+    flower_list = train_dataset.class_to_idx
+    # 创建一个字典，存储index和类别的对应关系，在模型推理阶段会用到。
+    cla_dict = dict((val, key) for key, val in flower_list.items())
+    # 将字典写成一个json文件
+    json_str = json.dumps(cla_dict, indent=4)
+    with open('class_indices.json', 'w') as json_file:
+        json_file.write(json_str)
+
+    batch_size = 32 # batch_size大小，是超参，可调，如果模型跑不起来，尝试调小batch_size
+    nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # 用于加载数据集的进程数量
+    print('Using {} dataloader workers every process'.format(nw))
+
+    # 使用 DataLoader 将 ImageFloder 加载的数据集处理成批量（batch）加载模型
+    train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=nw)
+    validate_loader = torch.utils.data.DataLoader(validate_dataset, batch_size=4, shuffle=False,  num_workers=nw) # 注意，验证集不需要shuffle
+    print("using {} images for training, {} images for validation.".format(train_num, val_num))
+    
+    # 实例化模型，并送进设备
+    net = AlexNet(num_classes=5, init_weights=True)
+    net.to(device)
+
+    # 指定损失函数用于计算损失；指定优化器用于更新模型参数；指定训练迭代的轮数，训练权重的存储地址
+    loss_function = nn.CrossEntropyLoss() 
+    optimizer = optim.Adam(net.parameters(), lr=0.0002)
+    epochs = 20
+    save_path = './AlexNet.pth'
+    if os.path.exists(save_path) is False:
+        os.mkdir('./AlexNet.pth')
+
+    best_acc = 0.0
+    train_steps = len(train_loader) # epoch是迭代训练数据集的次数，train_stepa是数据集可以被分成的批次数量 = num(dataset) / batch_size
+    for epoch in range(epochs):
+        # train
+        net.train()
+        running_loss = 0.0
+        # tqdm是一个进度条显示器，可以在终端打印出现在的训练进度
+        train_bar = tqdm(train_loader, file=sys.stdout, ncols=100)
+        for step, data in enumerate(train_bar):
+            images, labels = data
+            optimizer.zero_grad()
+            outputs = net(images.to(device))
+            loss = loss_function(outputs, labels.to(device)) # 求损失
+            loss.backward() # 自动求导
+            optimizer.step() # 梯度下降
+
+            # print statistics
+            running_loss += loss.item()
+            # .desc是进度条tqdm中的成员变量，作用是描述信息
+            train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,  epochs, loss)
+
+        # validate
+        net.eval()
+        acc = 0.0  # accumulate accurate number / epoch
+        with torch.no_grad(): 
+            for val_data in validate_loader:
+                val_images, val_labels = val_data
+                outputs = net(val_images.to(device))
+                predict_y = torch.max(outputs, dim=1)[1]
+                acc += torch.eq(predict_y, val_labels.to(device)).sum().item() 
+
+        val_accurate = acc / val_num
+        print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %  (epoch + 1, running_loss / train_steps, val_accurate))
+
+        if val_accurate > best_acc:
+            best_acc = val_accurate
+            torch.save(net.state_dict(), save_path)
+
+    print('Finished Training')
+
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file

实战代码/AlexNet作业（补充）/Test2_alexnet/class_indices.json

+{
+{
+    "0": "daisy",
+    "1": "dandelion",
+    "2": "roses",
+    "3": "sunflowers",
+    "4": "tulips"
+}
\ No newline at end of file

实战代码/AlexNet作业（补充）/Test2_alexnet/model.py

+import torch.nn as nn
+import torch.nn as nn
+import torch
+
+
+class AlexNet(nn.Module):
+    def __init__(self, num_classes=1000, init_weights=False):
+        super(AlexNet, self).__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 48, kernel_size=11, stride=4, padding=2),  # input[3, 224, 224]  output[48, 55, 55]
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[48, 27, 27]
+            nn.Conv2d(48, 128, kernel_size=5, padding=2),           # output[128, 27, 27]
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[128, 13, 13]
+            nn.Conv2d(128, 192, kernel_size=3, padding=1),          # output[192, 13, 13]
+            nn.ReLU(inplace=True),
+            nn.Conv2d(192, 192, kernel_size=3, padding=1),          # output[192, 13, 13]
+            nn.ReLU(inplace=True),
+            nn.Conv2d(192, 128, kernel_size=3, padding=1),          # output[128, 13, 13]
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[128, 6, 6]
+        )
+        self.classifier = nn.Sequential(
+            nn.Dropout(p=0.5),
+            nn.Linear(128 * 6 * 6, 2048),
+            nn.ReLU(inplace=True),
+            nn.Dropout(p=0.5),
+            nn.Linear(2048, 2048),
+            nn.ReLU(inplace=True),
+            nn.Linear(2048, num_classes),
+        )
+        if init_weights:
+            self._initialize_weights()
+
+    def forward(self, x):
+        x = self.features(x)
+        x = torch.flatten(x, start_dim=1)
+        x = self.classifier(x)
+        return x
+
+    def _initialize_weights(self):
+        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.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                nn.init.constant_(m.bias, 0)

实战代码/AlexNet作业（补充）/Test2_alexnet/predict.py

+import os
+import os
+import json
+
+import torch
+from PIL import Image
+from torchvision import transforms
+import matplotlib.pyplot as plt
+
+from model import AlexNet
+
+
+def main():
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+    data_transform = transforms.Compose(
+        [transforms.Resize((224, 224)),
+         transforms.ToTensor(),
+         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
+
+    # load image
+    img_path = "../tulip.jpg"
+    assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
+    img = Image.open(img_path)
+
+    plt.imshow(img)
+    # [N, C, H, W]
+    img = data_transform(img)
+    # expand batch dimension
+    img = torch.unsqueeze(img, dim=0)
+
+    # read class_indict
+    json_path = './class_indices.json'
+    assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)
+
+    with open(json_path, "r") as f:
+        class_indict = json.load(f)
+
+    # create model
+    model = AlexNet(num_classes=5).to(device)
+
+    # load model weights
+    weights_path = "./AlexNet.pth"
+    assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
+    model.load_state_dict(torch.load(weights_path))
+
+    model.eval()
+    with torch.no_grad():
+        # predict class
+        output = torch.squeeze(model(img.to(device))).cpu()
+        predict = torch.softmax(output, dim=0)
+        predict_cla = torch.argmax(predict).numpy()
+
+    print_res = "class: {}   prob: {:.3}".format(class_indict[str(predict_cla)],
+                                                 predict[predict_cla].numpy())
+    plt.title(print_res)
+    for i in range(len(predict)):
+        print("class: {:10}   prob: {:.3}".format(class_indict[str(i)],
+                                                  predict[i].numpy()))
+    plt.show()
+
+
+if __name__ == '__main__':
+    main()

实战代码/AlexNet作业（补充）/Test2_alexnet/train.py

+import os
+import os
+import sys
+import json
+
+import torch
+import torch.nn as nn
+from torchvision import transforms, datasets, utils
+import matplotlib.pyplot as plt
+import numpy as np
+import torch.optim as optim
+from tqdm import tqdm
+
+from model import AlexNet
+
+
+def main():
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    print("using {} device.".format(device))
+
+    data_transform = {
+        "train": transforms.Compose([transforms.RandomResizedCrop(224),
+                                     transforms.RandomHorizontalFlip(),
+                                     transforms.ToTensor(),
+                                     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
+        "val": transforms.Compose([transforms.Resize((224, 224)),  # cannot 224, must (224, 224)
+                                   transforms.ToTensor(),
+                                   transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}
+
+    data_root = os.path.abspath(os.path.join(os.getcwd(), "../.."))  # get data root path
+    image_path = os.path.join(data_root, "data_set", "flower_data")  # flower data set path
+    assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
+    train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
+                                         transform=data_transform["train"])
+    train_num = len(train_dataset)
+
+    # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
+    flower_list = train_dataset.class_to_idx
+    cla_dict = dict((val, key) for key, val in flower_list.items())
+    # write dict into json file
+    json_str = json.dumps(cla_dict, indent=4)
+    with open('class_indices.json', 'w') as json_file:
+        json_file.write(json_str)
+
+    batch_size = 32
+    nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # number of workers
+    print('Using {} dataloader workers every process'.format(nw))
+
+    train_loader = torch.utils.data.DataLoader(train_dataset,
+                                               batch_size=batch_size, shuffle=True,
+                                               num_workers=nw)
+
+    validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
+                                            transform=data_transform["val"])
+    val_num = len(validate_dataset)
+    validate_loader = torch.utils.data.DataLoader(validate_dataset,
+                                                  batch_size=4, shuffle=False,
+                                                  num_workers=nw)
+
+    print("using {} images for training, {} images for validation.".format(train_num,
+                                                                           val_num))
+    # test_data_iter = iter(validate_loader)
+    # test_image, test_label = test_data_iter.next()
+    #
+    # def imshow(img):
+    #     img = img / 2 + 0.5  # unnormalize
+    #     npimg = img.numpy()
+    #     plt.imshow(np.transpose(npimg, (1, 2, 0)))
+    #     plt.show()
+    #
+    # print(' '.join('%5s' % cla_dict[test_label[j].item()] for j in range(4)))
+    # imshow(utils.make_grid(test_image))
+
+    net = AlexNet(num_classes=5, init_weights=True)
+
+    net.to(device)
+    loss_function = nn.CrossEntropyLoss()
+    # pata = list(net.parameters())
+    optimizer = optim.Adam(net.parameters(), lr=0.0002)
+
+    epochs = 10
+    save_path = './AlexNet.pth'
+    best_acc = 0.0
+    train_steps = len(train_loader)
+    for epoch in range(epochs):
+        # train
+        net.train()
+        running_loss = 0.0
+        train_bar = tqdm(train_loader, file=sys.stdout)
+        for step, data in enumerate(train_bar):
+            images, labels = data
+            optimizer.zero_grad()
+            outputs = net(images.to(device))
+            loss = loss_function(outputs, labels.to(device))
+            loss.backward()
+            optimizer.step()
+
+            # print statistics
+            running_loss += loss.item()
+
+            train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
+                                                                     epochs,
+                                                                     loss)
+
+        # validate
+        net.eval()
+        acc = 0.0  # accumulate accurate number / epoch
+        with torch.no_grad():
+            val_bar = tqdm(validate_loader, file=sys.stdout)
+            for val_data in val_bar:
+                val_images, val_labels = val_data
+                outputs = net(val_images.to(device))
+                predict_y = torch.max(outputs, dim=1)[1]
+                acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
+
+        val_accurate = acc / val_num
+        print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
+              (epoch + 1, running_loss / train_steps, val_accurate))
+
+        if val_accurate > best_acc:
+            best_acc = val_accurate
+            torch.save(net.state_dict(), save_path)
+
+    print('Finished Training')
+
+
+if __name__ == '__main__':
+    main()

实战代码/AlexNet实战/AlexNet/README.md

+# AlexNet花朵分类
+# AlexNet花朵分类
+
+这是一个使用AlexNet模型进行花朵分类的训练脚本。它使用了PyTorch库来定义模型、加载数据集、训练模型等。
+
+## 依赖
+
+- Python 3.x
+- PyTorch
+- torchvision
+
+## 数据集准备
+
+1. 下载花朵分类数据集，并将其放置在适当的位置。
+ flower数据集到百度云盘下载
+2. 数据集文件夹结构应如下所示：
+├── AlexNet
+├── flower
+│ ├── flower_photos
+│ │ ├── class1
+│ │ ├── class2
+│ │ ├── ...
+│ │ └── classN
+│ ├── train
+│ │ ├── class1
+│ │ ├── class2
+│ │ ├── ...
+│ │ └── classN
+│ └── val
+│ ├── class1
+│ ├── class2
+│ ├── ...
+│ └── classN
+- `train`文件夹包含训练集图像，每个类别的图像应放在对应的子文件夹中。
+- `val`文件夹包含验证集图像，也按照类别分别放置在子文件夹中。
+
+3. 在`train.py`文件中的`data_path`变量中设置数据集的绝对路径。
+
+## 使用方法
+
+运行以下命令开始训练模型：
+
+python train.py
+
+## 参数调整
+
+- 可以在`main.py`文件中根据需要调整以下参数：
+  - `batch_size`：每个批次的样本数量。
+  - `lr`：学习率。
+  - `epochs`：训练的总轮数。
+  - `save_path`：保存模型的路径。
+  - ...
+
+## 模型保存
+
+训练过程中，模型会在验证集上表现优于之前的最佳模型时进行保存。模型会保存在`classification/AlexNet/checkpoints/AlexNet_for_flower.pth`路径下。
+
+## 注意事项
+
+- 在运行代码之前，请确保已安装所需的依赖项。
+- 请根据实际情况设置数据集路径和其他参数。
+- 请确保拥有足够的计算资源和训练时间。
+
+如果有任何问题或需要进一步帮助，请随时提问。
+
+

实战代码/AlexNet实战/AlexNet/__init__.py

+ 
+ 
\ No newline at end of file

实战代码/AlexNet实战/AlexNet/class_indices.json

+{
+{
+    "0": "daisy",
+    "1": "dandelion",
+    "2": "roses",
+    "3": "sunflowers",
+    "4": "tulips"
+}
\ No newline at end of file

实战代码/AlexNet实战/AlexNet/model.py

+import torch.nn as nn
+import torch.nn as nn
+import torch
+
+class AlexNet(nn.Module):
+    def __init__(self, num_class, init_weights=False):
+        super().__init__()
+        self.features = nn.Sequential(
+
+            nn.Conv2d(3,48,kernel_size=11, stride=4, padding=2), #in[3,224,224] ==> out[48,55,55]
+            nn.ReLU(True),
+            nn.MaxPool2d(kernel_size=3,stride=2),                # out[48,27,27]
+
+            nn.Conv2d(48,128,kernel_size=5,padding=2),           # out[128,27,27]   (K=5,s=1,p=2 conv size no change)
+            nn.ReLU(True),
+            nn.MaxPool2d(kernel_size=3,stride=2),                # out [128,13,13]
+
+            nn.Conv2d(128, 192, kernel_size=3, padding=1),       # out [192,13,13]  (K=3,s=1,p=1 conv size no change)
+            nn.ReLU(True),
+
+            nn.Conv2d(192,192, kernel_size=3,padding=1),         # out [192,13,13]
+            nn.ReLU(True),
+
+            nn.Conv2d(192, 128, kernel_size=3, padding=1),       # out [128,13,13]
+            nn.ReLU(True),
+            nn.MaxPool2d(kernel_size=3, stride=2)                # out [128,6,6]
+        )
+
+        self.classifer = nn.Sequential(
+            nn.Dropout(p=0.5),
+            nn.Linear(128*6*6, 2048),
+            nn.ReLU(inplace=True),
+            nn.Dropout(p=0.5),
+            nn.Linear(2048,2048),
+            nn.ReLU(True),
+            nn.Linear(2048, num_class)
+        )
+
+        if init_weights:
+            self._initialize_weights()
+    
+    def forward(self, x):
+        x = self.features(x)
+        x = torch.flatten(x, start_dim=1) 
+        x = self.classifer(x)
+        return x
+    
+    def _initialize_weights(self):
+        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.Linear):
+                nn.init.normal_(m.weight,0,0.01)
+                nn.init.constant_(m.bias,0)
\ No newline at end of file

实战代码/AlexNet实战/AlexNet/test.py

+import os
+import os
+import json 
+import torch
+from PIL import Image
+from torchvision import transforms
+import matplotlib.pyplot as plt
+
+from model import AlexNet
+
+def main():
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    print("using {} device".format(device))
+    
+    data_transform = transforms.Compose(
+        [transforms.Resize((224,224)),
+         transforms.ToTensor(),
+         transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))]
+    )
+    
+    # load_image
+    img_path = "D:\\VSworkspace\\code\\flower\\val\\roses\\1402130395_0b89d76029.jpg"
+    assert os.path.exists(img_path), "file '{}' does not exit".format(img_path)
+    img = Image.open(img_path)
+    plt.imshow(img) 
+    
+    img = data_transform(img)
+    img = torch.unsqueeze(img, dim=0)
+    
+    json_path = "D:\\VSworkspace\\code\\classification\\AlexNet\\class_indices.json"
+    assert os.path.exists(json_path), "file '{}' does not exit".format(json_path)
+    json_file = open(json_path, "r")
+    class_index = json.load(json_file)  # {'0': 'daisy', '1': 'dandelion', '2': 'roses', '3': 'sunflowers', '4': 'tulips'}
+    
+    # create model and load parameters
+    model = AlexNet(num_class=5).to(device)
+    weights_path = 'D:\\VSworkspace\\code\\classification\\AlexNet\\checkpoints\\AlexNet_for_flower.pth'
+    assert os.path.exists(weights_path), "file '{}' does not exit".format(weights_path)   
+    model.load_state_dict(torch.load(weights_path))
+    
+    # infer
+    model.eval()
+    with torch.no_grad():
+        # predict class
+        output = torch.squeeze(model(img.to(device))).cpu()
+        predict = torch.softmax(output, dim=0) 
+        predict_class = torch.argmax(predict).numpy()
+    
+    print_res = "class: {}   prob: {:.3}".format(class_index[str(predict_class)],
+                                                 predict[predict_class].numpy())
+    plt.title(print_res)
+    for i in range(len(predict)):
+        print("class: {:10}   prob: {:.3}".format(class_index[str(i)],
+                                                  predict[i].numpy()))
+    plt.show()
+
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file

实战代码/AlexNet实战/AlexNet/train.py

+import torch
+import torch
+import torch.nn as nn
+
+import os
+import sys
+import json
+from torchvision import transforms, datasets, utils
+from torch.utils.data import DataLoader
+ 
+import numpy as np
+import torch.optim as optim 
+ 
+from model import AlexNet
+
+def main():
+    device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
+    print('using{} device.'.format(device))
+    
+    data_transform = {
+        "train": transforms.Compose(
+            [transforms.RandomResizedCrop(224),
+             transforms.RandomHorizontalFlip(),
+             transforms.ToTensor(), #把shape=(H x W x C) 的像素值为 [0, 255] 的 PIL.Image 和 numpy.ndarray转换成shape=(C,H,WW)的像素值范围为[0.0, 1.0]的 torch.FloatTensor
+             transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
+             ]
+        ),
+        "test":transforms.Compose(
+            [transforms.Resize((224,224)),
+             transforms.ToTensor(),
+             transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
+             ]
+        )
+    }
+    
+    data_path = os.path.abspath(os.path.join(os.getcwd(), "flower")) 
+    train_dataset = datasets.ImageFolder(root=os.path.join(data_path, "train"), transform=data_transform["train"]) 
+    vaild_dataset = datasets.ImageFolder(root=os.path.join(data_path, "val"), transform=data_transform["test"])
+    train_num = len(train_dataset)
+    test_num = len(vaild_dataset)
+    
+     # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
+    flower_list = train_dataset.class_to_idx
+    class_dict = dict((val, key) for key, val in flower_list.items())
+    
+    # write label into json file
+    json_str = json.dumps(class_dict, indent=4)  # 将一个Python数据结构转换为JSON,  indent:参数根据数据格式缩进显示，读起来更加清晰。
+    with open(os.path.abspath(os.path.join(os.getcwd(), 'classification\\AlexNet\\class_indices.json')), 'w') as json_file:
+        json_file.write(json_str)
+    
+    batch_size = 32
+    n_works = min([os.cpu_count(), batch_size if batch_size >1 else 0, 9])
+    print('Using {} dataloader workers every process'.format(n_works))
+    
+    train_loader = DataLoader(train_dataset, batch_size, shuffle=True, num_workers=n_works, drop_last=True)
+    valid_loader = DataLoader(vaild_dataset, batch_size=4, shuffle=False, num_workers=n_works, drop_last=True)
+    
+    print('using {} images for traing and using {} images for testing'.format(train_num, test_num))
+    
+    net = AlexNet(num_class=5, init_weights=True)
+    net.to(device)
+    loss_function = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(net.parameters(), lr=0.0002)
+    
+    epochs = 10
+    save_path = os.path.join(os.getcwd(), 'classification\\AlexNet\\checkpoints\\AlexNet_for_flower.pth')
+    best_acc = 0.0
+    train_steps = len(train_loader)  
+ 
+    # training
+    
+    for epoch in range(epochs):
+        net.train()
+        running_loss = 0.0  
+        for step, data in enumerate(train_loader):
+            images, labels = data 
+            optimizer.zero_grad()
+            outputs = net(images.to(device))
+            loss = loss_function(outputs, labels.to(device))
+            loss.backward()
+            optimizer.step()
+
+            # print statistics
+            running_loss += loss.item()
+            print("Epoch" +str(epoch)+ ": processing:" + str(step) + "/" + str(train_steps))
+
+        # validate
+        net.eval()
+        acc = 0.0  # accumulate accurate number / epoch
+        with torch.no_grad(): 
+            for val_data in valid_loader:
+                val_images, val_labels = val_data
+                outputs = net(val_images.to(device))
+                predict_y = torch.max(outputs, dim=1)[1]
+                acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
+
+        val_accurate = acc / test_num
+        print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
+              (epoch + 1, running_loss / train_steps, val_accurate))
+
+        if val_accurate > best_acc:
+            best_acc = val_accurate
+            torch.save(net.state_dict(), save_path)
+
+    print('Finished Training')
+
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file

实战代码/AlexNet实战（补充）/AlexNet/README.md

+# AlexNet花朵分类
+# AlexNet花朵分类
+
+这是一个使用AlexNet模型进行花朵分类的训练脚本。它使用了PyTorch库来定义模型、加载数据集、训练模型等。
+
+## 依赖
+
+- Python 3.x
+- PyTorch
+- torchvision
+
+## 数据集准备
+
+1. 下载花朵分类数据集，并将其放置在适当的位置。
+ flower数据集到百度云盘下载
+2. 数据集文件夹结构应如下所示：
+├── AlexNet
+├── flower
+│ ├── flower_photos
+│ │ ├── class1
+│ │ ├── class2
+│ │ ├── ...
+│ │ └── classN
+│ ├── train
+│ │ ├── class1
+│ │ ├── class2
+│ │ ├── ...
+│ │ └── classN
+│ └── val
+│ ├── class1
+│ ├── class2
+│ ├── ...
+│ └── classN
+- `train`文件夹包含训练集图像，每个类别的图像应放在对应的子文件夹中。
+- `val`文件夹包含验证集图像，也按照类别分别放置在子文件夹中。
+
+3. 在`train.py`文件中的`data_path`变量中设置数据集的绝对路径。
+
+## 使用方法
+
+运行以下命令开始训练模型：
+
+python train.py
+
+## 参数调整
+
+- 可以在`main.py`文件中根据需要调整以下参数：
+  - `batch_size`：每个批次的样本数量。
+  - `lr`：学习率。
+  - `epochs`：训练的总轮数。
+  - `save_path`：保存模型的路径。
+  - ...
+
+## 模型保存
+
+训练过程中，模型会在验证集上表现优于之前的最佳模型时进行保存。模型会保存在`classification/AlexNet/checkpoints/AlexNet_for_flower.pth`路径下。
+
+## 注意事项
+
+- 在运行代码之前，请确保已安装所需的依赖项。
+- 请根据实际情况设置数据集路径和其他参数。
+- 请确保拥有足够的计算资源和训练时间。
+
+如果有任何问题或需要进一步帮助，请随时提问。
+
+

实战代码/AlexNet实战（补充）/AlexNet/__init__.py

+ 
+ 
\ No newline at end of file

实战代码/AlexNet实战（补充）/AlexNet/class_indices.json

+{
+{
+    "0": "daisy",
+    "1": "dandelion",
+    "2": "roses",
+    "3": "sunflowers",
+    "4": "tulips"
+}
\ No newline at end of file

实战代码/AlexNet实战（补充）/AlexNet/model.py

+import torch.nn as nn
+import torch.nn as nn
+import torch
+
+class AlexNet(nn.Module):
+    def __init__(self, num_class, init_weights=False):
+        super().__init__()
+        self.features = nn.Sequential(
+
+            nn.Conv2d(3,48,kernel_size=11, stride=4, padding=2), #in[3,224,224] ==> out[48,55,55]
+            nn.ReLU(True),
+            nn.MaxPool2d(kernel_size=3,stride=2),                # out[48,27,27]
+
+            nn.Conv2d(48,128,kernel_size=5,padding=2),           # out[128,27,27]   (K=5,s=1,p=2 conv size no change)
+            nn.ReLU(True),
+            nn.MaxPool2d(kernel_size=3,stride=2),                # out [128,13,13]
+
+            nn.Conv2d(128, 192, kernel_size=3, padding=1),       # out [192,13,13]  (K=3,s=1,p=1 conv size no change)
+            nn.ReLU(True),
+
+            nn.Conv2d(192,192, kernel_size=3,padding=1),         # out [192,13,13]
+            nn.ReLU(True),
+
+            nn.Conv2d(192, 128, kernel_size=3, padding=1),       # out [128,13,13]
+            nn.ReLU(True),
+            nn.MaxPool2d(kernel_size=3, stride=2)                # out [128,6,6]
+        )
+
+        self.classifer = nn.Sequential(
+            nn.Dropout(p=0.5),
+            nn.Linear(128*6*6, 2048),
+            nn.ReLU(inplace=True),
+            nn.Dropout(p=0.5),
+            nn.Linear(2048,2048),
+            nn.ReLU(True),
+            nn.Linear(2048, num_class)
+        )
+
+        if init_weights:
+            self._initialize_weights()
+    
+    def forward(self, x):
+        x = self.features(x)
+        x = torch.flatten(x, start_dim=1) 
+        x = self.classifer(x)
+        return x
+    
+    def _initialize_weights(self):
+        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.Linear):
+                nn.init.normal_(m.weight,0,0.01)
+                nn.init.constant_(m.bias,0)
\ No newline at end of file

实战代码/AlexNet实战（补充）/AlexNet/test.py

+import os
+import os
+import json 
+import torch
+from PIL import Image
+from torchvision import transforms
+import matplotlib.pyplot as plt
+
+from model import AlexNet
+
+def main():
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    print("using {} device".format(device))
+    
+    data_transform = transforms.Compose(
+        [transforms.Resize((224,224)),
+         transforms.ToTensor(),
+         transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))]
+    )
+    
+    # load_image
+    img_path = "D:\\VSworkspace\\code\\flower\\val\\roses\\1402130395_0b89d76029.jpg"
+    assert os.path.exists(img_path), "file '{}' does not exit".format(img_path)
+    img = Image.open(img_path)
+    plt.imshow(img) 
+    
+    img = data_transform(img)
+    img = torch.unsqueeze(img, dim=0)
+    
+    json_path = "D:\\VSworkspace\\code\\classification\\AlexNet\\class_indices.json"
+    assert os.path.exists(json_path), "file '{}' does not exit".format(json_path)
+    json_file = open(json_path, "r")
+    class_index = json.load(json_file)  # {'0': 'daisy', '1': 'dandelion', '2': 'roses', '3': 'sunflowers', '4': 'tulips'}
+    
+    # create model and load parameters
+    model = AlexNet(num_class=5).to(device)
+    weights_path = 'D:\\VSworkspace\\code\\classification\\AlexNet\\checkpoints\\AlexNet_for_flower.pth'
+    assert os.path.exists(weights_path), "file '{}' does not exit".format(weights_path)   
+    model.load_state_dict(torch.load(weights_path))
+    
+    # infer
+    model.eval()
+    with torch.no_grad():
+        # predict class
+        output = torch.squeeze(model(img.to(device))).cpu()
+        predict = torch.softmax(output, dim=0) 
+        predict_class = torch.argmax(predict).numpy()
+    
+    print_res = "class: {}   prob: {:.3}".format(class_index[str(predict_class)],
+                                                 predict[predict_class].numpy())
+    plt.title(print_res)
+    for i in range(len(predict)):
+        print("class: {:10}   prob: {:.3}".format(class_index[str(i)],
+                                                  predict[i].numpy()))
+    plt.show()
+
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file

实战代码/AlexNet实战（补充）/AlexNet/train.py

+import torch
+import torch
+import torch.nn as nn
+
+import os
+import sys
+import json
+from torchvision import transforms, datasets, utils
+from torch.utils.data import DataLoader
+ 
+import numpy as np
+import torch.optim as optim 
+ 
+from model import AlexNet
+
+def main():
+    device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
+    print('using{} device.'.format(device))
+    
+    data_transform = {
+        "train": transforms.Compose(
+            [transforms.RandomResizedCrop(224),
+             transforms.RandomHorizontalFlip(),
+             transforms.ToTensor(), #把shape=(H x W x C) 的像素值为 [0, 255] 的 PIL.Image 和 numpy.ndarray转换成shape=(C,H,WW)的像素值范围为[0.0, 1.0]的 torch.FloatTensor
+             transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
+             ]
+        ),
+        "test":transforms.Compose(
+            [transforms.Resize((224,224)),
+             transforms.ToTensor(),
+             transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
+             ]
+        )
+    }
+    
+    data_path = os.path.abspath(os.path.join(os.getcwd(), "flower")) 
+    train_dataset = datasets.ImageFolder(root=os.path.join(data_path, "train"), transform=data_transform["train"]) 
+    vaild_dataset = datasets.ImageFolder(root=os.path.join(data_path, "val"), transform=data_transform["test"])
+    train_num = len(train_dataset)
+    test_num = len(vaild_dataset)
+    
+     # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
+    flower_list = train_dataset.class_to_idx
+    class_dict = dict((val, key) for key, val in flower_list.items())
+    
+    # write label into json file
+    json_str = json.dumps(class_dict, indent=4)  # 将一个Python数据结构转换为JSON,  indent:参数根据数据格式缩进显示，读起来更加清晰。
+    with open(os.path.abspath(os.path.join(os.getcwd(), 'classification\\AlexNet\\class_indices.json')), 'w') as json_file:
+        json_file.write(json_str)
+    
+    batch_size = 32
+    n_works = min([os.cpu_count(), batch_size if batch_size >1 else 0, 9])
+    print('Using {} dataloader workers every process'.format(n_works))
+    
+    train_loader = DataLoader(train_dataset, batch_size, shuffle=True, num_workers=n_works, drop_last=True)
+    valid_loader = DataLoader(vaild_dataset, batch_size=4, shuffle=False, num_workers=n_works, drop_last=True)
+    
+    print('using {} images for traing and using {} images for testing'.format(train_num, test_num))
+    
+    net = AlexNet(num_class=5, init_weights=True)
+    net.to(device)
+    loss_function = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(net.parameters(), lr=0.0002)
+    
+    epochs = 10
+    save_path = os.path.join(os.getcwd(), 'classification\\AlexNet\\checkpoints\\AlexNet_for_flower.pth')
+    best_acc = 0.0
+    train_steps = len(train_loader)  
+ 
+    # training
+    
+    for epoch in range(epochs):
+        net.train()
+        running_loss = 0.0  
+        for step, data in enumerate(train_loader):
+            images, labels = data 
+            optimizer.zero_grad()
+            outputs = net(images.to(device))
+            loss = loss_function(outputs, labels.to(device))
+            loss.backward()
+            optimizer.step()
+
+            # print statistics
+            running_loss += loss.item()
+            print("Epoch" +str(epoch)+ ": processing:" + str(step) + "/" + str(train_steps))
+
+        # validate
+        net.eval()
+        acc = 0.0  # accumulate accurate number / epoch
+        with torch.no_grad(): 
+            for val_data in valid_loader:
+                val_images, val_labels = val_data
+                outputs = net(val_images.to(device))
+                predict_y = torch.max(outputs, dim=1)[1]
+                acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
+
+        val_accurate = acc / test_num
+        print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
+              (epoch + 1, running_loss / train_steps, val_accurate))
+
+        if val_accurate > best_acc:
+            best_acc = val_accurate
+            torch.save(net.state_dict(), save_path)
+
+    print('Finished Training')
+
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file

实战代码/AlexNet实战（补充）/补充资料.adoc

+++ "a/\345\256\236\346\210\230\344\273\243\347\240\201/AlexNet\345\256\236\346\210\230\357\274\210\350\241\245\345\205\205\357\274\211/\350\241\245\345\205\205\350\265\204\346\226\231.adoc"

实战代码/Bert_lstm_crf命名实体识别/.ipynb_checkpoints/ner模型-checkpoint.ipynb

+{
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

实战代码/Bert_lstm_crf命名实体识别/.ipynb_checkpoints/ner模型加载-checkpoint.ipynb

+{
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

实战代码/Bert_lstm_crf命名实体识别/.ipynb_checkpoints/pyltp使用-checkpoint.ipynb

+{
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

实战代码/Bert_lstm_crf命名实体识别/.ipynb_checkpoints/torch_crf使用-checkpoint.ipynb

+{
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

实战代码/Bert_lstm_crf命名实体识别/README.md

+### ner模型
+### ner模型
+
+- 数据集在data目录下
+- 模型使用的是ner模型
+- 先运行torch-crf使用.ipynb看一下torch-crf的基本操作
+- 然后运行ner模型.ipynb 训练模型
+- 模型加载预测运行ner模型加载.ipynb
\ No newline at end of file

实战代码/Bert_lstm_crf命名实体识别/ltp使用.ipynb

+{
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "0ce30825",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#序列标注\n",
+    "# HMM,MEMM,CRF概率图模型\n",
+    "# 序列标注任务经常用于句法分析，比如词性标注，分词， 命名实体识别，依存句法， 语义角色分析\n",
+    "# 机器阅读理解、抽取式的文本摘要经常也会作为序列标注任务处理\n",
+    "# 句法分析工具 pyltp, hanlp, stanfordnlp,snownlp.... nltk"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "30d71ced",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['今天', '中午', '吃', '什么']"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# 分词\n",
+    "from pyltp import Segmentor\n",
+    "\n",
+    "cws_path = 'D:/nlp_model/ltp_data_v3.4.0/cws.model'\n",
+    "\n",
+    "segmentor = Segmentor()\n",
+    "segmentor.load(cws_path)\n",
+    "\n",
+    "words = segmentor.segment('今天中午吃什么')\n",
+    "list(words)\n",
+    "\n",
+    "# segmentor.release()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "4550d9e8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['姚', '明', '是', '叶莉', '的', '老公']\n",
+      "['nh', 'nh', 'v', 'nh', 'u', 'n']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 词性标注\n",
+    "from pyltp import Postagger\n",
+    "\n",
+    "pos_path = 'D:/nlp_model/ltp_data_v3.4.0/pos.model'\n",
+    "\n",
+    "postagger = Postagger()\n",
+    "postagger.load(pos_path)\n",
+    "\n",
+    "sen = '姚明是叶莉的老公'\n",
+    "\n",
+    "words = segmentor.segment(sen)\n",
+    "postags = postagger.postag(words)\n",
+    "print(list(words))\n",
+    "print(list(postags))\n",
+    "\n",
+    "postagger.release()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "feeee75c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['O', 'O', 'O', 'S-Nh', 'O', 'O']\n"
+     ]
+    }
+   ],
+   "source": [
+    "#命名实体识别\n",
+    "from pyltp import NamedEntityRecognizer\n",
+    "\n",
+    "ner_path = 'D:/nlp_model/ltp_data_v3.4.0/ner.model'\n",
+    "\n",
+    "recognizer = NamedEntityRecognizer()\n",
+    "recognizer.load(ner_path)\n",
+    "\n",
+    "netags = recognizer.recognize(words,postags)\n",
+    "print(list(netags))\n",
+    "\n",
+    "recognizer.release()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "dfb55feb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2 ATT\n",
+      "3 SBV\n",
+      "0 HED\n",
+      "6 ATT\n",
+      "4 RAD\n",
+      "3 VOB\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<bound method release of <pyltp.Parser object at 0x0000022589E39618>>"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from pyltp import Parser\n",
+    "\n",
+    "par_path = 'D:/nlp_model/ltp_data_v3.4.0/parser.model'\n",
+    "\n",
+    "parser = Parser()\n",
+    "parser.load(par_path)\n",
+    "\n",
+    "arcs = parser.parse(words,postags)\n",
+    "\n",
+    "for arc in arcs:\n",
+    "    print(arc.head,arc.relation)\n",
+    "\n",
+    "parser.release"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "c76d2e6b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "A0 0 1\n",
+      "A1 3 5\n"
+     ]
+    }
+   ],
+   "source": [
+    "#语义角色标注\n",
+    "from pyltp import SementicRoleLabeller\n",
+    "\n",
+    "srl_path = 'D:/nlp_model/ltp_data_v3.4.0/pisrl_win.model'\n",
+    "\n",
+    "labeller = SementicRoleLabeller()\n",
+    "labeller.load(srl_path)\n",
+    "\n",
+    "roles = labeller.label(words,postags,arcs)\n",
+    "\n",
+    "for role in roles:\n",
+    "    for arg in role.arguments:\n",
+    "        print(arg.name,arg.range.start,arg.range.end)\n",
+    "\n",
+    "labeller.release()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "3a0a3495",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'姚明是叶莉的老公'"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "65c61121",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "py36",
+   "language": "python",
+   "name": "py36"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

实战代码/Bert_lstm_crf命名实体识别/models/albert_chinese_small/.gitattributes

+*.bin.* filter=lfs diff=lfs merge=lfs -text
+*.bin.* filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tar.gz filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text

实战代码/Bert_lstm_crf命名实体识别/models/albert_chinese_small/config.json

+{
+{
+  "attention_probs_dropout_prob": 0.0,
+  "bos_token_id": 2,
+  "classifier_dropout_prob": 0.1,
+  "down_scale_factor": 1,
+  "embedding_size": 128,
+  "eos_token_id": 3,
+  "gap_size": 0,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.0,
+  "hidden_size": 384,
+  "initializer_range": 0.02,
+  "inner_group_num": 1,
+  "intermediate_size": 1536,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "albert",
+  "net_structure_type": 0,
+  "num_attention_heads": 12,
+  "num_hidden_groups": 1,
+  "num_hidden_layers": 6,
+  "num_memory_blocks": 0,
+  "pad_token_id": 0,
+  "type_vocab_size": 2,
+  "vocab_size": 21128
+}

实战代码/Bert_lstm_crf命名实体识别/models/albert_chinese_small/pytorch_model.bin

+version https://git-lfs.github.com/spec/v1
+version https://git-lfs.github.com/spec/v1
+oid sha256:a480185be5bf98c486b2156fe9b5b5b221b1014b8c29e0cbf2fb1f3cb09e12ee
+size 19258882

实战代码/Bert_lstm_crf命名实体识别/models/albert_chinese_tiny/README.md

+---
+---
+language: zh
+---
+
+# albert_chinese_tiny
+
+This a albert_chinese_tiny model from [brightmart/albert_zh project](https://github.com/brightmart/albert_zh), albert_tiny_google_zh model    
+converted by huggingface's [script](https://github.com/huggingface/transformers/blob/master/src/transformers/convert_albert_original_tf_checkpoint_to_pytorch.py)
+
+## Attention (注意)
+
+Since sentencepiece is not used in albert_chinese_tiny model   
+you have to call BertTokenizer instead of AlbertTokenizer !!!    
+we can eval it using an example on MaskedLM   
+   
+由於 albert_chinese_tiny 模型沒有用 sentencepiece   
+用AlbertTokenizer會載不進詞表，因此需要改用BertTokenizer !!!   
+我們可以跑MaskedLM預測來驗證這個做法是否正確   
+   
+## Justify (驗證有效性)
+[colab trial](https://colab.research.google.com/drive/1Wjz48Uws6-VuSHv_-DcWLilv77-AaYgj)   
+```python
+from transformers import *
+import torch
+from torch.nn.functional import softmax
+
+pretrained = 'voidful/albert_chinese_tiny'
+tokenizer = BertTokenizer.from_pretrained(pretrained)
+model = AlbertForMaskedLM.from_pretrained(pretrained)
+
+inputtext = "今天[MASK]情很好"
+
+maskpos = tokenizer.encode(inputtext, add_special_tokens=True).index(103)
+
+input_ids = torch.tensor(tokenizer.encode(inputtext, add_special_tokens=True)).unsqueeze(0)  # Batch size 1
+outputs = model(input_ids, masked_lm_labels=input_ids)
+loss, prediction_scores = outputs[:2]
+logit_prob = softmax(prediction_scores[0, maskpos]).data.tolist()
+predicted_index = torch.argmax(prediction_scores[0, maskpos]).item()
+predicted_token = tokenizer.convert_ids_to_tokens([predicted_index])[0]
+print(predicted_token,logit_prob[predicted_index])
+```
+Result: `感 0.40312355756759644`   

实战代码/Bert_lstm_crf命名实体识别/models/albert_chinese_tiny/config.json

+{
+{
+  "attention_probs_dropout_prob": 0.0,
+  "bos_token_id": 2,
+  "classifier_dropout_prob": 0.1,
+  "down_scale_factor": 1,
+  "embedding_size": 128,
+  "eos_token_id": 3,
+  "gap_size": 0,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.0,
+  "hidden_size": 312,
+  "initializer_range": 0.02,
+  "inner_group_num": 1,
+  "intermediate_size": 1248,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "albert",
+  "net_structure_type": 0,
+  "num_attention_heads": 12,
+  "num_hidden_groups": 1,
+  "num_hidden_layers": 4,
+  "num_memory_blocks": 0,
+  "pad_token_id": 0,
+  "type_vocab_size": 2,
+  "vocab_size": 21128
+}

实战代码/Bert_lstm_crf命名实体识别/models/albert_zh/config.json

+{
+{
+  "attention_probs_dropout_prob": 0.0,
+  "bos_token_id": 2,
+  "classifier_dropout_prob": 0.1,
+  "down_scale_factor": 1,
+  "embedding_size": 128,
+  "eos_token_id": 3,
+  "gap_size": 0,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.0,
+  "hidden_size": 312,
+  "initializer_range": 0.02,
+  "inner_group_num": 1,
+  "intermediate_size": 1248,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "albert",
+  "net_structure_type": 0,
+  "num_attention_heads": 12,
+  "num_hidden_groups": 1,
+  "num_hidden_layers": 4,
+  "num_memory_blocks": 0,
+  "pad_token_id": 0,
+  "type_vocab_size": 2,
+  "vocab_size": 21128
+}

实战代码/Bert_lstm_crf命名实体识别/ner模型加载.ipynb

+{
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "0384ebe7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from transformers import AlbertModel, BertConfig,BertTokenizer\n",
+    "from TorchCRF import CRF\n",
+    "from torch.utils.data import Dataset,DataLoader\n",
+    "import pandas as pd\n",
+    "from sklearn import metrics\n",
+    "from transformers import AdamW, get_linear_schedule_with_warmup\n",
+    "import torch.optim as optim\n",
+    "from torch.utils import data\n",
+    "import time\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "808aae31",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Model(nn.Module):\n",
+    "\n",
+    "    def __init__(self,tag_num):\n",
+    "        super().__init__()\n",
+    "        self.bert = AlbertModel.from_pretrained('models/albert_zh/')\n",
+    "        config = self.bert.config\n",
+    "        self.lstm = nn.LSTM(bidirectional=True, num_layers=2, input_size=config.hidden_size, hidden_size=config.hidden_size//2, batch_first=True)\n",
+    "        self.crf = CRF(tag_num)\n",
+    "        self.fc = nn.Linear(config.hidden_size,tag_num)\n",
+    "\n",
+    "    def forward(self,x,y):\n",
+    "        #也可以不用lstm，只用bert参与训练\n",
+    "        with torch.no_grad():\n",
+    "            bert_output = self.bert(x)[0]\n",
+    "        lstm_output, _ = self.lstm(bert_output) \n",
+    "        fc_output = self.fc(lstm_output) \n",
+    "        loss = self.crf(fc_output,y) \n",
+    "        tag = self.crf.decode(fc_output) \n",
+    "        return loss,tag\n",
+    "    \n",
+    "     #前向传播是有label信息传过来的，预测的时候呢是没有label,只有特征\n",
+    "    def predict(self,x):\n",
+    "        with torch.no_grad():\n",
+    "            bert_output = self.bert(x)[0]\n",
+    "        lstm_output, _ = self.lstm(bert_output) \n",
+    "        fc_output = self.fc(lstm_output)\n",
+    "        tag = self.crf.decode(fc_output)\n",
+    "        return tag"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "187ae2fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tag2idx ={'O': 0,\n",
+    "     'I-ORG': 1,\n",
+    "     'I-LOC': 2,\n",
+    "     'B-LOC': 3,\n",
+    "     'I-PER': 4,\n",
+    "     'B-ORG': 5,\n",
+    "     'B-PER': 6,\n",
+    "     '[PAD]': 7,\n",
+    "     '[CLS]': 8,\n",
+    "     '[SEP]': 9}\n",
+    "idx2tag = {0: 'O',\n",
+    "     1: 'I-ORG',\n",
+    "     2: 'I-LOC',\n",
+    "     3: 'B-LOC',\n",
+    "     4: 'I-PER',\n",
+    "     5: 'B-ORG',\n",
+    "     6: 'B-PER',\n",
+    "     7: '[PAD]',\n",
+    "     8: '[CLS]',\n",
+    "     9: '[SEP]'}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1283f699",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tag_num = len(idx2tag)\n",
+    "model = Model(tag_num)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "49e54d66",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "state_dict = torch.load('ner.pt')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "2a5a7a9b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<All keys matched successfully>"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#加载保存的模型\n",
+    "model.load_state_dict(state_dict)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "5e20b1c3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenizer = BertTokenizer.from_pretrained('models/albert_zh/')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "b3cb48d8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'input_ids': tensor([[ 101, 4636, 2428, 3221,  671, 2157, 6763,  816, 1062, 1385,  102]]), 'token_type_ids': tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test_sen = '百度是一家软件公司'\n",
+    "tok = tokenizer(test_sen,return_tensors='pt')\n",
+    "tok"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "0b8969b7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[5], [1], [0], [0], [0], [0], [0], [0], [0]]"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.eval()\n",
+    "res = model.predict(tok['input_ids'])[1:-1]\n",
+    "res"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "9f2e3dff",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['B-ORG', 'I-ORG', 'O', 'O', 'O', 'O', 'O', 'O', 'O']"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ner_res = [idx2tag[i[0]] for i in res]\n",
+    "ner_res"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "952772c3",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a818d942",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "py36",
+   "language": "python",
+   "name": "py36"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

实战代码/Bert_lstm_crf命名实体识别/torch-crf使用.ipynb

+{
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "f8139911",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from TorchCRF import CRF"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "1627723e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 假设训练数据有5种label\n",
+    "num_tags = 5\n",
+    "model = CRF(num_tags)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "2966ead8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([[[ 1.9620, -1.0741,  0.8100,  0.6520, -1.0200],\n",
+       "         [-0.2064, -0.5976, -1.5270, -0.7896,  0.5321],\n",
+       "         [ 0.4330, -0.5478, -0.0669, -0.3608,  0.5404]]])"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# 构建一些数据测试下\n",
+    "seq_length = 3    #句子长度为3\n",
+    "batch_size = 1\n",
+    "\n",
+    "# 假设词向量的维度跟label的种类一样为Num_tags\n",
+    "# 相当于一个有三个词的句子，每个词的词向量为5维\n",
+    "vector = torch.randn(batch_size,seq_length,num_tags)\n",
+    "vector"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "b80b785b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#tag\n",
+    "tags = torch.tensor([[0,2,3]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "be21205c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[0], [4], [4]]"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#crf预测tag\n",
+    "model.decode(vector)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "42a33744",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor(-5.6217, grad_fn=<SumBackward0>)"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#计算损失\n",
+    "loss = model(vector,tags)\n",
+    "loss"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b8026ec9",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "py36",
+   "language": "python",
+   "name": "py36"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

实战代码/RNN实战/RNN系列演示/README.md

+# RNN文本分类与序列预测项目
+# RNN文本分类与序列预测项目
+
+本项目旨在使用递归神经网络（RNN）模型进行文本分类和序列预测任务。通过学习这些示例，您将能够理解如何使用RNN模型处理文本数据。
+
+## 目录结构
+
+项目的目录结构如下所示：
+
+- `financial_data/`：存放金融数据的文件夹。
+  - `fmxw.txt`：负向金融文本数据文件。
+  - `zmxxw.txt`：正向金融文本数据文件。
+- `vector/`：存放向量相关文件的文件夹。
+  - `embedding.npz`：嵌入向量文件。
+  - `vocab.pkl`：词汇表文件。
+- `RNN文本分类.ipynb`：文本分类任务的Jupyter Notebook文件。
+- `RNN序列预测.ipynb`：序列预测任务的Jupyter Notebook文件。
+
+## 数据准备
+
+金融数据位于`financial_data/`文件夹中的两个文件：`fmxw.txt`和`zmxxw.txt`。您可以根据自己的需求替换或添加更多的数据文件。
+
+## 向量文件
+
+向量文件位于`vector/`文件夹中，包括以下文件：
+
+- `embedding.npz`：包含嵌入向量的文件。
+- `vocab.pkl`：包含词汇表的文件。
+
+请确保这些文件位于正确的路径，并根据需要进行修改或扩展。
+
+## 使用示例
+
+以下是两个Jupyter Notebook文件的简要说明和使用示例：
+
+### RNN文本分类.ipynb
+
+该文件演示了如何使用RNN模型进行文本分类任务。它包括以下步骤：
+
+1. 数据准备和预处理。
+2. 构建RNN模型。
+3. 模型训练和评估。
+4. 预测新文本的分类。
+
+您可以打开`RNN文本分类.ipynb`文件，并按照其中的说明执行每个单元格，以了解和运行文本分类任务。
+
+### RNN序列预测.ipynb
+
+该文件演示了如何使用RNN模型进行序列预测任务。它包括以下步骤：
+
+1. 数据准备和预处理。
+2. 构建RNN模型。
+3. 模型训练和评估。
+4. 使用模型生成序列预测。
+
+您可以打开`RNN序列预测.ipynb`文件，并按照其中的说明执行每个单元格，以了解和运行序列预测任务。
+
+## 扩展和自定义
+
+您可以根据需要扩展和自定义项目，例如：
+
+- 添加更多的数据文件到`financial_data/`文件夹中，以增加训练数据的多样性。
+- 调整RNN模型的参数和架构，以优化性能。
+- 使用不同的嵌入向量和词汇表文件，或者训练自己的嵌入向量模型。
+
+请根据个人需求进行相应的修改和实验。
+
+## 依赖项安装与环境配置
+
+在运行项目代码之前，请确保已安装以下依赖项：
+
+- Python 3.x
+- Jupyter Notebook
+- TensorFlow
+- NumPy
+- Pandas
+
+您可以使用以下命令安装所需的Python库：
+
+```
+pip install jupyter tensorflow numpy pandas
+```
+
+## 运行项目
+
+1. 下载或克隆整个项目到本地计算机。
+2. 进入项目目录。
+3. 打开Jupyter Notebook，执行以下操作：
+   - 导航到`RNN文本分类.ipynb`或`RNN序列预测.ipynb`文件。
+   - 按照文件中的说明执行每个单元格。
+
+请确保数据文件和向量文件位于正确的位置，并在代码中使用正确的文件路径。
+
+如有任何疑问或需要进一步帮助，请随时提问。
+
+感谢您参与本项目！
\ No newline at end of file

实战代码/kaggle房假预测/README.md

+# 项目名称
+# 项目名称
+
+这是一个关于数据集处理和预测房价的任务。
+
+## 数据集
+
+数据集位于`data`目录下，包括以下文件：
+
+- `train.csv`: 训练数据集
+- `test.csv`: 测试数据集
+
+## 代码说明
+
+主要的代码逻辑如下：
+
+```python
+import pandas as pd
+from sklearn.preprocessing import LabelEncoder
+
+# 读取数据集
+train_data = pd.read_csv('data/train.csv')
+test_data = pd.read_csv('data/test.csv')
+
+# 检查数据集
+train_data.head()
+test_data.head()
+
+# 填充缺失值
+for x in train_data.columns:
+    if train_data[x].dtypes == object:
+        train_data[x] = train_data[x].fillna('None')
+    else:
+        train_data[x] = train_data[x].fillna(train_data[x].value_counts().idxmax())
+
+for x in test_data.columns:
+    if test_data[x].dtypes == object:
+        test_data[x] = test_data[x].fillna('None')
+    else:
+        test_data[x] = test_data[x].fillna(test_data[x].value_counts().idxmax())
+
+# 编码分类特征
+label = LabelEncoder()
+for x in train_data.columns:
+    if train_data[x].dtypes == object:
+        train_data[x] = label.fit_transform(train_data[x].astype(str))
+
+for x in test_data.columns:
+    if test_data[x].dtypes == object:
+        test_data[x] = label.fit_transform(test_data[x].astype(str))
+
+# 准备训练数据
+y = train_data['SalePrice']
+train_data.drop(['SalePrice'], axis=1, inplace=True)
+X = train_data
+
+# 划分训练集和测试集
+from sklearn.model_selection import train_test_split
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# 构建模型
+from sklearn.ensemble import RandomForestRegressor
+model = RandomForestRegressor()
+model = model.fit(X_train, y_train)
+
+# 预测
+prediction = model.predict(test_data)
+
+# 生成提交文件
+pd.DataFrame({'Id': test_data.Id, 'SalePrice': prediction}).to_csv('submission.csv', index=False)
+```
+## 使用说明
+- 确保已安装所需的Python库，可以使用以下命令安装依赖：
+- pip install pandas scikit-learn
+- 将训练数据集和测试数据集放置在data目录下。
+
+- 执行代码中的各个代码块，按照代码的顺序运行。
+
+- 执行完所有代码块后，将生成的预测结果保存在submission.csv文件中。
+
+## 注意事项
+- 请确保数据集文件的路径正确，并且数据集中没有缺失值。
+
+- 如果需要修改代码以适应不同的数据集，请根据具体情况进行相应的调整。
+
+- 本示例使用的模型是随机森林回归模型，你可以根据需要选择其他模型进行训练和预测
\ No newline at end of file