灵活性：TensorFlow支持动态图和静态图两种模式，用户可以根据需要选择适合自己的开发模式。
自动微分：TensorFlow自带自动微分功能，可以方便地计算模型的梯度，这对于优化机器学习模型至关重要。
分布式训练：TensorFlow支持分布式训练，可以在多台机器上分布式训练模型，这对于处理大规模数据集和复杂模型非常有用。
高级API ：TensorFlow提供了高级API，如Keras，可以方便地构建和训练模型。Keras已经发展成一个独立的深度学习框架，并在TensorFlow 2.x版本中得到了更好的支持和集成。
（ps:后面我们也会学习低级API，需要手动定义输入Tensor、各个层的计算过程（如卷积、激活、池化等），并将这些计算过程组合成一个完整的计算图。）
部署和移动端支持：TensorFlow支持将训练好的模型部署到生产环境和移动端，方便用户在不同平台上进行应用。

三、简单实现

|---|-----------------------------------------------------------------------------|
| | import tensorflow as tf |
| | from tensorflow.keras import layers, models |
| | |
| | # 加载和预处理数据（这里以MNIST手写数字数据集为例） |
| | mnist = tf.keras.datasets.mnist |
| | (x_train, y_train), (x_test, y_test) = mnist.load_data() |
| | x_train, x_test = x_train / 255.0, x_test / 255.0 # 归一化像素值到0-1之间 |
| | |
| | # 构建模型 |
| | model = models.Sequential([ |
| | layers.Flatten(input_shape=(28, 28)), # 将28x28的输入图像展平为一维向量 |
| | layers.Dense(128, activation='relu'), # 全连接层，128个神经元，ReLU激活函数 |
| | layers.Dropout(0.2), # Dropout层，用于减少过拟合，丢弃20/神经元 |
| | layers.Dense(10, activation='softmax') # 输出层，10个神经元（对应10个类别），softmax激活函数 |
| | ]) |
| | |
| | # 编译模型 |
| | model.compile(optimizer='adam', |
| | loss='sparse_categorical_crossentropy', |
| | metrics=['accuracy']) |
| | |
| | # 训练模型 |
| | model.fit(x_train, y_train, epochs=5) |
| | |
| | # 评估模型 |
| | test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2) |
| | print(f'\nTest accuracy: {test_acc}') |

我们首先加载了MNIST数据集，并将其分为训练集和测试集。
接着，我们对图像数据进行了归一化处理，将像素值从0-255缩放到0-1之间。
然后，我们构建了一个简单的神经网络模型，该模型包含一个展平层、一个全连接层（带有ReLU激活函数）、一个Dropout层（用于减少过拟合）和一个输出层（带有softmax激活函数，用于多分类任务）。
我们编译了模型，指定了优化器（Adam）、损失函数（稀疏分类交叉熵）和评估指标（准确率）。
最后，我们训练了模型，并在测试集上评估了其性能。

参数:

layers.Flatten(input_shape=(28, 28)): Flatten层用于将输入图像（28x28像素）展平为一维向量（784个元素）。这是必要的，因为全连接层需要一维输入。
layers.Dense(10, activation='softmax'): 这是输出层，具有10个神经元（对应于10个数字类别）。使用softmax激活函数将输出转换为概率分布。

模型编译

optimizer='adam': 指定优化器为Adam。
loss='sparse_categorical_crossentropy': 指定损失函数为稀疏分类交叉熵。由于y_train和y_test是整数标签而不是one-hot编码，因此使用稀疏版本。
metrics=['accuracy']: 指定评估模型性能的指标为准确率。

模型训练

model.fit(x_train, y_train, epochs=5): 使用训练数据x_train和y_train来训练模型，训练5个周期（epoch）。每个周期都会遍历整个训练集一次。

模型评估

model.evaluate(x_test, y_test, verbose=2): 使用测试数据x_test和y_test来评估模型的性能。verbose=2表示在评估过程中显示每个批次的损失和准确率。

Alexnet

ISLVRC 2012

训练集：1,281,167张已标注图片

验证集：50,000张已标注图片

测试集：100,000张未标注图片

经卷积后的矩阵尺寸大小计算公式为： N = (W − F + 2P ) / S + 1

① 输入图片大小 W(高)×W（宽） ② Filter（卷积核）大小 F×F ③ 步长 S ④ padding的像素数 P

例如：像卷积1中，因为作者用了两个GPU，我们只看一个。kernels=48*2，已知输入为[224,224,3(深度为3)]输出为55*55*96（48*2）高*宽*池化核数。

N = (W − F + 2P ) / S + 1 =[224-11+(1+2)]/4+1=55

代码示例：

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)

model.py

这个文件一个用于图像分类的卷积神经网络模型。

初始化函数 __init__ ：
- num_classes：模型输出的类别数，默认为1000。
- init_weights：一个布尔值，指示是否在初始化时自动设置模型权重，默认为False。
- self.features：定义了模型的特征提取部分，包括一系列的卷积层、ReLU激活函数和最大池化层。
- self.classifier：定义了模型的分类部分，包括全连接层、Dropout层和ReLU激活函数。
- 如果init_weights为True，则调用_initialize_weights函数来初始化权重。
前向传播函数 forward ：
- 输入图像x通过self.features进行特征提取，然后通过torch.flatten将特征图展平为一维向量。
- 展平后的特征向量通过self.classifier进行分类，输出每个类别的预测得分。
权重初始化函数 _initialize_weights ：
- 遍历模型的所有模块，如果模块是卷积层或全连接层，则使用特定的方法初始化其权重和偏置。

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

tqdm用于显示进度条。
from model import AlexNet导入了自定义的AlexNet模型。

def main():

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

print("using {} device.".format(device))

检查CUDA是否可用，并据此选择使用GPU还是CPU。

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"])

使用datasets.ImageFolder加载训练和验证数据集。
类标签处理

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)

将类别索引映射到类别名称，并保存到JSON文件中。
数据加载器

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"])

创建数据加载器，用于批量加载数据。
num_workers指定了加载数据时使用的进程数。

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)

初始化AlexNet模型，并设置类别数为5。
将模型移动到指定的设备上（GPU或CPU）。
使用交叉熵损失函数。
使用Adam优化器。

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)

训练过程分为多个epoch。
在每个epoch中，模型先切换到训练模式，然后遍历训练数据集。
使用优化器更新模型参数。
每个epoch结束后，模型切换到评估模式，遍历验证数据集以计算准确率。
如果当前epoch的验证准确率高于之前的最高准确率，则保存模型。

print('Finished Training')

if name == 'main':

main()

train.py

训练AlexNet模型的完整流程。

设置设备（GPU或CPU）。
定义数据预处理流程data_transform，包括随机裁剪、水平翻转、归一化等。
设置数据集的路径，并加载训练和验证数据集。
将类别索引映射到类别名称，并保存为JSON文件。
配置数据加载器DataLoader，包括批量大小、是否打乱数据、工作线程数等。
初始化AlexNet模型，设置损失函数（交叉熵损失）和优化器（Adam）。
训练模型：
- 在每个epoch中，模型首先在训练集上进行训练，计算损失并更新权重。
- 然后，在验证集上评估模型的准确性。
- 记录每个epoch的训练损失和验证准确性。
- 如果当前epoch的验证准确性高于之前的最佳准确性，则保存模型权重。

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))])

定义了一个预处理管道，它首先将图像调整到224x224像素（AlexNet的输入大小），然后将图像转换为PyTorch张量，并对每个通道进行归一化处理。归一化使用均值(0.5, 0.5, 0.5)和标准差(0.5, 0.5, 0.5)

load image

img_path = r"D:\pycharm\深度学习-图像分类\data_set\flower_data\train\tulips\11746276_de3dec8201.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)

将图像通过预处理管道，并增加一个批量维度，因为PyTorch模型期望输入是一个四维张量，其中N是批量大小，C是通道数，H和W分别是高度和宽度。

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)

读取包含类别索引映射的JSON文件，这个文件应该有一个从类别索引到类别名称的映射。

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()

创建AlexNet模型实例，指定类别数为5，并将模型移动到之前设置的设备上（GPU或CPU）。然后加载预训练的权重，并将模型设置为评估模式，这意味着在推理期间不会进行梯度计算或权重更新。

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()

使用torch.no_grad()禁用梯度计算，因为我们在进行推理而不是训练。将图像张量移动到设备上，通过模型进行前向传播，得到输出。然后应用softmax函数得到概率分布，并找到概率最高的类别的索引。

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()

predict.py

使用PyTorch框架和AlexNet模型进行图像分类的完整示例。

设置设备：根据是否检测到CUDA设备（GPU），设置PyTorch使用CPU或GPU。
定义数据转换 ：使用transforms.Compose定义一个转换序列，包括调整图像大小到224x224，转换为Tensor，然后进行归一化。
加载图像：使用PIL打开指定路径的图像，并检查文件是否存在。
显示原始图像：使用matplotlib显示原始图像。
图像预处理：应用之前定义的转换序列，并增加批量维度以匹配模型输入要求。
读取类别索引：从JSON文件中加载类别索引映射，用于将模型预测的数字标签转换为可读的类别名称。
创建模型：实例化AlexNet模型，设置类别数为5（假设有5个类别），并将模型移至之前确定的设备（CPU或GPU）。
加载模型权重：从指定路径加载训练好的模型权重。
模型评估模式：设置模型为评估模式，关闭dropout和batch normalization的训练特性。
进行预测 ：
- 使用torch.no_grad()上下文管理器关闭梯度计算，减少内存消耗，加快计算速度。
- 将预处理后的图像传入模型进行预测，对输出进行squeeze操作去除多余的维度，然后将结果移至CPU。
- 应用softmax函数计算每个类别的预测概率。
- 找到概率最高的类别作为预测结果。
显示结果：打印并显示预测类别和概率，以及所有类别的预测概率。

图像分类-demo(Lenet),tensorflow和Alexnet

demo(Lenet)

代码实现基本步骤：

TensorFlow

一、核心概念

二、主要特点

三、简单实现

参数:

模型编译

模型训练

模型评估

Alexnet

model.py

{'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}

write dict into json file

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))

pata = list(net.parameters())

train

print statistics

validate

train.py

load image

[N, C, H, W],

expand batch dimension

read class_indict

create model

load model weights

predict class

predict.py