回复了主题帖： >>征集 | 使用 MCU，哪些问题最令你头大？

我总结了5个痛点， 痛点1：资料获取比较零散，很多MCU的datasheet和program guide已经app note都比较分散，找起来不方便，有时候获取资料，网络不顺畅； 痛点2：芯片底层驱动学习框架各个厂家不是很统一，同一厂家不同代的MCU的驱动框架可能有有区别，学习和移植成本较高； 痛点3：芯片选型困难，很多客户应用可以用多个型号的MCU来实现，但询价成本和渠道不是很方便，小客户只能需要通过代理才能确定价格，客户无法快速实现选型； 痛点4: 新功能的引入缺乏对应的demo，造成客户无法真正理解新功能，无法快速使能新功能； 痛点5: 很多厂商缺少linux gcc之类的不依赖IDE的编程示例。

回复了主题帖： >>征集 | 使用 MCU，哪些问题最令你头大？

申小林 发表于 2024-8-5 15:49 在MCU的使用过程中遇到的问题是比较多的，我总结了一下，主要有以下几点，其中最让人苦不堪言的就是硬件方 ... 啊，我以为真的是 一点一点 敲出来的...

回复了主题帖： 《机器学习算法与实现 —— Python编程与应用实例》-- 第一贴 初识

秦天qintian0303 发表于 2024-7-5 09:13 有没有大致看一下，这本书的主要侧重方向是什么？  本书侧重于机器学习，从传统的机器学习一直到神经网络，深度神经网络，从基础的数学理论，到python实现，都讲的比较透彻。

发表了主题帖： 《机器学习算法与实现 —— Python编程与应用实例》-- 第八贴 结项语与resnet实战

  结项语： 本贴是此次评测活动的最后一贴，首先感谢论坛给机会参与此次阅读评测活动，通过此次评测，学习到了很多机器学习的基础概念，帮助我建立了很多人工智能基础知识的连接。让我对神经网络的原理有了深入的认识。从目标函数建立、到梯度求解，从传统目标检测模型到目前RNN/CNN等模型，得益于计算技术的快速发展，CPU和GPU的异构硬件算力以及内存速率的不断提升，相信人工智能的发展会更加迅猛。 感谢论坛，感谢本书的作者，书中也有一些地方描述的不是太清晰，希望能进一步把当前大家比较感兴趣的卷积深度神经网络与神经网络的关系以及演进讲的再清晰一些。当然，本书主要是讲解机器学习的相关内容，从这个意义上讲，本书已经非常好了。感谢布老师以及其它作者的辛勤付出，再次感谢论坛，能举办这类的阅读测评活动，非常有意义。希望这次分享的8个帖子能给大家带来些许益处。   ResNet实战--引言：本贴的另外一部分，将尝试将书中介绍的resnet(残差网络)的pytorch在本地try起来，resnet模型是我在工作当中被反复提及的一个网络，通常软件工程师会用resnet50来测试我们制作的人工智能芯片的算力等性能，当然resnet50目前也显得落后了，但不失为一个典型的人工智能网络。   环境说明： 硬件： 我做实验的环境是基于PC，内存 处理器   13th Gen Intel(R) Core(TM) i7-13700KF   3.40 GHz 机带 RAM     16.0 GB (15.7 GB 可用) 系统类型       64 位操作系统, 基于 x64 的处理器 GPU: RXT4060TI-8GB 软件： Windows 11； Pycharm社区版 Anaconda免费版 Torch cuda Git pip 需要注意的是: 建议通过conda来管理python环境，在pycharm中，不同的工程可能需要安装不同的python库，这样管理起来比较方便。 另外，可以将conda/pip等资源的源更换为国内，清华源或者中科大源，否则由于墙的限制，下载一些python包的资源会非常慢。 本书也提到了具体的环境搭建方法，可参考：https://gitee.com/pi-lab/machinelearning_notebook/blob/master/references_tips/InstallPython.md     需要注意的一点：书中一些例程常常会用到from utils import train，这个utils大家千万别认为是一个python的库，这个utils实质上本地的一个实现模块，是本书作者实现的一些模块，千万不要用pip尝试安装，pip安装到的不是你想要的。这个我从网上搜了很多的介绍，很多都是乱扯的，有个别的博主，才说道点子上。这里的utils，大家可以从https://gitee.com/pi-lab/machinelearning_notebook/tree/master/7_deep_learning/1_CNN下载，不同章节都有自己的utils, 大家不要搞错了，注意章节对应上。     Resnet(Residual Network)介绍： 深度神经网络的层数较多时，会存在梯度消失的问题，使得网络无法训练。距离loss层越远的层，在反向传播中，梯度越小，就越难更新。Resnet 通过引入了跨层链接解决了梯度回传失的问题。 通过上述创新，resnet网络在2015年的ImageNet大赛中获得最低的TOP5-错误率。   残差网络的一个基本单元：   Batch norm的作用 机器学习中，进行模型训练之前，需对数据做归一化处理，使其分布一致。在深度神经网络训练过程中，通常一次训练是一个batch，而非全体数据。每个batch具有不同的分布产生了internal covarivate shift问题——在训练过程中，数据分布会发生变化，对下一层网络的学习带来困难。Batch Normalization将数据规范到均值为0，方差为1的分布上，一方面使得数据分布一致，另一方面避免梯度消失。   数据集下载： http://www.cs.toronto.edu/~kriz/cifar.html The CIFAR-10 and CIFAR-100 are labeled subsets of the 80 million tiny images dataset. They were collected by Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton.   The CIFAR-10 dataset consists of 60000 32x32 colour images in 10 classes, with 6000 images per class. There are 50000 training images and 10000 test images. The dataset is divided into five training batches and one test batch, each with 10000 images. The test batch contains exactly 1000 randomly-selected images from each class. The training batches contain the remaining images in random order, but some training batches may contain more images from one class than another. Between them, the training batches contain exactly 5000 images from each class.   或者修改：train_set = CIFAR10('../../data', train=True, transform=data_tf, download= True) 即可自动下载数据集。       上图中/2是stride=2的意思，未指定步长，则默认为1；   代码实现： utilis.py & resnet.py, 执行resnet的py即可。 utilis.py from datetime import datetime import torch import torch.nn.functional as F from torch import nn from torch.autograd import Variable def get_acc(output, label): total = output.shape[0] _, pred_label = output.max(1) num_correct = (pred_label == label).sum().item() return num_correct / total def train(net, train_data, valid_data, num_epochs, optimizer, criterion, use_cuda=True): if use_cuda and torch.cuda.is_available(): net = net.cuda() l_train_loss = [] l_train_acc = [] l_valid_loss = [] l_valid_acc = [] prev_time = datetime.now() for epoch in range(num_epochs): train_loss = 0 train_acc = 0 net = net.train() for im, label in train_data: if use_cuda and torch.cuda.is_available(): im = Variable(im.cuda()) # (bs, 3, h, w) label = Variable(label.cuda()) # (bs, h, w) else: im = Variable(im) label = Variable(label) # forward output = net(im) loss = criterion(output, label) # backward optimizer.zero_grad() loss.backward() optimizer.step() train_loss += loss.item() train_acc += get_acc(output, label) if valid_data is not None: valid_loss = 0 valid_acc = 0 net = net.eval() for im, label in valid_data: if use_cuda and torch.cuda.is_available(): im = Variable(im.cuda()) label = Variable(label.cuda()) else: im = Variable(im) label = Variable(label) output = net(im) loss = criterion(output, label) valid_loss += loss.item() valid_acc += get_acc(output, label) epoch_str = ( "[%2d] Train:(L=%f, Acc=%f), Valid:(L=%f, Acc=%f), " % (epoch, train_loss / len(train_data), train_acc / len(train_data), valid_loss / len(valid_data), valid_acc / len(valid_data))) l_valid_acc.append(valid_acc / len(valid_data)) l_valid_loss.append(valid_loss / len(valid_data)) else: epoch_str = ("[%2d] Train:(L=%f, Acc=%f), " % (epoch, train_loss / len(train_data), train_acc / len(train_data))) l_train_acc.append(train_acc / len(train_data)) l_train_loss.append(train_loss / len(train_data)) cur_time = datetime.now() h, remainder = divmod((cur_time - prev_time).seconds, 3600) m, s = divmod(remainder, 60) time_str = "T: %02d:%02d:%02d" % (h, m, s) prev_time = cur_time print(epoch_str + time_str) return (l_train_loss, l_train_acc, l_valid_loss, l_valid_acc) def conv3x3(in_channel, out_channel, stride=1): return nn.Conv2d( in_channel, out_channel, 3, stride=stride, padding=1, bias=False) class residual_block(nn.Module): def __init__(self, in_channel, out_channel, same_shape=True): super(residual_block, self).__init__() self.same_shape = same_shape stride = 1 if self.same_shape else 2 self.conv1 = conv3x3(in_channel, out_channel, stride=stride) self.bn1 = nn.BatchNorm2d(out_channel) self.conv2 = conv3x3(out_channel, out_channel) self.bn2 = nn.BatchNorm2d(out_channel) if not self.same_shape: self.conv3 = nn.Conv2d(in_channel, out_channel, 1, stride=stride) def forward(self, x): out = self.conv1(x) out = F.relu(self.bn1(out), True) out = self.conv2(out) out = F.relu(self.bn2(out), True) if not self.same_shape: x = self.conv3(x) return F.relu(x + out, True) class resnet(nn.Module): def __init__(self, in_channel, num_classes, verbose=False): super(resnet, self).__init__() self.verbose = verbose self.block1 = nn.Conv2d(in_channel, 64, 7, 2) self.block2 = nn.Sequential( nn.MaxPool2d(3, 2), residual_block(64, 64), residual_block(64, 64)) self.block3 = nn.Sequential( residual_block(64, 128, False), residual_block(128, 128)) self.block4 = nn.Sequential( residual_block(128, 256, False), residual_block(256, 256)) self.block5 = nn.Sequential( residual_block(256, 512, False), residual_block(512, 512), nn.AvgPool2d(3)) self.classifier = nn.Linear(512, num_classes) def forward(self, x): x = self.block1(x) if self.verbose: print('block 1 output: {}'.format(x.shape)) x = self.block2(x) if self.verbose: print('block 2 output: {}'.format(x.shape)) x = self.block3(x) if self.verbose: print('block 3 output: {}'.format(x.shape)) x = self.block4(x) if self.verbose: print('block 4 output: {}'.format(x.shape)) x = self.block5(x) if self.verbose: print('block 5 output: {}'.format(x.shape)) x = x.view(x.shape[0], -1) x = self.classifier(x) return x resnet.py import numpy as np import torch from torch import nn import torch.nn.functional as F from torch.autograd import Variable from torchvision.datasets import CIFAR10 from torchvision import transforms as tfs def conv3x3(in_channel, out_channel, stride=1): return nn.Conv2d(in_channel, out_channel, 3, stride=stride, padding=1, bias=False) class Residual_Block(nn.Module): def __init__(self, in_channel, out_channel, same_shape=True): super(Residual_Block, self).__init__() self.same_shape = same_shape stride = 1 if self.same_shape else 2 self.conv1 = conv3x3(in_channel, out_channel, stride=stride) self.bn1 = nn.BatchNorm2d(out_channel) self.conv2 = conv3x3(out_channel, out_channel) self.bn2 = nn.BatchNorm2d(out_channel) if not self.same_shape: self.conv3 = nn.Conv2d(in_channel, out_channel, 1, stride=stride) def forward(self, x): out = self.conv1(x) out = F.relu(self.bn1(out), True) out = self.conv2(out) out = F.relu(self.bn2(out), True) if not self.same_shape: x = self.conv3(x) return F.relu(x + out, True) #输入输出形状相同 test_net = Residual_Block(32, 32) test_x = Variable(torch.zeros(1, 32, 96, 96)) print('input: {}'.format(test_x.shape)) test_y = test_net(test_x) print('output: {}'.format(test_y.shape)) # 输入输出形状不同 test_net = Residual_Block(3, 32, False) test_x = Variable(torch.zeros(1, 3, 96, 96)) print('input: {}'.format(test_x.shape)) test_y = test_net(test_x) print('output: {}'.format(test_y.shape)) class ResNet(nn.Module): def __init__(self, in_channel, num_classes, verbose=False): super(ResNet, self).__init__() self.verbose = verbose self.block1 = nn.Conv2d(in_channel, 64, 7, 2) self.block2 = nn.Sequential( nn.MaxPool2d(3, 2), Residual_Block(64, 64), Residual_Block(64, 64) ) self.block3 = nn.Sequential( Residual_Block(64, 128, False), Residual_Block(128, 128) ) self.block4 = nn.Sequential( Residual_Block(128, 256, False), Residual_Block(256, 256) ) self.block5 = nn.Sequential( Residual_Block(256, 512, False), Residual_Block(512, 512), nn.AvgPool2d(3) ) self.classifier = nn.Linear(512, num_classes) def forward(self, x): x = self.block1(x) if self.verbose: print('block 1 output: {}'.format(x.shape)) x = self.block2(x) if self.verbose: print('block 2 output: {}'.format(x.shape)) x = self.block3(x) if self.verbose: print('block 3 output: {}'.format(x.shape)) x = self.block4(x) if self.verbose: print('block 4 output: {}'.format(x.shape)) x = self.block5(x) if self.verbose: print('block 5 output: {}'.format(x.shape)) x = x.view(x.shape[0], -1) x = self.classifier(x) return x test_net = ResNet(3, 10, True) test_x = Variable(torch.zeros(1, 3, 96, 96)) test_y = test_net(test_x) print('output: {}'.format(test_y.shape)) from utils import train def data_tf(x): im_aug = tfs.Compose([ tfs.Resize(96), tfs.ToTensor(), tfs.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]) ]) x = im_aug(x) return x train_set = CIFAR10('../../data', train=True, transform=data_tf, download= True) train_data = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True) test_set = CIFAR10('../../data', train=False, transform=data_tf) test_data = torch.utils.data.DataLoader(test_set, batch_size=128, shuffle=False) net = ResNet(3, 10) optimizer = torch.optim.Adam(net.parameters(), lr=1e-3) criterion = nn.CrossEntropyLoss() res = train(net, train_data, test_data, 100, optimizer, criterion) import matplotlib.pyplot as plt #%matplotlib inline plt.plot(res[0], label='train') plt.plot(res[2], label='valid') plt.xlabel('epoch') plt.ylabel('Loss') plt.legend(loc='best') plt.savefig('fig-res-resnet-train-validate-loss.pdf') plt.show() plt.plot(res[1], label='train') plt.plot(res[3], label='valid') plt.xlabel('epoch') plt.ylabel('Acc') plt.legend(loc='best') plt.savefig('fig-res-resnet-train-validate-acc.pdf') plt.show() # save raw data import numpy numpy.save('fig-res-resnet_data.npy', res) 结果：         训练时PC的硬件消耗：     本网络的性能不是很好，猜测是网络的深度不够，准确率一直在80%左右。书中的解释是数据集小以及没有做数据增强。 结语：机器学习是一门交叉学科，数学是基础，计算机是工具，经过不断努力，大多数人都能掌握基本的思想，但是想创造出优雅的网络模型，离不开前人的基础以及不断持之以恒的努力。另外，硬件是推动技术进步的必要东西，人工智能经历了数次冷暖交替，现在的火热，离不开计算机技术的发展，大量高性能硬件的出现，使得复杂计算的实现成为了现实。作为一名AI芯片行业从业者，对于AI的应用有一定的了解，是有益的，能够提升自己的综合实力，提高自己的可触及的天花板，知其然，知其所以然，相信未来，人工智能必将为人类的发展贡献更大的力量，让我们拭目以待。  

发表了主题帖： 《机器学习算法与实现 —— Python编程与应用实例》-- 第七贴 线性回归模型实战

   引言： 书中提到了很多机器学习算法与实现，从中选取了几个典型的算法，在PC上进行了实际体验。本书附带了丰富的电子资料，具体可参考：https://gitee.com/pi-lab/machinelearning_notebook； 本贴介绍的典型算法是线性模型，首先介绍书中介绍的一元一次线性拟合算法在pytorch的实现，然后介绍一元三次线性拟合算法的实现；本贴尝试了一元一次方程来拟合的实验过程，并在此基础上，尝试用一元二次方程来做拟合。通过使用一元二次线性函数来拟合，更进一步加深了机器学习的相关概念，目标函数，梯度，训练，极值。   环境说明：   硬件： 我做实验的环境是基于PC，内存 处理器   13th Gen Intel(R) Core(TM) i7-13700KF   3.40 GHz 机带 RAM     16.0 GB (15.7 GB 可用) 系统类型       64 位操作系统, 基于 x64 的处理器 GPU: RXT4060TI-8GB 软件： Windows 11； Pycharm社区版 Anaconda免费版 Torch cuda Git pip 需要注意的是: 建议通过conda来管理python环境，在pycharm中，不同的工程可能需要安装不同的python库，这样管理起来比较方便。 另外，可以将conda/pip等资源的源更换为国内，清华源或者中科大源，否则由于墙的限制，下载一些python包的资源会非常慢。 本书也提到了具体的环境搭建方法，可参考：https://gitee.com/pi-lab/machinelearning_notebook/blob/master/references_tips/InstallPython.md     一、一元一次线性算法的pytorch实现 1.1模型介绍 回顾文章中的一元一次线性模型：   最小二乘法来构造目标函数； 通过梯度下降法可以来找到这个误差函数的最小值，梯度在数学概念中就是导数，对于多元函数，需要求每个变量的偏导数；这个概念需要具备高等数学的知识，将一元一次函数的x和y，看成f(x,y), 分别求x和y的偏导数，则分别是它们的梯度函数；   梯度有什么意义呢？从几何意义来讲，一个点的梯度值是这个函数变化最快的地方。通俗上理解，我们初中/高中时学到加速度是速度的一阶导数，加速度越快，代表速度变化越快。梯度的含义也差不多。   针对一元线性回归问题，就是沿着梯度的反方向，不断改变 w 和 b 的值，最终找到一组最好的 w 和 b 使得误差最小。 学习率：每次更新w/b的时候，需要决定更新的步长，这个就是学习率，用 η 表示。不同的学习率都会导致不同的结果，学习率太小会导致下降非常缓慢；学习率太大又会导致跳动非常明显。   按照含义, 每次w、b更新的公式就是： w=w−η*∂f(w,b)/∂w b=b−η*∂f(w,b)/∂b   1.2代码实现 import torch import numpy as np torch.manual_seed(2021) # 生层测试数据 x_train = np.random.rand(20, 1) y_train = x_train * 3 + 4 + 3*np.random.rand(20,1) # 画出图像 import matplotlib.pyplot as plt plt.plot(x_train, y_train, 'bo') plt.show() # 转换成 Tensor x_train = torch.from_numpy(x_train) y_train = torch.from_numpy(y_train) # 定义参数 w 和 b w = torch.randn(1, requires_grad=True) # 随机初始化 b = torch.zeros(1, requires_grad=True) # 使用 0 进行初始化 # 构建线性回归模型 def linear_model(x): return x * w + b #def logistc_regression(x): # return torch.sigmoid(x*w+b) y_ = linear_model(x_train) plt.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label='real') plt.plot(x_train.data.numpy(), y_.data.numpy(), 'ro', label='estimated') plt.legend() plt.show() # 计算误差 def get_loss(y_, y): return torch.sum((y_ - y) ** 2) loss = get_loss(y_, y_train) print(loss) # 自动求导 loss.backward() # 查看 w 和 b 的梯度 print(w.grad) print(b.grad) # 更新一次参数 w.data = w.data - 1e-2 * w.grad.data b.data = b.data - 1e-2 * b.grad.data y_ = linear_model(x_train) plt.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label='real') plt.plot(x_train.data.numpy(), y_.data.numpy(), 'ro', label='estimated') plt.legend() plt.show() for e in range(100): # 进行 100 次更新 y_ = linear_model(x_train) loss = get_loss(y_, y_train) w.grad.zero_() # 注意：归零梯度 b.grad.zero_() # 注意：归零梯度 loss.backward() w.data = w.data - 1e-2 * w.grad.data # 更新 w b.data = b.data - 1e-2 * b.grad.data # 更新 b if (e + 1) % 20 == 0: print('epoch: {}, loss: {}'.format(e, loss.item())) y_ = linear_model(x_train) plt.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label='real') plt.plot(x_train.data.numpy(), y_.data.numpy(), 'ro', label='estimated') plt.legend() plt.show()   1.3结果对比 待拟合数据：   第一次拟合后的对比：   中间拟合结果对比：   最终拟合结果：         二、一元二次方程拟合尝试 用f(x)=(x**2) * w0 + x * w1 + b来拟合，这里要注意，因为本实验中原始数据会变动，因此，每一次执行结果会变动，数据的不同，用一元二次和一元一次模型来拟合的精度可能也会有差别，这并不代表哪一个精度高，对比精度，应该用同样的数据来对比。这里就不做了，有兴趣的坛友，可以稍微改下程序，即可实现。   原理不多说直接上代码： import torch import numpy as np torch.manual_seed(2021) # 生层测试数据 x_train = np.random.rand(20, 1) y_train = x_train * 3 + 4 + 3*np.random.rand(20,1) # 画出图像 import matplotlib.pyplot as plt plt.plot(x_train, y_train, 'bo') plt.show() # 转换成 Tensor x_train = torch.from_numpy(x_train) y_train = torch.from_numpy(y_train) # 定义参数 w 和 b w0 = torch.randn(1, requires_grad=True) # 随机初始化 w1 = torch.randn(1, requires_grad=True) # 随机初始化 b = torch.zeros(1, requires_grad=True) # 使用 0 进行初始化 # 构建线性回归模型 def linear_model(x): return (x**2) * w0 + x * w1 + b #def logistc_regression(x): # return torch.sigmoid(x*w+b) y_ = linear_model(x_train) plt.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label='real') plt.plot(x_train.data.numpy(), y_.data.numpy(), 'ro', label='estimated') plt.legend() plt.show() # 计算误差 def get_loss(y_, y): return torch.sum((y_ - y) ** 2) loss = get_loss(y_, y_train) print(loss) # 自动求导 loss.backward() # 查看 w 和 b 的梯度 print(w0.grad) print(w1.grad) print(b.grad) # 更新一次参数 w0.data = w0.data - 1e-2 * w0.grad.data w1.data = w1.data - 1e-2 * w1.grad.data b.data = b.data - 1e-2 * b.grad.data y_ = linear_model(x_train) plt.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label='real') plt.plot(x_train.data.numpy(), y_.data.numpy(), 'ro', label='estimated') plt.legend() plt.show() for e in range(100): # 进行 100 次更新 y_ = linear_model(x_train) loss = get_loss(y_, y_train) w0.grad.zero_() # 注意：归零梯度 w1.grad.zero_() # 注意：归零梯度 b.grad.zero_() # 注意：归零梯度 loss.backward() w0.data = w0.data - 1e-2 * w0.grad.data # 更新 w w1.data = w1.data - 1e-2 * w1.grad.data # 更新 w b.data = b.data - 1e-2 * b.grad.data # 更新 b if (e + 1) % 20 == 0: print('epoch: {}, w0:{}, w1:{}, b:{}, loss: {}'.format(e, w0.data, w1.data, b.data, loss.item())) y_ = linear_model(x_train) plt.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label='real') plt.plot(x_train.data.numpy(), y_.data.numpy(), 'ro', label='estimated') plt.legend() plt.show() 原始数据：   结果：      

发表了主题帖： 《机器学习算法与实现 —— Python编程与应用实例》-- 第六贴 目标检测和深度强化学习

引言： 本贴主要分享10~11章节相关的内容，也是本书的最后两个章节。 本书第10章主要讲解了目标检测相关的内容，从图像中检测出特定的目标。并讲解了目标检测的发展历程，当前常见的算法等； 本书第11章讲解了深度强化学习的相关知识，深度强化学习是一种在交互中学习的理论   第十章 目标检测： 目标检测是计算机视觉的一个重要研究方向，在静态图像或者视频中找到某些特定的特征，从而判断图像/视频中出现的类别，一般会输出一个框，框出具体识别到的东西。   目标检测的任务：分类，定位，检测，分割。   目标检测的发展历程：2013年之前多以传统方法为主，特征提取加分类器。2013年之后，引入了神经网络等概念，促进了目标检测的飞速发展。   传统的目标检测分为：区域选取、特征提取、特征分类三个阶段。 传统的方法存在的问题是计算量很大，特征和分类器关联性较弱，而深度神经网络本身具备特征提取能力和分类能力, 可以借助GPU进行计算加速。   而卷积神经网络在处理图像分类问题时，一般分为两大类算法。第一大类是以R-CNN(region with CNN features)为代表的两阶算法，step1把所有物体框出来，step2，每个物体使用卷积神经网络进行分类。另外，一种是以YOLO(you only look once)/SSD(single-shot multibox detector)算法的一阶处理算法，框出物体的同时进行物体识别分类。 一阶算法，计算速度快，但精度会差些。二阶算法，计算速度慢，但精度会高一些。   Fast RCNN，2015年在RCNN的基础上，Fast RCNN实现了端到端的检测和卷积共享。   之后出现的Faster RCNN，首次提出了锚框的思想，即预先给出一些列的大小和宽高不等的先验框，他们均匀的分布在特征图上。利用特征可以预测这些锚框的类被，以及与真实目标包围框的偏移。这样可以提高检测的精度。   目标检测的评估方法： 1.IoU=交集/并集，假如图像中只有1个物体，定位这个物体时，输出的结果应该是一个框，但定位不准确时，这个框就会出现偏差。假如输出是B框，而实际是A框，则可以用IoU来评价定位的准确性。--适用于判断1个物体的图像的定位准确性   2.mAP(mean Average Precision) 按照IoU评价算法来评估每个类别的精度； 所有图像中某一类别精度的算数平均是平均精度。 平均精度均值：对所有N个类别的平均精度再取平均。   目标检测的原理： 由于性能的原因，目前人们基本不在使用传统的方法来进行目标检测，当前的重点是研究基于深度学习的目标检测算法。 YOLO: You only look once, 顾名思义，看一眼就能判断出目标。它的主要思想：讲目标定位和分类用一个神经网络统一起来，实现端到端的目标检测。把目标检测问题转换为直接从图像中提取边界框和类别概率的单回归问题，一次就可以检测出目标的分类和位置。Yolo模型的运算速度非常快，借助GPU可以实现非常高的检测帧率。 2015年 yolov1 2016年 yolov2 2018年 yolov3 2020年yolov5 2022年 yolov6/7 2023 年yolov8 2024年 yolov9 Yolo的各个版本介绍，网上已经很多了，就不在赘述。 本书，讲解了yolov1~5的基本特点，然后着重讲解了yolov4的原理与实现，可以帮助读者从根本上理解人工智能网络的设计和实现。     第十一章 深度强化学习 人工智能中，有很多应用问题要求再算法时刻做出决策并执行动作。智能体在与环境的交互过程中根据获得的奖励或者惩罚不断的学习知识，调整自己的动作策略，以达到某个预期目标。解决这类问题的机器学习算法被成为强化学习。 深度强化学习是深度学习与强化学习的结合产物。   强化学习要解决的问题可以抽象为马尔可夫决策过程（MDP）, 特点是：系统下一时刻的状态由当前时刻的状态决定，而与更早的时刻的状态无关。MDP智能体可以执行动作，以改变自己和环境的状态，并且得到惩罚和奖励。 Q学习算法：如果知道所有状态转移的概率以及结果，理论上可使用动态规划算法求解出最优策略。然而实际当中，无法直接得到所有的状态间的转移概率，无法使用动态规划来求解。从而产生了随机算法来求解。典型的便是Q学习算法。这是一种无模型的算法，他提供智能系统在马尔可夫环境下通过动作序列选择最优动作的学习能力。   深度强化学习：传统的Q学习中，Q值存储在Q表中，表中各行是所有可能的状态，各列是所有可能的动作。如果量少，问题不大。当面对一些存在很多可能的情况下，Q表的建立难度非常大，导致Q算法很难应用到解决现实问题当中。 为解决这个难题，可用值近似函数来表示Q表，加入权重，借助神经网络来实现。具体书中讲的很清楚，由于公式比较多，这里就不赘述了。    

回复了主题帖： 《机器学习算法与实现 —— Python编程与应用实例》-- 第五贴 神经网络学习与感悟

Jacktang 发表于 2024-8-5 07:21 神经网络是个神秘的东西，就是不知道怎么学习和感悟了   其实 并不神秘，有很多教材 都讲的比较好； 实质上 就是通过模仿神经元工作原理，然后加上数学一些思想，讲物理世界的数据通过卷积(这个也不不是很难) 抽离出来一些特征，通过大数据来不断强化神经元的连接(锁定权重)，这便是训练的过程；等训练完了，推理过程就是一样的概念； 这玩意比人脑差远了，人脑可以自主进行训练学习，边学边推理，可以形成自主思想；而人工智能，从理论上讲，根本不可能产生新的思想，更多的是大数据的产物，从目前来看，也就是更为智能的专用计算机，替代人类，恐怕看看不到一点希望。。

发表了主题帖： 《机器学习算法与实现 —— Python编程与应用实例》-- 第五贴 神经网络学习与感悟

引言： 本贴主要分享7~9章节相关的内容。 本书第七章讲解了神经网络的相关知识。从神经网络的发展讲述到神经网络的实现，完整叙述了神经网络的基础理论和引用。人工神经网络(Artificial Neural Networks, ANNs), 简称神经网络（NN）；神经网络是目前最为火热的人工智能的重要技术支撑。神经网络的灵感来源于人类大脑中的神经元，神经元通过突出连接，从而通过不同强度的生物电信号，来实现人类的思维活动。当前的神经网络只是类人脑神经元工作模式。第八章讲解了PyTorch框架的使用，这是一个比较受大家欢迎的深度学习框架，还有tensorflow等。第九章，讲解了深度卷积神经网络。   从感知机到多层神经网络 感知机是一种单层的模拟大脑神经元工作的网络结构。     多层神经网络是多层神经元通过一定形式连接在一起的网络结构，单层神经网络只能处理较为简单的问题，解决复杂的识别问题时常常表现不佳。 神经元和感知器本质上是一样的，感知器的激活函数通常是阶跃函数；激活函数可以理解为该神经元达到什么情况下才能输出信号。也就是激活该神经元。而神经元的激活函数通常为sigmoid函数或者tanh函数，选择这两个函数的根本原因，在于多层神经网络算法实施过程中训练时，通常需要求导数。而阶跃函数是不连续的函数，在0处不可导，计算起来不方便。   本章节从基本模型讲起，通过公式表述，将如何模型化神经网络，如何用数学公式表述以及求解多层神经网络讲述的比较清楚，同时讲解了如何通过python来进行多层神经网络的训练。 随着人工智能的兴起，各种神经网络架构被设计出来，用于解决物品分类，对话，自动文本生成，图像生成等技术中。神经网络越来越复杂，深度神经网络以其优异的性能，逐步崭露头角。很多时候，我们不得不借助一些成熟框架，来调用一些比较成熟的网络模型。但是，如果能够真正从数学理论，实现上理解神经网络的设计和实现过程，那必然会对应用神经网络，以及设计新的人工网络奠定强有力的基础。   演变到今日，深度神经网络的发展，使得人们认识到算力成为了人工智能发展的瓶颈。在单位时间内，如何用最少的能源实现更高的算力成为了关键。英伟达抓住了历史机遇，以GPU为契机，逐步抓住人工智能革命的浪潮，成为引领当前人类人工智能发展的科技巨头。   深度学习框架： 深度学习一般遵循通用的开发模式：定义损失函数、求导、权重更新和数据拟合。深度学习网络的层数较多，手工编写代码效率较低，所以研究人员开发一种编程架构来简化程序的编写。Tensor(张量)相关的计算、自动求导、以及一些常用的人工智能模型调用接口。这些将极大方便开发者。   深度学习以及深度神经网络： 深度学习模型：卷积、深度置信和递归。卷积深度神经网络通常包括卷积层、池化层、全连接层。 卷积的概念其实很简单，就是矩阵成法。池化也成为下采样，目的是减小特征图的尺寸，选取较为有用的信息，通常有取平均值，取最大值等。 CNN训练之前，通常需要进行归一化，比如图像要都归一化为200X200大小，归一化也要有一定的要求，否则会丢失图片原有的信息，造成推理或者训练的偏差。   本书讲解了几个常用的深度神经网络，比如AlexNex，VGG, GooLeNet， Resnet, DenseNet等。   浅谈中美人工智能之间的差距 最根本的差距人才差距  -- 教育、人才数量、数学、材料、物理、工程差距依然很大 半导体设计/生产上的差距 -- 从顶尖芯片设计/制造公司的数量和质量上看，相差极大 计算机软硬件之间的差距  -- 从底层到外设，差距不可谓不大 数学理论上的差距  -- 这个差距说实话，我不太能感知到 其他差距 – 欢迎大家探讨 对中国人工智能行业发展的几点意见 1.人才是根本，教育是基础； 2.长久投入，长期主义；中国的人工智能不出意外，最先实现盈利的仍然是应用层面的公司，比如月之暗面和一大批互联网巨头；而AI基础设施，比如服务器组装厂也会在AI浪潮中分一杯羹。但是，AI芯片设计公司，可能并不会一帆风顺，相反可能很长一段时间内由于缺乏真正的技术创新，而无法跟上全球AI发展的步伐。 3.国家层面，应当尽快补足芯片制造的短板，并且建立国家层面的基础IP共享平台，免费或者以低廉的价格给到学生以及初创企业使用，避免国家投资都在重复的造轮子，或者大量的资金都流向了头部的EDA公司或者IP授权商那里。   些许感悟： 怎么说呢，世界发展浪潮浩浩荡荡，其实人工智能只是计算机技术发展到一定阶段所产生的附加技术，其实质上还是建立在第三次工业革命技术的基础上。我觉得人工智能并不能根本上改变人类发展的方向。新材料的发现、基础理论的突破，才是人类未来能否突破现有生产力瓶颈的根本因素。这必将花费人类上百年或者上千年的时间… 但不知那时，人类是否还存在，但你我终将无法看见了..   不得不说open AI将死气沉沉的人工智能再一次重塑金身，这将是人类发展史上的一次新的契机，借助人工智能，人类必将能走向更远的未来..          

发表了主题帖： 《机器学习算法与实现 —— Python编程与应用实例》-- 第四贴 逻辑斯蒂回归

本帖最后由 传媒学子 于 2024-7-29 22:09 编辑 引言： 本书第六章讲解了逻辑斯蒂回归。   Logistic函数： 罗吉斯蒂克函数，即logistic函数。逻辑函数或逻辑曲线是一种常见的S函数，它是皮埃尔·弗朗索瓦·韦吕勒在1844或1845年在研究它与人口增长的关系时命名的。广义Logistic曲线可以模仿一些情况人口增长（P）的S形曲线。起初阶段大致是指数增长；然后随着开始变得饱和，增加变慢；最后，达到成熟时增加停止。 Logistic函数：        从网上看到了很多logistic回归的讲解，但是很少讲到名字的来源，这里搜到了一些介绍。有些将logistic翻译为“逻辑”， 有些讲其翻译为”逻辑斯蒂“，我本人也没有太弄明白，哪一个翻译更合适，故本文按照英文名字来直接引述。   本书首先讲解了最小二乘法，进而引入梯度下降法，然后讲解了多元线性回归，最终讲解了logistic回归的具体实现。从原理到代码，循序渐进，帮助读者知其然，并知其所以然。   最小二乘法： 这个概念从小学一直学到研究生，甚至在工作当中也会接触到这个概念，但是说实话，总是默模模糊糊，不是很清晰。最小二乘法是线性回归模型中最广泛应用的方法。其数学原理，就是通过最小化误差的平方和来找到一组数据的最佳的拟合函数。   一般直线拟合，大家都能理解，还有曲线拟合，随着拟合曲线的复杂程度，参数也会越来越多，计算和理解起来就麻烦了，很多时候公式中都会有累加符号。     因为偏差有正有负，因此需要引入模的概念，进而计算平方比较简便。对于一元二次方程，有2个参数，y=ax+b, 实际点(xi,yi)对于F(a,b) = 所有点的差的平方(yi – axi – b) ^2，学过高数的应该能看懂，这是一个二次函数，存在一个极小值点，且这个极值点存在于导数为0的位置，通过极值分别以a和b求各自的偏导数，找寻各自的极值。 联立方程即可求解a和b.       梯度下降法(Gradient Descent)： 当数据较多或者模型是非线性模型时，或者参数比较多且复杂时，无法直接求出模型参数的解析解。此时，可以尝试通过迭代逐步逼近模型的最优参数，这是机器学习中最常用的一种优化求解方法。   只需要损失函数的一阶导数，计算相对简单，核心思想：通过当前点的梯度方向寻找新的迭代点，不断迭代，直至找到最优参数。 面临的问题：如何计算梯度？梯度大小(学习率、步长)设多少合适？ 聪明的数学家，通过随机梯度下降法和小批量梯度下降法可以优化梯度下降法的一些缺陷，但随之带来了新的问题，计算的并行度以及批量大小的设定等。   多元线性回归： 顾名思义，是指多个自变量与因变量之前依然满足线性关系的数据回归模型。 损失函数的设定，以及对每个参数求偏导数，计算相关参数。   Logistic回归的原理： 最小二乘法可以对线性模型进行回归，但不能有效解决离散的分类问题。在线性回归模型的基础上，使用Sigmoid函数，将线性模型的结果压缩到[0,1]之间，使其拥有概率意义，它可以将任意输入映射到[0,1]区间，实现值到概率转换。   最小二乘线性模型用矩阵的表达为：         Logistic regression的优缺点： 优点：计算代价不高，易于理解和实现 缺点：容易欠拟合，分类精度不高 应用场景 逻辑回归主要是解决二分类问题，比如 1.区分是否是垃圾邮件 2.银行判断是否给用户办信用卡   总结： 机器学习的基础原理 数学-> 建模 ->数据处理->编程 ->解决问题， 编程只是最为普通的一步，如何建模，才是机器学习、人工智能的核心。

回复了主题帖： 《机器学习算法与实现 —— Python编程与应用实例》-- 第三贴 K均值聚类算法

御坂10032号 发表于 2024-7-25 00:29 我们老师讲这个的时候 给了我们一个网站 可以让我们动态的看到是怎么聚集在一起的。现在忘了扔到哪里去了 找到了 可以分享下， 算法理解起来 不算难，但是 数学原理比较多，人工智能的基础就是数学，高数/概率论/线代..

发表了主题帖： 《机器学习算法与实现 —— Python编程与应用实例》-- 第三贴 K均值聚类算法

引言： 本书第五章讲解了K均值聚类算法 K均值聚类算法是一种简单的迭代型算法，它使用距离来评判相似性，发现给定数据集中的k个类别，其中每个类别的中心都由该类别中的所有值的均值得到，最后每个类别都由聚类的中心描述。一般采用欧氏距离。核心思想：循环迭代求解。 K均值聚类算法属于无监督学习，k最近邻算法属于经典的监督学习，分类是已知的。而K均值聚类算法的分类是未知的。通过感知样本间的相似度进行类别归纳。   K均值聚类原理： 重复移动类别的中心(或者重心)，移动至其包含成员的平均位置；然后重新划分其内部成员；重复执行上述过程直到收敛或者达到最大迭代次数。K是提前设置的超参数，表示类别个数。，   K均值聚类算法： 先随机选取K个对象作为初始的聚类中心。然后计算每个对象与各个种子聚类中心之间的距离，把每个对象分配给距离它最近的聚类中心。聚类中心以及分配给它们的对象就代表一个聚类。一旦全部对象都被分配了，每个聚类的聚类中心会根据聚类中现有的对象被重新计算。这个过程将不断重复直到满足某个终止条件。终止条件可以是以下任何一个： 1、没有（或最小数目）对象被重新分配给不同的聚类。 2、没有（或最小数目）聚类中心再发生变化。 3、误差平方和局部最小。   K均值聚类算法首先保持u(重心)不变，重复迭代更新c来最小化J, 然后保持c不变，更新参数u来最小化J. 从数学上讲，J一定单调递减且收敛。理论上，K均值聚类算法可能会在不同的聚类重心之间振荡，对于不同的c和/或不同的u可能会得到相同的J值。 u指的是重心, c指的是元素，J指的是损失函数(欧氏距离平方和)。   评估聚类性能 对于分类问题，可以直接通过计算被错误分类的样本数量，得出准确率；然而聚类问题，并没有具体的标签，无法直接用绝对数量来评估性能。 本书介绍了两种方法来评估聚类，第一种是调整兰德指数（ARI），第二种是轮廓系数。 如果被评估的数据本身带有正确的类别信息时，可以用ARI. 轮廓系数是一种适用于评估的数据无标签时进行评估。文章用一个例子很好的说明了轮廓系数的使用。     轮廓系系数最大的k，为最佳的分类数。   K均值聚类算法应用： 本书讲解如何利用K均值聚类算法实现图像的压缩功能，在保证图片质量的前提下，节省了20%多的存储空间。   分享中数学知识没有过多涉及，一方面这些公式难以书写，另一方面写出来似乎也难以描述清楚，感兴趣的同学，可以搜索K-means聚类算法，有很多公式。而本书可以作为一个很好的工具书，引导大家更快的建立相关知识体系，凝练人类现有智慧，为前行者指引方向，我想这便是书籍的作用，而本书则是其中一员。

回复了主题帖： 招聘资深AI芯片板卡固件/嵌入式开发工程师

目前已经招到一个资深的了，3~5年的工程师 还有HC, 有感兴趣的可以留言

发表了主题帖： 《机器学习算法与实现 —— Python编程与应用实例》-- 第二贴 K最邻近算法

本帖最后由 传媒学子 于 2024-7-15 00:51 编辑 引言： 本书第四章讲解了K最近邻算法，本算法在之前的ACM等算法设计大赛中也是比较常见的算法。 什么是K最近邻算法？ kNN(k-Nearest Neighbor)算法，是机器学习中最基础的算法之一，既能用于分类，又可用于回归。核心思想：通过度量给定样本到训练数据集中所有样本的特征距离，将与给定样本特征距离最近的k个样本中出现次数最多的类别指定为该样本最优估计的类别； K最近邻原理： 分类问题中，对于一个新样本，可以根据距离最近的样本的类别来判断其所属的类别。因为k近邻算法主要依靠周围邻近的有限样本而非判别类别的方法来确定所属类别，所以对类别交叉或重叠较多的待分样本集，较其他方法来说更合适。   存在的问题： 样本不平衡时，会产生误判，可以通过加权（与样本距离短的邻居权重大）来改进。 仅适用于数据量少的情况，否则计算复杂度会过高。   特征距离计算： 机器学习中常见的距离度量有：曼哈顿距离，欧氏距离等。kNN算法中通常使用的欧氏距离 曼哈顿距离，也称为城市街区距离或出租车距离，是一种计算在标准坐标系上两点之间距离的方法，它表示两个点在南北方向上的距离加上在东西方向上的距离。这种距离的计算方式得名于规划为方形建筑区块的城市，如曼哈顿，其中最短的行车路径（忽略单向车道和特定大道的斜向车道）是通过南北方向和东西方向上的直线距离之和来确定的。 曼哈顿距离的计算公式为：http://www.w3.org/1998/Math/MathML">𝑑(𝑖,𝑗)=∣𝑋1−𝑋2∣+∣𝑌1−𝑌2∣d(i,j)=∣X1−X2∣+∣Y1−Y2∣，其中http://www.w3.org/1998/Math/MathML">(𝑋1,𝑌1)(X1,Y1)和(𝑋2,𝑌2)(X2,Y2)是二维平面上的两个点。这个公式直接反映了曼哈顿距离的定义，即两点在南北方向上的距离加上在东西方向上的距离。   曼哈顿距离的概念不仅来源于地理和城市规划，也与数学中的最值问题相关。它的产生是为了解决一类特定的数学问题，通过绝对值的几何意义和函数图像的角度来求解最小值。在计算机科学和数据分析中，曼哈顿距离常用于需要计算在网格状结构上点与点之间距离的场景，如图像处理、路径规划等。 此外，曼哈顿距离与欧几里得距离（即通常所说的直线距离）不同，后者是通过勾股定理计算两点之间的直线最短距离。曼哈顿距离的计算方式更直观地反映了在街道网络中行走的路径，因此也被称为“计程车几何”，因为在出租车行驶时，司机通常会选择直线行驶而不是走弯路以节省时间或距离。 欧氏距离：通常是指直线距离 二维平面的距离公式为：   可推广到多维空间：     算法实现： 本书利用python演示了从数据生成-算法实施-编程示例以及结果分析一整套kNN算法流程。   感悟： 通过kNN算法我们要明白一点，机器学习或者说人工智能算法的核心是数学，数学是人工智能的核心，编程只是人工智能实施的工具，而数据则是算法成长的必备食粮。年轻的朋友们如果想窥探人工智能的世界，请务必要学好数学，高等数学/线性代数/概率论以及研究生的解析几何等数学知识，否则我们只是一个操作工，而且是一个低等的操作工，想成为人工智能学科的科学家，数学是不能绕开的基础。

回复了主题帖： 《机器学习算法与实现 —— Python编程与应用实例》-- 第一贴 初识

Verifone 发表于 2024-7-5 10:23 这种算法的书看起来就头疼，要花太多时间静下心了，难懂的 其实 还好，有些东西多接触 接触，不难理解。AI的核心是自己设计模型，然后其实我们很多人搞的就是 如何用？ 可能用都还用不好..  然后AI这个是软硬件结合 然后从数学到建模到芯片设计，软硬通吃的一门学问.. 

回复了主题帖： 《机器学习算法与实现 —— Python编程与应用实例》-- 第一贴 初识

秦天qintian0303 发表于 2024-7-5 09:13 有没有大致看一下，这本书的主要侧重方向是什么？  等我看完 再回答您这个问题  这本书是一个比较入门的教材，比较全面

回复了主题帖： 颁奖：嵌入式工程师AI挑战营（初阶），致敬敢于将边缘AI收入统治领域的你们

好厉害

发表了主题帖： 《机器学习算法与实现 —— Python编程与应用实例》-- 第一贴 初识

本帖最后由 传媒学子 于 2024-7-4 21:56 编辑 引言：由于平时工作比较忙，下班比较累了，很难抽出时间来制作电子产品，因此也错过了论坛很多的有意思的评测活动；偶然间，发现最近论坛推出了一些优秀的书籍，来供大家评测，看到这本书与自己最近在从事的人工智能领域非常契合，因此，参与了此次活动。因为书籍是6月27号左右才收到的，因此，第一次分享比原来的计划要晚了几天，花了几天时间，看了一些书的整体框架和第1-3章，特此分享给大家。   作者介绍： 一本优秀的书，一定是出自优秀的作者之手，本书的作者布树辉老师，是西北工业大学的教授，与西工大飞行器智能认知与控制实验室的师生一起，为大家编撰了本书。布老师是2021年的吴文俊人工智能科学技术发明一等奖获得者。粗略翻了一下此书，无论是知识广度还是深度都是一本不可多得的介绍人工智能的书籍。责任编辑谭美平也是下了很大功夫，整个排版看起来十分清爽，全书作图美观，字体优雅，又不失专业。     本书框架介绍： 本书从机器学习的发展史开始，讲述了机器学习的基本概念，讲述了机器学习常用的python编程语言的基本知识，以及机器学习的常见算法，以及当下热门的人工智能常用的神经网络（深度神经网络），最终以Pytorch框架为载体，讲述了目标检测的一些常见算法的基本原理和应用。全书由浅入深，理论结合实际，初步感觉是这样，等读完了看看是否符合自己的认知。   第1章 绪论 –读后感 以前总是分不清人工智能和机器学习的区别，从本书中得到了好的解释。人工智能是一个比机器学习更为宽泛的概念，机器学习是人工智能领域中重要的一种方法，机器学习的本质是一类算法的总称，这些算法能够从大量历史的数据中挖掘出隐含的规律，并用于分类、回归和聚类。 回归和分类都属于监督学习，回归常见的有线性回归，预测未来的房价和气温等。分类问题的目的是将事物打上标签，结果一般是离散的。 泛化：模型对新的输入的识别能力，识别能力越好，说明泛化能力越强。 泛化表现非常差，说明模型出现了过拟合。所谓的过拟合，是指模型对于训练的数据集表现非常出色，对于新的数据集识别能力很差。   机器学习的分类：监督学习、无监督学习和半监督学习。深度学习属于半监督学习，正在向无监督学习进步，但要做的事情还很多。   人工神经网络可分为浅层神经网络和深度神经网络。深度神经网络是机器学习的一个新的研究方向，最接近于实现人工智能。深度神经网络的灵感来源于人脑的工作方式，多层网络可以更好的挖掘图像特征，进而提高对目标差异识别的检测率。   学习人工智能的方法，应该由浅入深，逐步补足基础，不能因为涉及知识面过多而踟蹰不前，也不能因为过于关注模型的学习，而忽略了其理论基础。   第2章 python语言和第3章python常用库 读后感 Python语言是一种解释性语言，从我使用的角度来看，python帮助我节省了大量的编程时间，学习成本比较低。人工智能的学习最近比较火热的便是pytorch, py顾名思义离不开python, 具体不多说了。借助社区版的pycharm和anaconda可以实现基本的人工智能模型训练和学习平台。    

回复了主题帖： 共读入围：《机器学习算法与实现 —— Python编程与应用实例》

个人信息无误，确认可以完成评测计划。

发表了主题帖： 招聘资深AI芯片板卡固件/嵌入式开发工程师

招聘资深嵌入式工程师，上海为佳，北京需要非常资深，接受短暂出差； 公司为初创AI芯片公司，技术实力雄厚，leader nice. 公司没有加班文化，不打卡，双休节假日，公积金等待遇都是按政策上线，待遇看实力，薪资范围30~50K * 16月,  其中13薪固定，3个月奖金根据情况浮动，特别优秀的，可以再谈；PS: 初创公司也会有一些风险，但未来收益也大。 机会难得，先到先得， 岗位找到人后，本贴就会删除，能看到这个帖子，就可以联系   有兴趣，私信我，工作日1~2天回复，五一节后会回复； JD如下： 岗位要求 1. 具有多年芯片公司Firmware开发背景，至少完整经历过一款芯片的硅前Firmware开发和bring-up过程，能独立负责现有框架下的Firmware开发 2. 熟悉C语言 3. 熟悉Arm或者RISC-V平台 4. 有AI芯片固件开发经验，熟悉SPI/I2C/UART等接口协议者优先, 熟悉虚拟化技术优先 5. 有芯片原厂BIOS开发经验优先 6. 具有很强的学习能力和分析问题解决问题能力 7. 有团队精神，沟通能力强   工作场景 硅前硅后芯片Firmware开发 和硅前硅后验证，性能调优，软件组都有比较多的合作。        

加入了学习《石头剪刀布之AI时代》，观看 石头剪刀布之AI时代--结项视频