神经网络一般多少显存够用

❶ 神经网络的数据量多少比较合适

一般来说要1万以上，越多越好，但要保证采集标准统一，且输出为相同的数据不能太多。

❷ matlab神经网络训练一般需要多少数据

你这个问题真的不好回答，因为没有固定答案，也没有什么经验答案，不能太少也不能太多，因为需要根据实际情况决定了，看你是要做什么了

❸ 运行神经网络的机器需要什么配置

摘要 您好~这道问题问得很好，我需要一点时间编辑答案，还请您耐心等待一下。

❹ 怎么查看自己搭建的神经网络需要的显存

newrb设计了径向基网络，调用格式：net=newrb[net,tr]=newrb(P,T,goal,spread,MN,DF)P-Q组输入向量组成的R×Q维矩阵；T-Q组目标分类向量组成的S×Q维矩阵；goal-均方误差,默认值为0；spread-径向基函数的扩展速度,默认值为1；MN-神经元的最大数目,默认是QDF-两次显示之间所添加的神经元数目,默认值为25；net-返回值，一个径向基网络；tr-返回值，训练纪录。

❺ BP神经网络的训练集需要大样本吗一般样本个数为多少

BP神经网络的训练集需要大样本吗？一般样本个数为多少？
BP神经网络样本数有什么影响
学习神经网络这段时间，有一个疑问，BP神经网络中训练的次数指的网络的迭代次数，如果有a个样本,每个样本训练次数n，则网络一共迭代an次，在n>>a 情况下 ， 网络在不停的调整权值，减小误差，跟样本数似乎关系不大。而且，a大了的话训练时间必然会变长。
换一种说法，将你的数据集看成一个固定值， 那么样本集与测试集 也可以按照某种规格确定下来如7：3 所以如何看待 样本集的多少与训练结果呢？ 或者说怎么使你的网络更加稳定，更加符合你的所需 。

我尝试从之前的一个例子中看下区别

如何用70行Java代码实现深度神经网络算法

作者其实是实现了一个BP神经网络 ，不多说，看最后的例子

一个运用神经网络的例子
最后我们找个简单例子来看看神经网络神奇的效果。为了方便观察数据分布，我们选用一个二维坐标的数据，下面共有4个数据，方块代表数据的类型为1，三角代表数据的类型为0，可以看到属于方块类型的数据有（1，2）和（2，1），属于三角类型的数据有（1，1），（2，2），现在问题是需要在平面上将4个数据分成1和0两类，并以此来预测新的数据的类型。


图片描述

我们可以运用逻辑回归算法来解决上面的分类问题，但是逻辑回归得到一个线性的直线做为分界线，可以看到上面的红线无论怎么摆放，总是有一个样本被错误地划分到不同类型中，所以对于上面的数据，仅仅一条直线不能很正确地划分他们的分类，如果我们运用神经网络算法，可以得到下图的分类效果，相当于多条直线求并集来划分空间，这样准确性更高。

图片描述

简单粗暴，用作者的代码运行后 训练5000次 。根据训练结果来预测一条新数据的分类（3,1）



预测值 （3,1）的结果跟（1,2）（2,1）属于一类 属于正方形

这时如果我们去掉 2个样本，则样本输入变成如下

//设置样本数据，对应上面的4个二维坐标数据
double[][] data = new double[][]{{1,2},{2,2}};
//设置目标数据，对应4个坐标数据的分类
double[][] target = new double[][]{{1,0},{0,1}};
1
2
3
4
1
2
3
4




则（3,1）结果变成了三角形，

如果你选前两个点 你会发现直接一条中间线就可以区分 这时候的你的结果跟之前4个点时有区别 so 你得增加样本 直到这些样本按照你所想要的方式分类 ，所以样本的多少 重要性体现在，样本得能反映所有的特征值（也就是输入值） ，样本多少或者特征（本例子指点的位置特征）决定的你的网络的训练结果，！！！这是 我们反推出来的结果 。这里距离深度学习好像近了一步。

另外，这个70行代码的神经网络没有保存你训练的网络 ，所以你每次运行都是重新训练的网络。其实，在你训练过后 权值已经确定了下来，我们确定网络也就是根据权值，so只要把训练后的权值保存下来，将需要分类的数据按照这种权值带入网络，即可得到输出值，也就是一旦网络确定， 权值也就确定，一个输入对应一个固定的输出，不会再次改变！个人见解。

最后附上作者的源码，作者的文章见开头链接
下面的实现程序BpDeep.java可以直接拿去使用，

import java.util.Random;
public class BpDeep{
public double[][] layer;//神经网络各层节点
public double[][] layerErr;//神经网络各节点误差
public double[][][] layer_weight;//各层节点权重
public double[][][] layer_weight_delta;//各层节点权重动量
public double mobp;//动量系数
public double rate;//学习系数

public BpDeep(int[] layernum, double rate, double mobp){
this.mobp = mobp;
this.rate = rate;
layer = new double[layernum.length][];
layerErr = new double[layernum.length][];
layer_weight = new double[layernum.length][][];
layer_weight_delta = new double[layernum.length][][];
Random random = new Random();
for(int l=0;l<layernum.length;l++){
layer[l]=new double[layernum[l]];
layerErr[l]=new double[layernum[l]];
if(l+1<layernum.length){
layer_weight[l]=new double[layernum[l]+1][layernum[l+1]];
layer_weight_delta[l]=new double[layernum[l]+1][layernum[l+1]];
for(int j=0;j<layernum[l]+1;j++)
for(int i=0;i<layernum[l+1];i++)
layer_weight[l][j][i]=random.nextDouble();//随机初始化权重
}
}
}
//逐层向前计算输出
public double[] computeOut(double[] in){
for(int l=1;l<layer.length;l++){
for(int j=0;j<layer[l].length;j++){
double z=layer_weight[l-1][layer[l-1].length][j];
for(int i=0;i<layer[l-1].length;i++){
layer[l-1][i]=l==1?in[i]:layer[l-1][i];
z+=layer_weight[l-1][i][j]*layer[l-1][i];
}
layer[l][j]=1/(1+Math.exp(-z));
}
}
return layer[layer.length-1];
}
//逐层反向计算误差并修改权重
public void updateWeight(double[] tar){
int l=layer.length-1;
for(int j=0;j<layerErr[l].length;j++)
layerErr[l][j]=layer[l][j]*(1-layer[l][j])*(tar[j]-layer[l][j]);

while(l-->0){
for(int j=0;j<layerErr[l].length;j++){
double z = 0.0;
for(int i=0;i<layerErr[l+1].length;i++){
z=z+l>0?layerErr[l+1][i]*layer_weight[l][j][i]:0;
layer_weight_delta[l][j][i]= mobp*layer_weight_delta[l][j][i]+rate*layerErr[l+1][i]*layer[l][j];//隐含层动量调整
layer_weight[l][j][i]+=layer_weight_delta[l][j][i];//隐含层权重调整
if(j==layerErr[l].length-1){
layer_weight_delta[l][j+1][i]= mobp*layer_weight_delta[l][j+1][i]+rate*layerErr[l+1][i];//截距动量调整
layer_weight[l][j+1][i]+=layer_weight_delta[l][j+1][i];//截距权重调整
}
}
layerErr[l][j]=z*layer[l][j]*(1-layer[l][j]);//记录误差
}
}
}

public void train(double[] in, double[] tar){
double[] out = computeOut(in);
updateWeight(tar);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
下面是这个测试程序BpDeepTest.java的源码：

import java.util.Arrays;
public class BpDeepTest{
public static void main(String[] args){
//初始化神经网络的基本配置
//第一个参数是一个整型数组，表示神经网络的层数和每层节点数，比如{3,10,10,10,10,2}表示输入层是3个节点，输出层是2个节点，中间有4层隐含层，每层10个节点
//第二个参数是学习步长，第三个参数是动量系数
BpDeep bp = new BpDeep(new int[]{2,10,2}, 0.15, 0.8);

//设置样本数据，对应上面的4个二维坐标数据
double[][] data = new double[][]{{1,2},{2,2},{1,1},{2,1}};
//设置目标数据，对应4个坐标数据的分类
double[][] target = new double[][]{{1,0},{0,1},{0,1},{1,0}};

//迭代训练5000次
for(int n=0;n<5000;n++)
for(int i=0;i<data.length;i++)
bp.train(data[i], target[i]);

//根据训练结果来检验样本数据
for(int j=0;j<data.length;j++){
double[] result = bp.computeOut(data[j]);
System.out.println(Arrays.toString(data[j])+":"+Arrays.toString(result));
}

//根据训练结果来预测一条新数据的分类
double[] x = new double[]{3,1};
double[] result = bp.computeOut(x);
System.out.println(Arrays.toString(x)+":"+Arrays.toString(result));
}
}

❻ unet模型属于哪种神经网络

unet模型属于卷积神经网络。是德国弗莱堡大学计算机科学系为生物医学图像分割而开发的，该网络基于全卷积网络其架构经过修改和扩展，可以使用更少的训练图像并产生更精确的分割，Unet是2015年诞生的模型。

unet模型的特点

Unet是比较早的基于深度学习的分割算法了，优点是速度真的快P100上基于VGG的backbone能跑到50帧，同时不是太开放的场景下可以做到令人满意的分割效果，在对实时性要求较高的场合下是比较适用的不是所有的场合都能上MaskRCNN的Backbone大一点。

如果显卡差点就容易爆显存了，同时相比大分割网络的模型动辄几百Mb，Unet用小backbone模型就可以做到10Mb内，Conv层通道减少一点再把网络模型参数分开，模型大小可以做到很小，用CPU跑速度都挺快的，关键是分割精度在较为简单场景下还可以。

❼ 人脑有多大的内存

在《大脑与思维》杂志发表的文章称，尽管最大的电脑的记忆容量是1,000,000,000,000个字节（10的12次方），人脑的记忆容量的字节数则大约到10后面跟8432个零。 人脑中神经元的数量是已知的，大约为1000亿个，许多分析家以此为基础提出了电脑不久将超过人脑的观点。但是，研究人员并不局限于这个角度，他们运用一系列运算法则，计算出了人脑的记忆容量，其中包括不同神经网络的庞大功能。 具有讽刺意味的是，这项发现可能会改变电脑设计的思路。今后电脑的改进可能不是增加字节，而是模仿人脑，更加注重神经网络。
答案补充
人脑 好象是 谁来着 研究的 说人脑开发最好的不过 才开发了%5 %95是你达不到的！`人脑里的电能带起 20W灯泡吧 人脑子里储存的各种信息，可相当于美国国会图书馆的50倍，即5亿本书的知识 你想想比内存好吧！~ 人脑细胞有140——160亿条，被开发利用的仅占1/10。大人的大脑平均为人体总体重的2%，但它需要使用全身所用氧气的25%，相比之下肾脏只需12%，心脏只需7%。神经信号在神经或肌肉纤维中的传递速度可以高达每小时200英里。 人体内有45英里的神经。 人的大脑细胞数超过全世界人口总数2倍多，每天可处理8600万条信息，其记忆贮存的信息超过任何一台电子计算机。 把世界上的CPU加起来吧！~ CPU只不过是 被开发出来的了 人脑你才开发了5% 你要全开发了 幽默点说 你自己回家印美圆去吧！~哎！~美圆不值钱 印英镑算了！~ 一句话 电脑内存也好 CPU处理快也好 是因为被开发出来 人脑还是未知95%啊！~

❽ 哪家服务商GPU更适合深度学习领域

现在基本上都会选择云服务让电脑上云，租用云服务器的方式来完成深度学习领域需要的高配电脑服务。
总体而言，NVIDIA目前最适合深度学习的GPU是RTX3080和RTX3090。RTX系列显卡对于深度学习来说最大的优势在于专为神经网络设计的运算单元——Tensor Core（张量核心），而RTX30系列性能的提升是上一代产品图灵架构的2倍。
根据测评参数，NVIDIA旗舰显卡RTX3080拥有8704个CUDA核心，272个TMU，88个ROP，以及68个SM。Tensor Core数量达到544个，RT Core为136个。
其中，被称为GPU“猛兽”的RTX 3090 使用代号为 GA102 的核心，和前代泰坦一样拥有 24G 显存，但型号升级为 DDR6X（镁光提供），显存速度 19.5Gbps，384bit 位宽，拥有 10496 个等效 CUDA 核心，相比 GeForce RTX 2080 Ti，3090 的核心数量增加一倍不止。
不过，自2020年9月上市以来，RTX3080和RTX3090一直处于一卡难求的状态，市场价更是涨了7倍，而供货商甚至无法预测具体的供货时间。
对于企业和实验室的科研人员而言，要在预算范围内购买最新的GPU，特别是RTX3080和RTX3090这类旗舰显卡难以实现；进行整机配置时，需要考虑多个因素，比如电源、机箱体积，主板的PCle卡槽等，这时候，云电脑在GPU算力上的选择则更为灵活和方便。

❾ gtx960显卡4g内存能跑yolov5神经网络吗

能跑，甚至部署在openvino上的话用cpu都能跑几十帧

❿ sklearn神经网络节点数一般选多少

一般从1开始。
因为是全连接神经网络，所以会有很多个参数，参数右上角是下一层对应的网络层数（在吴恩达系列视屏中输入层不作为一层。
所以右上角是从1开始的，此处是从2开始的），右下角第一个数是下一层神经元的位置，第二个数是前一层神经元的位置。