文章目录

神经网络编程基础
- 2.1 二分类(Binary Classification)
- 2.2逻辑回归(Logistic Regression)
- 2.3逻辑回归的代价函数(Cost Function of Logistic Regression)
- 2.4 梯度下降(Gradient Descent)
- 2.5 计算图(Computation Graph)
- - 计算J的导数
  - 反向传播
- 2.9 逻辑回归中的梯度下降(Logistic Regression Gradient Descent)
- 2.10 Logistic Regression on m examples代码流程
- 2.11向量化表达(Vectorization)
- 2.13向量化逻辑回归(Vectorizing Logistic Regression)
- 2.14 向量化Logistic回归的梯度(Vectorizing Logistic Regression's Gradient)
- 2.18 Logistic损失函数的来由(Explanation of Logistic Regression cost function)（待深入探究）

神经网络编程基础

2.1 二分类(Binary Classification)

假设有一张图片作为输入，1(cat) vs 0(not cat)

在计算机中保存一张图片需要RBG三种颜色的矩阵通道，如果图片像素为64∗6464*6464∗64，那么总的向量xxx的维度就是nx=64∗64∗3=12288n_x=64*64*3=12288nx=64∗64∗3=12288，这就是一张图片的输入inputinputinput，最后再预测是0or10 or 10or1。
一些符号定义：

x=(x1,...,xnx)Tx = (x_1,...,x_{n_x})^Tx=(x1,...,xnx)T：表示一个nxn_xnx维数据，作为输入,即nxn_xnx维的一个列向量，
yyy：表示输出，取值是(0,1)(0,1)(0,1)，
(x(i),y(i))(x^{(i)},y^{(i)})(x(i),y(i))：表示第iii个input，
X=[x(1),...,x(n)](nx,m)X = [x^{(1)},... , x^{(n)}]_{(n_x,m)}X=[x(1),...,x(n)](nx,m)：表示总的input数据，维度为nx∗mn_x*mnx∗m，
Y=[y(1),...,y(n)](1,m)Y = [y^{(1)},...,y^{(n)}]_{(1,m)}Y=[y(1),...,y(n)](1,m)：表示所有数据的LabelLabelLabel，是一个mmm维的行向量。

在python中可以用.shape()来查看某个矩阵的形状

x = [[1,4,6],[6,2,6],[5,5,4]]
x.shape()

2.2逻辑回归(Logistic Regression)

GivenX,y^=P(y=1∣x),0≤y^≤1Given X, \hat{y}= P (y=1|x),{0}\le{\hat{y}}\le{1}GivenX,y^=P(y=1∣x),0≤y^≤1
x∈Rnxx \in \mathbb{R}^{n_x}x∈Rnx
ω∈Rnx,b∈R.\omega \in \mathbb{R}^{n_x} ,b \in \mathbb{R}.ω∈Rnx,b∈R.
Output:y^=σ(ωTx+b)Output : \hat{y} = \sigma(\omega^{T}x + b)Output:y^=σ(ωTx+b)

对于σ(z)=11+e−z\sigma(z)=\frac{1}{1+e^{-z}}σ(z)=1+e−z1函数如果Z{Z}Z越小，σ(z)\sigma(z)σ(z)就越接近0， Z{Z}Z越大，σ(z)\sigma(z)σ(z)就越接近1.
其中，z定义为：z(i)=ωTx(i)+bz^{(i)}=\omega^{T}x^{(i)}+bz(i)=ωTx(i)+b，上标(i)(i)(i)表示input训练列向量的第iii个

2.3逻辑回归的代价函数(Cost Function of Logistic Regression)

y^(i)=σ(ωTx(i)+b),σ(z)=11+e−z\hat{y}^{(i)}=\sigma(\omega^{T}x^{(i)}+b), {\sigma}(z)=\frac{1}{1+e{-z}}y^(i)=σ(ωTx(i)+b),σ(z)=1+e−z1
我们希望模型的预测值接近目标实际值：y^(i)≈y(i)\hat{y}^{(i)} \approx{y^{(i)}}y^(i)≈y(i)，由此引出损失函数
损失函数（误差函数）：
可以用y^(i)\hat{y}^{(i)}y^(i)与y(i)y^{(i)}y(i)之间的平方差或者绝对值，但是在逻辑回归中通常不用它们，因为在学习逻辑回归参数的时候，很多情况下优化目标不是凸优化的，可能有很多个局部的极值点，梯度下降算法很可能找不到全局最优解。
在逻辑回归中用到的损失函数为：
L(y^,y)=−yln(y^)−(1−y)ln(1−y^)L(\hat{y},y)=-yln(\hat{y})-(1-y)ln(1-\hat{y})L(y^,y)=−yln(y^)−(1−y)ln(1−y^)

当y=1y=1y=1时，损失函数L=−ln(y^)L=-ln(\hat{y})L=−ln(y^).
如果希望LLL尽可能小，那么y^\hat{y}y^就要尽可能大，又y^\hat yy^的取值为[0,1][0,1][0,1]，那么y^\hat yy^就需要尽可能接近111.
当y=0y=0y=0时，损失函数L=−ln(1−y^)L =-ln(1-\hat y)L=−ln(1−y^)
如果希望LLL尽可能小，那么y^\hat{y}y^就要尽可能小，又y^\hat yy^的取值为[0,1][0,1][0,1]，那么y^\hat yy^就需要尽可能接近000.

那么当我们有mmm个个体的数据，就需要对mmm个损失函数求和然后除以mmm：
J(ω,b)=1m∑i=1mL(y^(i),y(i))=1m∑i=1m(−y(i)ln(y^(i))−(1−y(i))ln(1−y^(i)))J(\omega,b)=\frac{1}{m}\sum^{m}_{i=1}L(\hat{y}^{(i)},y^{(i)})=\frac{1}{m} \sum^{m}_{i=1}(-y^{(i)}ln(\hat{y}^{(i)})-(1-y^{(i)})ln(1-\hat{y}^{(i)}))J(ω,b)=m1i=1∑mL(y^(i),y(i))=m1i=1∑m(−y(i)ln(y^(i))−(1−y(i))ln(1−y^(i)))

2.4 梯度下降(Gradient Descent)

GradientDesent:GradientDesent:GradientDesent:
Recap:y^=σ(ωTx+b),σ(z)=11+e−zRecap:\hat{y}=\sigma(\omega^{T}x+b), {\sigma}(z)=\frac{1}{1+e{-z}}Recap:y^=σ(ωTx+b),σ(z)=1+e−z1
J(ω,b)=1m∑i=1mL(y^(i),y(i))=1m∑i=1m(−y(i)ln(y^(i))−(1−y(i))ln(1−y^(i)))J(\omega,b)=\frac{1}{m}\sum^{m}_{i=1}L(\hat{y}^{(i)},y^{(i)})=\frac{1}{m} \sum^{m}_{i=1}\left( -y^{(i)}ln(\hat{y}^{(i)})-(1-y^{(i)})ln(1-\hat{y}^{(i)})\right)J(ω,b)=m1∑i=1mL(y^(i),y(i))=m1∑i=1m(−y(i)ln(y^(i))−(1−y(i))ln(1−y^(i)))

1.如下图所示，随机初识化www
2.沿着梯度下降最快的地方一直走可以达到全局最低点

www的更新权值公式：
ω:=ω−αdJ(ω)dω\omega:=\omega-\alpha \frac{d J(\omega)}{d \omega}ω:=ω−αdωdJ(ω)
α\alphaα：表示学习率，
dJ(ω)dω\frac{d J(\omega)}{d\omega}dωdJ(ω)：表示J(w,b)J(w,b)J(w,b)对www的导数

在二维平面的情况下：

该公式的更新会使J(w)逐渐向最低点逼近。
同理，bbb的权值更新公式：
b:=b−α∂J(w,b)∂bb:=b-\alpha \frac{\partial J(w,b)}{\partial b}b:=b−α∂b∂J(w,b)

2.5 计算图(Computation Graph)

设有J(a,b,c)=3(a+bc)J(a,b,c)=3(a+bc)J(a,b,c)=3(a+bc),其中a=5,b=3,c=2a=5,b=3,c=2a=5,b=3,c=2
令:
u=bcu=bcu=bc
v=a+uv=a+uv=a+u
则J=3vJ=3vJ=3v

计算J的导数

dJdv=3\frac{dJ}{dv}=3dvdJ=3
dJdu=dJdvdvdu=3∗1\frac{dJ}{du}=\frac{dJ}{dv}\frac{dv}{du}=3*1dudJ=dvdJdudv=3∗1,
dJda=dJdvdvda=3∗1\frac{dJ}{da}=\frac{dJ}{dv}\frac{dv}{da}=3*1dadJ=dvdJdadv=3∗1,
dJdb=dJdududb=3∗2=6\frac{dJ}{db}=\frac{dJ}{du}\frac{du}{db}=3*2=6dbdJ=dudJdbdu=3∗2=6
dJdc=dJdududc=3∗3=9\frac{dJ}{dc}=\frac{dJ}{du}\frac{du}{dc}=3*3=9dcdJ=dudJdcdu=3∗3=9

反向传播

结合2.9中可以有形象理解

2.9 逻辑回归中的梯度下降(Logistic Regression Gradient Descent)

如图：在这个公式的外侧画上长方形。然后计算： y^=a=σ(z)\hat{y}=a=\sigma(z)y^=a=σ(z)也就是计算图的下一步。最后计算损失函数L(a,y)L(a,y)L(a,y)。有了计算图，我就不需要再写出公式了。因此，为了使得逻辑回归中最小化代价函数L(a,y)L(a,y)L(a,y)，我们需要做的仅仅是修改参数www和bbb的值。

现在让我们来讨论通过反向计算出导数。因为我们想要计算出的代价函数L(a,y)L(a,y)L(a,y)的导数，首先我们需要反向计算出代价函数L(a,y)L(a,y)L(a,y)关于aaa的导数，在编写代码时，你只需要用dadada来表示dL(a,y)da\frac{dL(a,y)}{da}dadL(a,y)。通过微积分得到：
(1)dL(a,y)da=−ya+1−y1−a=a−y=^da\frac{dL(a,y)}{da}=-\frac{y}{a}+\frac{1-y}{1-a}=a-y \ \hat{=} \ da \tag{1} dadL(a,y)=−ay+1−a1−y=a−y =^ da(1)
(2)dz=^dLdz=dLda⋅dadzdz\ \hat=\ \frac{\text dL}{\text dz}= \frac{\text dL}{\text da}\cdot \frac{\text da}{\text dz} \tag{2}dz =^ dzdL=dadL⋅dzda(2)
(3)dadz=a⋅(1−a)\frac{\text da}{\text dz}=a\cdot(1-a)\tag{3}dzda=a⋅(1−a)(3)
将(3)(3)(3)式代入(2)(2)(2)式,有：
(4)dLdz=a−y\frac{\text dL}{\text dz}=a-y\tag{4}dzdL=a−y(4)
最后计算www和bbb对代价函数JJJ的影响：
(5)dω1=^dLdω1=1m∑imx1(i)(a(i)−y(i))d\omega_1\ \hat=\ \frac{dL}{d\omega_1}= \frac{1}{m}\sum_{i}^{m} {x_{1}^{(i)} (a^{(i)} -y^{(i)}) }\tag{5}dω1 =^ dω1dL=m1i∑mx1(i)(a(i)−y(i))(5)
(6)dω2=^dLdω2=1m∑imx2(i)(a(i)−y(i))d\omega_2 \ \hat=\ \frac{dL}{d\omega_2}= \frac{1}{m}\sum_{i}^{m} {x_{2}^{(i)} (a^{(i)} -y^{(i)}) }\tag{6}dω2 =^ dω2dL=m1i∑mx2(i)(a(i)−y(i))(6)
(7)db=^dLdb=1m∑im(a(i)−y(i))db\ \hat=\ \frac{dL}{db}=\frac{1}{m}\sum_{i}^{m} { (a^{(i)} -y^{(i)}) }\tag{7}db =^ dbdL=m1i∑m(a(i)−y(i))(7)

最后更新权值：
(8)w1=w1−αdLdw1=w1−α⋅dw1w_1 = w_1 - \alpha\frac{dL}{dw_1}=w_1-\alpha\cdot dw_1\tag{8} w1=w1−αdw1dL=w1−α⋅dw1(8)
(9)w2=w2−αdLdw2=w2−α⋅dw2w_2 = w_2 - \alpha\frac{dL}{dw_2}=w_2-\alpha\cdot dw_2\tag{9}w2=w2−αdw2dL=w2−α⋅dw2(9)
(10)b=b−αdLdb=b−α⋅dbb = b - \alpha\frac{dL}{db}=b-\alpha\cdot db\tag{10} b=b−αdbdL=b−α⋅db(10)

2.10 Logistic Regression on m examples代码流程

首先初始化J=0,dw1=0,dw2=0,db=0J=0,\ dw_1=0,\ dw_2 =0,\ db=0J=0, dw1=0, dw2=0, db=0
代码流（非正式代码）：

for i in range(m):z(i) = wx(i) + b a(i) = sigmoid(z(i))J += - (  y(i) * log(a(i)) +( 1-y(i) ) *log(1 - a(i) ) )dz(i) = a(i) - y(i)  #计算dL/dzdw1 += x1(i) * dz(i) #计算dL/dw1dw2 += x2(i) * dz(i) #计算dL/dw2db += dz(i)          #计算dL/db
J /= m
dw1 /= m
dw2 /= m
db /= m
w = w - alpha*dw
b = b - alpha*db

以上只应用了一步梯度下降，因此需要重复上面很多次。
但这种计算中有两个缺点，也就是说应用此方法在逻辑回归上你需要编写两个for循环。第一个 for 循环是一个小循环遍历m个训练样本，第二个 for 循环是一个遍历所有特征的 for 循环。这个例子中我们只有 2 个特征，所以nnn等于 2 并且nxn_xnx 等于 2。但如果你有更多特征，你开始编写你的因此dw1dw_1dw1，dw2dw_2dw2，相似的计算一直下去到dwnxdw_{n_x}dwnx。所以看来你需要一个 for 循环遍历所有n个特征。

2.11向量化表达(Vectorization)

假设有这么一个python的forforfor循环

z=0
for i in range(n_x):z+=w[i]*x[i] z+=b

这样计算会很慢,但是用向量化表达则计算会很快

import numpy as np
import time
n = 1000000
w = np.random.rand(n).reshape(n,1)
x = np.random.rand(n).reshape(n,1)#通过 round 随机得到两个一百万维度的数组

z=0
t1 = time.time()
for i in range(n_x):z+=w[i]*x[i]t2 = time.time()
print(z,'using time "%s"ms.'%((t2-t1)*1000))

[ 249835.28710158] using time "4013.7579441070557"ms.

t3 = time.time()
zz = np.dot(w.T,x) #使用向量化表达之后
t4 = time.time()
print(zz,'using time "%s"ms.'%((t4-t3)*1000))

[[ 249835.28710159]] using time "0.8718967437744141"ms.

2.13向量化逻辑回归(Vectorizing Logistic Regression)

首先我们回顾一下逻辑回归的前向传播步骤:
如果你有 mmm 个训
练样本，然后对第一个样本进行预测,计算 zzz，公式z(1)=wTx1+bz^{(1)}=w^{T}x^{1}+bz(1)=wTx1+b。然后计算激活函数 a(1)=σ(z(1))a^{(1)}=\sigma(z^{(1)})a(1)=σ(z(1))，计算第一个样本的预测值 y^(1)\hat y^{(1)}y^(1)。然后对第二个样本进行预测，需要计算z(2)=wTx2+bz^{(2)}=w^{T}x^{2}+bz(2)=wTx2+b ，a(2)=σ(z(2))a^{(2)}=\sigma(z^{(2)})a(2)=σ(z(2)) 。然后对第三个样本进行预测，需要计算 z(3)=wTx3+bz^{(3)}=w^{T}x^{3}+bz(3)=wTx3+b ， a(3)=σ(z(3))a^{(3)}=\sigma(z^{(3)})a(3)=σ(z(3)) ，依次类推。如果你有 m 个训练样本，则需要这样做 m 次，这样太耗时。
下面介绍向量化的编程方法：

核心思想是：向量化赋值，向量化运算
第iii个个体的属性值构成的列向量：
(2.13.1)x(i)=(x(1)(i)x(2)(i)⋮x(nx)(i))\tag{2.13.1} x^{(i)}=\begin{pmatrix} x^{(i)}_{(1)} \\ x^{(i)}_{(2)}\\ \vdots\\ x^{(i)}_{(n_x)} \end{pmatrix}x(i)=⎝⎜⎜⎜⎜⎜⎛x(1)(i)x(2)(i)⋮x(nx)(i)⎠⎟⎟⎟⎟⎟⎞(2.13.1)
m个x(i)x^{(i)}x(i)构成X矩阵：
(2.13.2)X=(x(1),x(2),…,x(m))(nx,m)\text X=\begin{pmatrix} x^{(1)} ,x^{(2)} ,\dots,x^{(m)} \end{pmatrix}_{(n_{x},m)} \tag{2.13.2}X=(x(1),x(2),…,x(m))(nx,m)(2.13.2)
参数向量www是一列nxn_xnx维的列向量：
(2.13.3)w=(w1w2⋮wm)(nx,1)w=\begin{pmatrix} w_1\\ w_2\\ \vdots\\w_m \end{pmatrix}_{(n_x,1)} \tag{2.13.3}w=⎝⎜⎜⎜⎛w1w2⋮wm⎠⎟⎟⎟⎞(nx,1)(2.13.3)
(2.13.4)z(i)=wTx(i)+bz^{(i)}=w^{T} x^{(i)} + b\tag{2.13.4}z(i)=wTx(i)+b(2.13.4)
m个z(i)z^{(i)}z(i)构成的行向量：
(2.13.5)Z=(z(1),z(2),⋯ ,z(m))Z=\begin{pmatrix} z^{(1)},z^{(2)},\cdots,z^{(m)} \end{pmatrix} \tag{2.13.5}Z=(z(1),z(2),⋯,z(m))(2.13.5)
求ZZZ只需要一行代码：Z = np.dot(w.T,b)
A为σ(Z)\sigma(Z)σ(Z)是一个m维的行向量：
(2.13.5)A=σ(Z)=(a(1),a(2),⋯ ,a(m))A =\sigma(Z)= \begin{pmatrix} a^{(1)},a^{(2)},\cdots,a^{(m)} \end{pmatrix} \tag{2.13.5}A=σ(Z)=(a(1),a(2),⋯,a(m))(2.13.5)

2.14 向量化Logistic回归的梯度(Vectorizing Logistic Regression’s Gradient)

第一个个体的损失函数L(1)L^{(1)}L(1)对z(1)z^{(1)}z(1)的偏导数： dL(1)dz(1)=a(1)−y(1)=^dz(1)\frac{dL^{(1)}}{dz^{(1)}}= a^{(1)}-y^{(1)}\ \hat= \ dz^{(1)}dz(1)dL(1)=a(1)−y(1) =^ dz(1)
第二个个体的损失函数L(2)L^{(2)}L(2)对z(2)z^{(2)}z(2)的偏导数： dL(2)dz(2)=a(2)−y(2)=^dz(2)\frac{dL^{(2)}}{dz^{(2)}}= a^{(2)}-y^{(2)}\ \hat= \ dz^{(2)}dz(2)dL(2)=a(2)−y(2) =^ dz(2)
…\dots…
第m个个体的损失函数L(m)L^{(m)}L(m)对z(m)z^{(m)}z(m)的偏导数： dL(m)dz(m)=a(m)−y(m)=^dz(m)\frac{dL^{(m)}}{dz^{(m)}}= a^{(m)}-y^{(m)}\ \hat= \ dz^{(m)}dz(m)dL(m)=a(m)−y(m) =^ dz(m)
Y=(y(1),y(2),⋯ ,y(m))Y= (y^{(1)},y^{(2)},\cdots,y^{(m)})Y=(y(1),y(2),⋯,y(m))
dZdZdZ是一个m维的行向量，
dZ=A−Y=(dz(1),dz(2),⋯ ,dz(m))dZ = A-Y = (dz^{(1)},dz^{(2)},\cdots,dz^{(m)})dZ=A−Y=(dz(1),dz(2),⋯,dz(m))

dw=1m⋅X⋅(dZ)Tdw = \frac{1}{m}\cdot X \cdot ({dZ})^{T}dw=m1⋅X⋅(dZ)T

db=1m∑(dZ)db=\frac{1}{m}\sum(dZ)db=m1∑(dZ)

dZ,dw,dbdZ,dw,dbdZ,dw,db的定义沿用2.9节中所述。
则向量化的一次梯度更新的python代码流程为：

Z = np.dot(w.T, X) + b
A = sigma(Z)
dZ = A - Y
dw = (1/m)*X*(dZ).T
db = (1/m)*np.sum(dZ)
w = w - a * dw
b = b - a * db

最后在此基础上来个for循环m次，作m次梯度更新。

2.18 Logistic损失函数的来由(Explanation of Logistic Regression cost function)（待深入探究）

在逻辑回归中，需要预测的结果y^\hat{y}y^可以表示为y^=σ(wTx+b)\hat{y}=\sigma(w^{T}x+b)y^=σ(wTx+b),σ\sigmaσ是我们熟悉的S型曲线σ(z)=σ(wTx+b)=11+e−z\sigma(z)=\sigma(w^{T}x+b)=\frac{1}{1+e^{-z}}σ(z)=σ(wTx+b)=1+e−z1。约定y^=p(y=1∣x)\hat{y}=p(y=1|x)y^=p(y=1∣x)，即算法的输出y^\hat yy^是给定训练样本个体xxx条件下y=1y=1y=1的概率。即：
如果y=1y=1y=1，在给定训练个体xxx条件下算出的概率为y^\hat yy^:

(2.18.1)Ify=1:p(y∣x)=y^If \ \ y=1: \ \ p(y|x)=\hat{y}\tag{2.18.1}If y=1: p(y∣x)=y^(2.18.1)
如果y=0y=0y=0，在给定训练个体xxx的条件下算出的概率为1−y^1-\hat y1−y^:
(2.18.2)Ify=0:p(y∣x)=1−y^If \ \ y=0: \ \ p(y|x)=1-\hat{y}\tag{2.18.2}If y=0: p(y∣x)=1−y^(2.18.2)
整合(2.18.1)(2.18.1)(2.18.1)和(2.18.2)(2.18.2)(2.18.2)两个式子得：
(2.18.3)P(y∣x)=y^y⋅(1−y^)1−yP(y|x)=\hat{y}^{y} \cdot (1-\hat{y})^{1-y}\tag{2.18.3}P(y∣x)=y^y⋅(1−y^)1−y(2.18.3)

两边同时取对数：
(2.18.4)LnP(y∣x)=ylny^+(1−y)ln(1−y^)LnP(y|x) =yln\hat{y} +(1-y)ln(1-\hat{y})\tag{2.18.4}LnP(y∣x)=ylny^+(1−y)ln(1−y^)(2.18.4)
由于log函数是严格单调递增的，最大化lnP(y∣x)lnP(y|x)lnP(y∣x)等价于最大化P(y∣x)P(y|x)P(y∣x)并且计算P(y∣x)P(y|x)P(y∣x)的对数，就是计算lnP(y∣x)lnP(y|x)lnP(y∣x)，即(2.18.4)(2.18.4)(2.18.4)式。
(2.18.4)(2.18.4)(2.18.4)就是前文提到的损失函数的负数，即−L(y^,y)-L(\hat{y},y)−L(y^,y)。有个负号的原因是，当我们训练学习算法时要以最大的概率预测这个值，然而在逻辑回归中我们需要最小化损失函数。

DeepLearning.AI笔记：二、神经网络编程基础相关推荐

C 语言学习笔记(二)：编程基础
目录一.冯诺依曼模型二.程序语言发展历史三.进制 3.1 二进制 3.2 八进制 3.3 十六进制 3.4 进制转换:二进制.八进制.十六进制.十进制之间的转换 3.4.1 将二进制.八进制.十 ...
操作系统内核Hack：(二)底层编程基础
操作系统内核Hack:(二)底层编程基础在<操作系统内核Hack:(一)实验环境搭建>中,我们看到了一个迷你操作系统引导程序.尽管只有不到二十行,然而要完全看懂还是需要不少底层软硬件知识 ...
（2）神经网络编程基础
文章目录神经网络编程基础 2.1 二分分类 2.2 logistic 回归(logistic Regression) 2.3 logistic 回归损失函数损失函数 (Loss (Error)Fu ...
java学习笔记15--多线程编程基础2
本文地址:http://www.cnblogs.com/archimedes/p/java-study-note15.html,转载请注明源地址. 线程的生命周期 1.线程的生命周期线程从产生到消亡 ...
【Visual C++】游戏开发笔记二十三游戏基础物理建模五粒子系统模拟二
分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow 也欢迎大家转载本篇文章.分享知识,造福人民,实现我们中华民族伟大复兴! 本系列文 ...
【Visual C++】游戏开发笔记二十游戏基础物理建模(二) 重力系统的模拟
本系列文章由zhmxy555(毛星云)编写,转载请注明出处. http://blog.csdn.net/zhmxy555/article/details/7496200 作者:毛星云邮箱: h ...
【Visual C++】游戏开发笔记二十三游戏基础物理建模(五) 粒子系统模拟(二)
本系列文章由zhmxy555(毛星云)编写,转载请注明出处. http://blog.csdn.net/zhmxy555/article/details/7607916 作者:毛星云邮箱: h ...
【Visual C++】游戏开发笔记二十一游戏基础物理建模三摩擦力系统模拟
分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow 也欢迎大家转载本篇文章.分享知识,造福人民,实现我们中华民族伟大复兴! 本系列文 ...
java学习笔记14--多线程编程基础1
本文地址:http://www.cnblogs.com/archimedes/p/java-study-note14.html,转载请注明源地址. 多线程编程基础多进程一个独立程序的每一次运行称为 ...

DeepLearning.AI笔记：二、神经网络编程基础