深入研究鸢尾花数据集
画出数据集中150个数据的前两个特征的散点分布图：
import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm, datasets
iris = datasets.load_iris()
X = iris.data[:, :2] # 只取前两维特征
y = iris.target
h = .02 # 网格中的步长
C = 1.0 # SVM正则化参数
svc = svm.SVC(kernel='linear', C=C).fit(X, y) # 线性核
rbf_svc = svm.SVC(kernel='rbf', gamma=0.7, C=C).fit(X, y) # 径向基核
poly_svc = svm.SVC(kernel='poly', degree=3, C=C).fit(X, y) # 多项式核
lin_svc = svm.LinearSVC(C=C).fit(X, y) # 线性核
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
titles = ['SVC with linear kernel',
'LinearSVC (linear kernel)',
'SVC with RBF kernel',
'SVC with polynomial (degree 3) kernel']
for i, clf in enumerate((svc, lin_svc, rbf_svc, poly_svc)):
# 绘出决策边界，不同的区域分配不同的颜色
plt.subplot(2, 2, i + 1) # 创建一个2行2列的图，并以第i个图为当前图
plt.subplots_adjust(wspace=0.4, hspace=0.4) # 设置子图间隔
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
# 把分类结果绘制出来
Z = Z.reshape(xx.shape) # (220, 280)
plt.contourf(xx, yy, Z)
# 将训练数据以离散点的形式绘制出来
plt.scatter(X[:, 0], X[:, 1], c=y, cmap="brg")
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.xticks(())
plt.yticks(())
plt.title(titles[i])
plt.show()
输出结果：
4.5 实践：基于前馈神经网络完成鸢尾花分类
继续使用第三章中的鸢尾花分类任务，将Softmax分类器替换为前馈神经网络。
- 损失函数：交叉熵损失；
- 优化器：随机梯度下降法；
- 评价指标：准确率。
4.5.1 小批量梯度下降法
为了减少每次迭代的计算复杂度，我们可以在每次迭代时只采集一小部分样本，计算在这组样本上损失函数的梯度并更新参数，这种优化方式称为小批量梯度下降法（Mini-Batch Gradient Descent，Mini-Batch GD）。
为了小批量梯度下降法，我们需要对数据进行随机分组。
目前，机器学习中通常做法是构建一个数据迭代器，每个迭代过程中从全部数据集中获取一批指定数量的数据。
4.5.2 数据处理
4.5.2. 1自定义加载数据集
import copy
import numpy as np
import torch
from sklearn.datasets import load_iris
#加载数据集
def load_data(shuffle=True):
#加载原始数据
X = np.array(load_iris().data, dtype=np.float32)
y = np.array(load_iris().target, dtype=np.int64)
X = torch.as_tensor(X)
y = torch.as_tensor(y)
#数据归一化
X_min = torch.min(X, dim=0)
X_max = torch.max(X, dim=0)
X = (X-X_min.values) / (X_max.values-X_min.values)
#如果shuffle为True，随机打乱数据
if shuffle:
idx = torch.randperm(X.shape[0])
X_new = copy.deepcopy(X)
y_new = copy.deepcopy(y)
for i in range(X.shape[0]):
X_new[i] = X[idx[i]]
y_new[i] = y[idx[i]]
X = X_new
y = y_new
return X, y
class IrisDataset(torch.utils.data.Dataset):
def __init__(self, mode='train', num_train=120, num_dev=15):
super(IrisDataset, self).__init__()
# 调用第三章中的数据读取函数，其中不需要将标签转成one-hot类型
X, y = load_data(shuffle=True)
if mode == 'train':
self.X, self.y = X[:num_train], y[:num_train]
elif mode == 'dev':
self.X, self.y = X[num_train:num_train + num_dev], y[num_train:num_train + num_dev]
else:
self.X, self.y = X[num_train + num_dev:], y[num_train + num_dev:]
def __getitem__(self, idx):
return self.X[idx], self.y[idx]
def __len__(self):
return len(self.y)
train_dataset = IrisDataset(mode='train')
dev_dataset = IrisDataset(mode='dev')
test_dataset = IrisDataset(mode='test')
4.5.2.2 用DataLoader进行封装
# 批量大小
batch_size = 16
# 加载数据
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
dev_loader = torch.utils.data.DataLoader(dev_dataset, batch_size=batch_size)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size)
4.5.3 模型构建
# 实现一个两层前馈神经网络
class Model_MLP_L2_V3(torch.nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(Model_MLP_L2_V3, self).__init__()
self.fc1 = torch.nn.Linear(input_size, hidden_size)
w_ = torch.normal(0, 0.01, size=(hidden_size, input_size), requires_grad=True)
self.fc1.weight = torch.nn.Parameter(w_)
self.fc1.bias = torch.nn.init.constant_(self.fc1.bias, val=1.0)
self.fc2 = torch.nn.Linear(hidden_size, output_size )
w2 = torch.normal(0, 0.01, size=(output_size, hidden_size), requires_grad=True)
self.fc2.weight = nn.Parameter(w2)
self.fc2.bias = torch.nn.init.constant_(self.fc2.bias, val=1.0)
self.act = torch.sigmoid
def forward(self, inputs):
outputs = self.fc1(inputs)
outputs = self.act(outputs)
outputs = self.fc2(outputs)
return outputs
ffnn_model =Model_MLP_L2_V3(input_size=4, hidden_size=6,output_size=3)
4.5.4 完善Runner类
class RunnerV3(object):
def __init__(self, model, optimizer, loss_fn, metric, **kwargs):
self.model = model
self.optimizer = optimizer
self.loss_fn = loss_fn
self.metric = metric # 只用于计算评价指标
# 记录训练过程中的评价指标变化情况
self.dev_scores = []
# 记录训练过程中的损失函数变化情况
self.train_epoch_losses = [] # 一个epoch记录一次loss
self.train_step_losses = [] # 一个step记录一次loss
self.dev_losses = []
# 记录全局最优指标
self.best_score = 0
def train(self, train_loader, dev_loader=None, **kwargs):
# 将模型切换为训练模式
self.model.train()
# 传入训练轮数，如果没有传入值则默认为0
num_epochs = kwargs.get("num_epochs", 0)
# 传入log打印频率，如果没有传入值则默认为100
log_steps = kwargs.get("log_steps", 100)
# 评价频率
eval_steps = kwargs.get("eval_steps", 0)
# 传入模型保存路径，如果没有传入值则默认为"best_model.pdparams"
save_path = kwargs.get("save_path", "best_model.pdparams")
custom_print_log = kwargs.get("custom_print_log", None)
# 训练总的步数
num_training_steps = num_epochs * len(train_loader)
if eval_steps:
if self.metric is None:
raise RuntimeError('Error: Metric can not be None!')
if dev_loader is None:
raise RuntimeError('Error: dev_loader can not be None!')
# 运行的step数目
global_step = 0
# 进行num_epochs轮训练
for epoch in range(num_epochs):
# 用于统计训练集的损失
total_loss = 0
for step, data in enumerate(train_loader):
X, y = data
# 获取模型预测
logits = self.model(X)
loss = self.loss_fn(logits, y) # 默认求mean
total_loss += loss
# 训练过程中，每个step的loss进行保存
self.train_step_losses.append((global_step, loss.item()))
if log_steps and global_step % log_steps == 0:
print(
f"[Train] epoch: {epoch}/{num_epochs}, step: {global_step}/{num_training_steps}, loss: {loss.item():.5f}")
# 梯度反向传播，计算每个参数的梯度值
loss.backward()
if custom_print_log:
custom_print_log(self)
# 小批量梯度下降进行参数更新
self.optimizer.step()
# 梯度归零
self.optimizer.zero_grad()
# 判断是否需要评价
if eval_steps > 0 and global_step > 0 and \
(global_step % eval_steps == 0 or global_step == (num_training_steps - 1)):
dev_score, dev_loss = self.evaluate(dev_loader, global_step=global_step)
print(f"[Evaluate] dev score: {dev_score:.5f}, dev loss: {dev_loss:.5f}")
# 将模型切换为训练模式
self.model.train()
# 如果当前指标为最优指标，保存该模型
if dev_score > self.best_score:
self.save_model(save_path)
print(
f"[Evaluate] best accuracy performence has been updated: {self.best_score:.5f} --> {dev_score:.5f}")
self.best_score = dev_score
global_step += 1
# 当前epoch 训练loss累计值
trn_loss = (total_loss / len(train_loader)).item()
# epoch粒度的训练loss保存
self.train_epoch_losses.append(trn_loss)
print("[Train] Training done!")
# 模型评估阶段，使用'torch.no_grad()'控制不计算和存储梯度
@torch.no_grad()
def evaluate(self, dev_loader, **kwargs):
assert self.metric is not None
# 将模型设置为评估模式
self.model.eval()
global_step = kwargs.get("global_step", -1)
# 用于统计训练集的损失
total_loss = 0
# 重置评价
self.metric.reset()
# 遍历验证集每个批次
for batch_id, data in enumerate(dev_loader):
X, y = data
# 计算模型输出
logits = self.model(X)
# 计算损失函数
loss = self.loss_fn(logits, y).item()
# 累积损失
total_loss += loss
# 累积评价
self.metric.update(logits, y)
dev_loss = (total_loss / len(dev_loader))
dev_score = self.metric.accumulate()
# 记录验证集loss
if global_step != -1:
self.dev_losses.append((global_step, dev_loss))
self.dev_scores.append(dev_score)
return dev_score, dev_loss
# 模型评估阶段，使用'torch.no_grad()'控制不计算和存储梯度
@torch.no_grad()
def predict(self, x, **kwargs):
# 将模型设置为评估模式
self.model.eval()
# 运行模型前向计算，得到预测值
logits = self.model(x)
return logits
def save_model(self, save_path):
torch.save(self.model.state_dict(), save_path)
def load_model(self, model_path):
model_state_dict = torch.load(model_path)
self.model.load_state_dict(model_state_dict)
Accuracy类代码如下：
class Accuracy(object):
def __init__(self, is_logist=True):
# 用于统计正确的样本个数
self.num_correct = 0
# 用于统计样本的总数
self.num_count = 0
self.is_logist = is_logist
def update(self, outputs, labels):
# 判断是二分类任务还是多分类任务，shape[1]=1时为二分类任务，shape[1]>1时为多分类任务
if outputs.shape[1] == 1: # 二分类
outputs = torch.squeeze(outputs, axis=-1)
if self.is_logist:
# logist判断是否大于0
preds = (outputs>=0).to(torch.float32)
else:
# 如果不是logist，判断每个概率值是否大于0.5，当大于0.5时，类别为1，否则类别为0
preds = (outputs>=0.5).to(torch.float32)
else:
# 多分类时，使用'torch.argmax'计算最大元素索引作为类别
preds = torch.argmax(outputs, dim=1).int()
# 获取本批数据中预测正确的样本个数
labels = torch.squeeze(labels, axis=-1)
batch_correct = torch.sum(torch.tensor(preds==labels, dtype=torch.float32)).numpy()
batch_count = len(labels)
# 更新num_correct 和 num_count
self.num_correct += batch_correct
self.num_count += batch_count
def accumulate(self):
# 使用累计的数据，计算总的指标
if self.num_count == 0:
return 0
return self.num_correct / self.num_count
def reset(self):
# 重置正确的数目和总数
self.num_correct = 0
self.num_count = 0
def name(self):
return "Accuracy"
4.5.5 模型训练
使用训练集和验证集进行模型训练。在实验中，保存准确率最高的模型作为最佳模型。
import torch.optim as opt
lr = 0.2
# 定义网络
model = fnn_model
# 定义优化器
optimizer = opt.SGD(model.parameters(),lr=lr)
# 定义损失函数。softmax+交叉熵
loss_fn = F.cross_entropy
# 定义评价指标
metric = Accuracy(is_logist=True)
runner = RunnerV3(model, optimizer, loss_fn, metric)
# 启动训练
log_steps = 100
eval_steps = 50
runner.train(train_loader, dev_loader,
num_epochs=150, log_steps=log_steps, eval_steps = eval_steps,
save_path="best_model.pdparams")
输出结果：
[Train] epoch: 0/150, step: 0/1200, loss: 1.10467
[Evaluate] dev score: 0.26667, dev loss: 1.22231
[Evaluate] best accuracy performence has been updated: 0.00000 --> 0.26667
[Train] epoch: 12/150, step: 100/1200, loss: 1.11286
[Evaluate] dev score: 0.26667, dev loss: 1.11308
[Evaluate] dev score: 0.26667, dev loss: 1.13753
[Train] epoch: 25/150, step: 200/1200, loss: 1.11455
[Evaluate] dev score: 0.26667, dev loss: 1.12687
[Evaluate] dev score: 0.26667, dev loss: 1.11112
[Train] epoch: 37/150, step: 300/1200, loss: 1.07319
[Evaluate] dev score: 0.26667, dev loss: 1.09228
[Evaluate] dev score: 0.26667, dev loss: 1.07941
[Train] epoch: 50/150, step: 400/1200, loss: 0.96820
[Evaluate] dev score: 0.53333, dev loss: 1.02344
[Evaluate] best accuracy performence has been updated: 0.26667 --> 0.53333
[Evaluate] dev score: 0.53333, dev loss: 0.93751
[Train] epoch: 62/150, step: 500/1200, loss: 0.72586
[Evaluate] dev score: 0.60000, dev loss: 0.77080
[Evaluate] best accuracy performence has been updated: 0.53333 --> 0.60000
[Evaluate] dev score: 0.66667, dev loss: 0.67423
[Evaluate] best accuracy performence has been updated: 0.60000 --> 0.66667
[Train] epoch: 75/150, step: 600/1200, loss: 0.53801
[Evaluate] dev score: 0.86667, dev loss: 0.57472
[Evaluate] best accuracy performence has been updated: 0.66667 --> 0.86667
[Evaluate] dev score: 0.80000, dev loss: 0.56176
[Train] epoch: 87/150, step: 700/1200, loss: 0.38122
[Evaluate] dev score: 0.86667, dev loss: 0.50781
[Evaluate] dev score: 0.93333, dev loss: 0.46224
[Evaluate] best accuracy performence has been updated: 0.86667 --> 0.93333
[Train] epoch: 100/150, step: 800/1200, loss: 0.43660
[Evaluate] dev score: 0.93333, dev loss: 0.43534
[Evaluate] dev score: 1.00000, dev loss: 0.40225
[Evaluate] best accuracy performence has been updated: 0.93333 --> 1.00000
[Train] epoch: 112/150, step: 900/1200, loss: 0.33995
[Evaluate] dev score: 0.93333, dev loss: 0.38908
[Evaluate] dev score: 0.93333, dev loss: 0.36191
[Train] epoch: 125/150, step: 1000/1200, loss: 0.28941
[Evaluate] dev score: 1.00000, dev loss: 0.33070
[Evaluate] dev score: 1.00000, dev loss: 0.31569
[Train] epoch: 137/150, step: 1100/1200, loss: 0.27491
[Evaluate] dev score: 1.00000, dev loss: 0.30810
[Evaluate] dev score: 1.00000, dev loss: 0.28763
[Evaluate] dev score: 1.00000, dev loss: 0.26681
[Train] Training done!可视化观察训练集损失和训练集loss变化情况：
import matplotlib.pyplot as plt
# 绘制训练集和验证集的损失变化以及验证集上的准确率变化曲线
def plot_training_loss_acc(runner, fig_name,
fig_size=(16, 6),
sample_step=20,
loss_legend_loc="upper right",
acc_legend_loc="lower right",
train_color="#e4007f",
dev_color='#f19ec2',
fontsize='large',
train_linestyle="-",
dev_linestyle='--'):
plt.figure(figsize=fig_size)
plt.subplot(1, 2, 1)
train_items = runner.train_step_losses[::sample_step]
train_steps = [x[0] for x in train_items]
train_losses = [x[1] for x in train_items]
plt.plot(train_steps, train_losses, color=train_color, linestyle=train_linestyle, label="Train loss")
if len(runner.dev_losses) > 0:
dev_steps = [x[0] for x in runner.dev_losses]
dev_losses = [x[1] for x in runner.dev_losses]
plt.plot(dev_steps, dev_losses, color=dev_color, linestyle=dev_linestyle, label="Dev loss")
# 绘制坐标轴和图例
plt.ylabel("loss", fontsize=fontsize)
plt.xlabel("step", fontsize=fontsize)
plt.legend(loc=loss_legend_loc, fontsize='x-large')
# 绘制评价准确率变化曲线
if len(runner.dev_scores) > 0:
plt.subplot(1, 2, 2)
plt.plot(dev_steps, runner.dev_scores,
color=dev_color, linestyle=dev_linestyle, label="Dev accuracy")
# 绘制坐标轴和图例
plt.ylabel("score", fontsize=fontsize)
plt.xlabel("step", fontsize=fontsize)
plt.legend(loc=acc_legend_loc, fontsize='x-large')
plt.savefig(fig_name)
plt.show()
plot_training_loss_acc(runner, 'fw-loss.pdf')
输出结果：
从输出结果可以看出准确率随着迭代次数增加逐渐上升直至收敛，损失函数则不断下降。
模型评价
使用测试数据对在训练过程中保存的最佳模型进行评价，观察模型在测试集上的准确率以及Loss情况。
score, loss = runner.evaluate(test_loader)
print("[Test] accuracy/loss: {:.4f}/{:.4f}".format(score, loss))输出结果：
[Test] accuracy/loss: 1.0000/0.1498模型预测
同样地，也可以使用保存好的模型，对测试集中的某一个数据进行模型预测，观察模型效果。
test_loader = iter(test_loader)
# 获取测试集中第一条数据
(X, label) = next(test_loader)
logits = runner.predict(X)
pred_class = torch.argmax(logits[0]).numpy()
label = label.numpy()[0]
# 输出真实类别与预测类别
print("The true category is {} and the predicted category is {}".format(label, pred_class))输出为：
The true category is 2 and the predicted category is 0思考题
1. 对比Softmax分类和前馈神经网络分类。（必做）
softmax代码：
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.linear_model import LogisticRegression
from matplotlib.colors import ListedColormap
iris = datasets.load_iris() # 加载数据
list(iris.keys()) # ['data', 'target', 'frame', 'target_names', 'DESCR', 'feature_names', 'filename', 'data_module']
X = iris["data"][:, 3:] # 花瓣长度
y = (iris["target"] == 2).astype(np.int32) # 标签，是维吉尼亚鸢尾花y就是1，否则为0
log_reg = LogisticRegression(solver="lbfgs", random_state=42)
log_reg.fit(X, y) # 训练模型
x0, x1 = np.meshgrid(
np.linspace(0, 8, 500).reshape(-1, 1),
np.linspace(0, 4.5, 200).reshape(-1, 1),
)
X_new = np.c_[x0.ravel(), x1.ravel()]
X = iris["data"][:, (0, 1)] # 花瓣长度, 花瓣宽度
y = iris["target"]
# 设置超参数multi_class为"multinomial"，指定一个支持Softmax回归的求解器，默认使用l2正则化，可以通过超参数C进行控制
softmax_reg = LogisticRegression(multi_class="multinomial", solver="lbfgs", C=0.1, random_state=42)
softmax_reg.fit(X, y)
y_proba = softmax_reg.predict_proba(X_new)
y_predict = softmax_reg.predict(X_new)
zz1 = y_proba[:, 1].reshape(x0.shape)
zz = y_predict.reshape(x0.shape)
plt.figure(figsize=(10, 4))
plt.plot(X[y == 2, 0], X[y == 2, 1], "g^", label="Iris virginica")
plt.plot(X[y == 1, 0], X[y == 1, 1], "bs", label="Iris versicolor")
plt.plot(X[y == 0, 0], X[y == 0, 1], "yo", label="Iris setosa")
custom_cmap = ListedColormap(['#FFB6C1', '#FFF0F5', '#FF69B4'])
plt.contourf(x0, x1, zz, cmap=custom_cmap)
plt.xlabel("Petal length", fontsize=14)
plt.ylabel("Petal width", fontsize=14)
plt.legend(loc="center left", fontsize=14)
plt.axis([3, 8, 1, 4.5])
plt.show()运行结果：
c=0.1
c=1
c=10
神经网络：
# 均匀生成40000个数据点
train=torch.tensor([])
tr_real=torch.tensor([])
# 预测对应类别
for data in train_loader:
X, trlabel=data
train=torch.cat((train,X),dim=0)
tr_real = torch.cat((tr_real, trlabel), dim=0)
y = runner.predict(train)
train_label=[]
for i in y:
pred_class = torch.argmax(i).numpy()
train_label.append(pred_class)
print(train_label)
dev=torch.tensor([])
dev_real=torch.tensor([])
# 预测对应类别
for data in test_loader:
X, delabel=data
dev=torch.cat((dev,X),dim=0)
dev_real = torch.cat((dev_real, delabel), dim=0)
y = runner.predict(dev)
dev_label=[]
for i in y :
pred_class = torch.argmax(i).numpy()
dev_label.append(pred_class)
print(dev_label)
print(dev)
test=torch.tensor([])
t_real=torch.tensor([])
# 预测对应类别
for data in test_loader:
X, tlabel=data
test=torch.cat((test,X),dim=0)
t_real = torch.cat((t_real,tlabel),dim=0)
y = runner.predict(test)
test_label=[]
for i in y :
pred_class = torch.argmax(i).numpy()
test_label.append(pred_class)
print(test_label)
'''
x=torch.tensor([])
for i in range(0,80000):
zhongjian=torch.randn(size=(1,4))
x= torch.cat((zhongjian,x), dim=0)
y= runner.predict(x)
ylabel=[]
for i in y :
pred_class = torch.argmax(i).numpy()
ylabel.append(pred_class)
'''
x=torch.cat((train,dev),dim=0)
x=torch.cat((x,test),dim=0)
y=torch.cat((tr_real,dev_real),dim=0)
y=torch.cat((y,t_real),dim=0)
print(x.shape,y.shape)
'''
print('x',x.shape,'\n',model.fc1.weight)
def plot_decision_boundary(model, x, y):
x_min, x_max = x[:, 0].min() - 0.5, x[:, 0].max() + 0.5
y_min, y_max = x[:, 1].min() - 0.5, x[:, 1].max() + 0.5
x_min1, x_max1 = x[:, 2].min() - 0.5, x[:,2].max() + 0.5
y_min2, y_max2 = x[:, 3].min() - 0.5, x[:, 3].max() + 0.5
h = 0.01
# 绘制网格
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
xz=np.c_[xx.ravel(), yy.ravel()]
z = model(np.c_[xz, xz])
z = z.reshape(xx.shape)
# 绘制contour
plt.contour(xx, yy, z, levels=[0.5], colors=['blue'])
plt.scatter(x[:, 0], x[:, 1], c=y)
plt.show()
def plot_network(x):
x = Variable(torch.from_numpy(x).float())
x1 = torch.mm(x, model.fc1.weight.T) + model.fc1.bias.T
x1 = F.sigmoid(x1)
x2 = torch.mm(x1, model.fc2.weight.T) + model.fc2.bias.T
out = x2
y=torch.tensor([])
for i in out:
pred_class = torch.argmax(i).numpy()
y.append(pred_class)
return y.data.numpy()
plot_decision_boundary(lambda x: plot_network(x), xyong.numpy(), y.numpy())
'''
# 绘制类别区域
plt.ylabel('x2')
plt.xlabel('x1')
plt.scatter(x[:,0].tolist(), x[:,1].tolist(), c=y.tolist(), cmap=plt.cm.Spectral)
plt.scatter(train[:, 0].tolist(), train[:, 1].tolist(), marker='*', c=train_label)
plt.scatter(dev[:, 0].tolist(), dev[:, 1].tolist(), marker='*', c=dev_label)
plt.scatter(test[:, 0].tolist(), test[:, 1].tolist(), marker='*', c=test_label)
plt.show()
讨论二者区别：
1.softmax分类（定义definition）
Softmax Regression，又称多类的logistic 回归，相当于Logistic 回归在多分类问题上的推广。
利用上述Softmax函数，对于多分类模型，在给定样本X下，定义Softmax回归预测属于类别c的条件概率为：
2.选择softmax的原因
相同输出特征情况,soft max更容易达到终极目标one-hot形式,或者说,softmax降低了训练难度,使得多分类问题更容易收敛。
都具有良好的数据压缩能力是实数域R→[ 0 , 1 ]的映射函数，可以将杂乱无序没有实际含义的数字直接转化为每个分类的可能性概率。
前馈神经网络神经分类与其相比的区别：
一、计算方法不同
前馈神经网络：一种最简单的神经网络，各神经元分层排列。每个神经元只与前一层的神经元相连。接收前一层的输出，并输出给下一层，各层间没有反馈。
二、用途不同
前馈神经网络：主要应用包括感知器网络、BP网络和RBF网络。
三、作用不同
前馈神经网络：结构简单，应用广泛，能够以任意精度逼近任意连续函数及平方可积函数．而且可以精确实现任意有限训练样本集。
总结
随着学习的越来越深，对我来说难度也越来越大，压力也是倍增，不能理解和不会操作的地方也是越来越多，好在当今信息技术发达，不会的可以去网上找一下或者询问身边的大神。比如此次的思考题，我开始是完全不懂，然后就去看了一下别被打脸大神的博客，自己尝试理解了一下之后完成的。最后大概是明白了。
思维导图：
3073
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
