周末遛狗时，我想起一个老问题：神经网络能预测三角形的面积吗？
神经网络非常擅长分类，例如根据花瓣长度和宽度以及萼片长度和宽度预测鸢尾花的种类（setosa、versicolor 或 virginica）。神经网络还擅长一些回归问题，例如根据城镇房屋的平均面积、城镇的税率、与最近大城市的距离等预测城镇的房价中位数。
但神经网络并不适用于普通的数学计算，例如根据底边和高计算三角形的面积。如果你的小学数学有点生疏，我会提醒你，三角形的面积是底边乘以高的 1/2。
NSDT工具推荐： Three.js AI纹理开发包 - YOLO合成数据生成器 - GLTF/GLB在线编辑 - 3D模型格式在线转换 - 可编程3D场景编辑器 - REVIT导出3D模型插件 - 3D模型语义搜索引擎 - Three.js虚拟轴心开发包 - 3D模型在线减面 - STL模型在线切割
我在一家大型科技公司工作，PyTorch 是官方首选的神经网络代码库，也是我个人首选的库。周末遛狗时，我决定使用 PyTorch 1.6 版（当前版本）预测三角形面积。
我编写了一个程序，以编程方式生成 10,000 个训练样本，其中底边和高边的值是 0.1 到 0.9 之间的随机值（因此面积在 0.005 到 0.405 之间）。我创建了一个 2-(100-100-100-100)-1 神经网络 — 2 个输入节点、4 个隐藏层（每个隐藏层有 100 个节点）和一个输出节点。我在隐藏节点上使用了 tanh 激活，在输出节点上没有使用激活。
我使用 10 个样本作为批次对网络进行了 1,000 个周期的训练。
训练后，网络正确地预测了 100% 的训练项目在正确区域的 10% 以内，100% 的训练项目在正确区域的 5% 以内，82% 的训练项目在正确区域的 1% 以内。这是否是一个好结果取决于你的观点。
很有趣。深度学习引起了很多关注，并且有大量关于该主题的研究活动。但这不是魔术。
在我思考三角形的那个周末，我看了一部 1967 年的老间谍电影《比男杀手更致命》，里面的女杀手都留着蜂窝发型。左图：女演员 Elke Sommer 扮演主要杀手。我不知道这种发型是怎么回事。中图和右图：互联网图片搜索返回了不少这样的图片，所以我猜蜂窝发型现在有时仍然在使用。
我的代码如下：
# triangle_area_nn.py
# predict area of triangle using PyTorch NN
import numpy as np
import torch as T
device = T.device("cpu")
class TriangleDataset(T.utils.data.Dataset):
# 0.40000, 0.80000, 0.16000
# [0] [1] [2]
def __init__(self, src_file, num_rows=None):
all_data = np.loadtxt(src_file, max_rows=num_rows,
usecols=range(0,3), delimiter=",", skiprows=0,
dtype=np.float32)
self.x_data = T.tensor(all_data[:,0:2],
dtype=T.float32).to(device)
self.y_data = T.tensor(all_data[:,2],
dtype=T.float32).to(device)
self.y_data = self.y_data.reshape(-1,1)
def __len__(self):
return len(self.x_data)
def __getitem__(self, idx):
if T.is_tensor(idx):
idx = idx.tolist()
base_ht = self.x_data[idx,:] # idx rows, all 4 cols
area = self.y_data[idx,:] # idx rows, the 1 col
sample = { 'base_ht' : base_ht, 'area' : area }
return sample
# ---------------------------------------------------------
def accuracy(model, ds):
# ds is a iterable Dataset of Tensors
n_correct10 = 0; n_wrong10 = 0
n_correct05 = 0; n_wrong05 = 0
n_correct01 = 0; n_wrong01 = 0
# alt: create DataLoader and then enumerate it
for i in range(len(ds)):
inpts = ds[i]['base_ht']
tri_area = ds[i]['area'] # float32 [0.0] or [1.0]
with T.no_grad():
oupt = model(inpts)
delta = tri_area.item() - oupt.item()
if delta < 0.10 * tri_area.item():
n_correct10 += 1
else:
n_wrong10 += 1
if delta < 0.05 * tri_area.item():
n_correct05 += 1
else:
n_wrong05 += 1
if delta < 0.01 * tri_area.item():
n_correct01 += 1
else:
n_wrong01 += 1
acc10 = (n_correct10 * 1.0) / (n_correct10 + n_wrong10)
acc05 = (n_correct05 * 1.0) / (n_correct05 + n_wrong05)
acc01 = (n_correct01 * 1.0) / (n_correct01 + n_wrong01)
return (acc10, acc05, acc01)
# ----------------------------------------------------------
class Net(T.nn.Module):
def __init__(self):
super(Net, self).__init__()
self.hid1 = T.nn.Linear(2, 100) # 2-(100-100-100-100)-1
self.hid2 = T.nn.Linear(100, 100)
self.hid3 = T.nn.Linear(100, 100)
self.hid4 = T.nn.Linear(100, 100)
self.oupt = T.nn.Linear(100, 1)
T.nn.init.xavier_uniform_(self.hid1.weight) # glorot
T.nn.init.zeros_(self.hid1.bias)
T.nn.init.xavier_uniform_(self.hid2.weight) # glorot
T.nn.init.zeros_(self.hid2.bias)
T.nn.init.xavier_uniform_(self.hid3.weight) # glorot
T.nn.init.zeros_(self.hid3.bias)
T.nn.init.xavier_uniform_(self.hid4.weight) # glorot
T.nn.init.zeros_(self.hid4.bias)
T.nn.init.xavier_uniform_(self.oupt.weight) # glorot
T.nn.init.zeros_(self.oupt.bias)
def forward(self, x):
z = T.tanh(self.hid1(x)) # or T.nn.Tanh()
z = T.tanh(self.hid2(z))
z = T.tanh(self.hid3(z))
z = T.tanh(self.hid4(z))
z = self.oupt(z) # no activation
return z
# ----------------------------------------------------------
def main():
# 0. make training data file
np.random.seed(1)
T.manual_seed(1)
hi = 0.9; lo = 0.1
train_f = open("area_train.txt", "w")
for i in range(10000):
base = (hi - lo) * np.random.random() + lo
height = (hi - lo) * np.random.random() + lo
area = 0.5 * base * height
s = "%0.5f, %0.5f, %0.5f \n" % (base, height, area)
train_f.write(s)
train_f.close()
# 1. create Dataset and DataLoader objects
print("Creating Triangle Area train DataLoader ")
train_file = ".\\area_train.txt"
train_ds = TriangleDataset(train_file) # all rows
bat_size = 10
train_ldr = T.utils.data.DataLoader(train_ds,
batch_size=bat_size, shuffle=True)
# 2. create neural network
print("Creating 2-(100-100-100-100)-1 regression NN ")
net = Net()
# 3. train network
print("\nPreparing training")
net = net.train() # set training mode
lrn_rate = 0.01
loss_func = T.nn.MSELoss()
optimizer = T.optim.SGD(net.parameters(),
lr=lrn_rate)
max_epochs = 1000
ep_log_interval = 100
print("Loss function: " + str(loss_func))
print("Optimizer: SGD")
print("Learn rate: 0.01")
print("Batch size: 10")
print("Max epochs: " + str(max_epochs))
print("\nStarting training")
for epoch in range(0, max_epochs):
epoch_loss = 0.0 # for one full epoch
epoch_loss_custom = 0.0
num_lines_read = 0
for (batch_idx, batch) in enumerate(train_ldr):
X = batch['base_ht'] # [10,4] base, height inputs
Y = batch['area'] # [10,1] correct area to predict
optimizer.zero_grad()
oupt = net(X) # [10,1] computed
loss_obj = loss_func(oupt, Y) # a tensor
epoch_loss += loss_obj.item() # accumulate
loss_obj.backward()
optimizer.step()
if epoch % ep_log_interval == 0:
print("epoch = %4d loss = %0.4f" % \
(epoch, epoch_loss))
print("Done ")
# 4. evaluate model
net = net.eval()
(acc10, acc05, acc01) = accuracy(net, train_ds)
print("\nAccuracy (.10) on train data = %0.2f%%" % \
(acc10 * 100))
print("\nAccuracy (.05) on train data = %0.2f%%" % \
(acc05 * 100))
print("\nAccuracy (.01) on train data = %0.2f%%" % \
(acc01 * 100))
if __name__ == "__main__":
main()原文链接：用神经网络预测三角形面积 - BimAnt
