本文为课程对应的学习笔记

地址http://www.auto-mooc.com/mooc/detail?mooc_id=F51511B0209FB73D81EAC260B63B2A21
课件资料存放地址：待更新

修订：补充“前馈神经网络”-2月14
补充BP的缺点-2月17

7.0感知器

重点理解：

1. 感知器
2. 浅层神经网络
3. BP反向传播

SVM与逻辑回归，适当应用可以解决很多非线性问题。

2010年Google科学家李飞飞举行图像分类比赛，2012多伦多大学教授Geoffry Hinton和他的团队带着 AlexNet，深度卷积神经网络参加了那一年的 ImageNet ILSVRC 挑战赛，以惊人的优势获胜（错误率比第二名低了足足 10%）。这篇被 NIPS 2012 收录的论文被认为是深度学习热的开启。神经网络的春天。

2017年10月26日，Hinton发表了一篇在AI圈掀起轩然大波的论文——Capsule Networks（胶囊网络）。Hinton高喊，“卷积神经网络（CNN）的时代已经过去了！”，将他过去几十年的研究翻了过去。

7.1 感知器

感知器 和 逻辑回归很相似，（逻辑回归更像是感知器的改进）。上个世纪50年度就有的概念，60年代就有的应用。

1943年就有人根据人脑神经的工作方式提出感知器。但是其问题是：工作模式是固定的，（细胞体处理问题是固定的）。

引入权重的概念，1956年：

7.2 偏差(Bias)和方差(Variance)（新增）

参考：https://zhuanlan.zhihu.com/p/38471518

偏差表示模型的期望输出与真实值的差异。

方差表示模型对于给定观测点进行预测时的可变性或者说稳定性。

下面是枪手打靶的例子。偏差反映了枪手瞄准点与靶心之间的偏差，而方差则是枪手的稳定性。实际射击过程中还有不可控因素，例如风的影响等，我们称之为噪音(noise)。

低偏差 Bias 与低方差 Variance 才会得到理想的结果，但低Bias 与低Variance 往往是不能兼得的。**如果要降低模型的 Bias，就一定程度上会提高模型的Variance，反之亦然。**这里以 K-NN 为例，看一些 K-NN 中 Bias 与Variance 与其参数 K 的关系，在 K-NN 中，误差形式如下，这里 x1,x2,…xk 是x 在训练数据集中最近的 k 个邻居，当K 取值很小时Bias 很低，但Variance很大。随着K 的增大，Bias明显会增大，但Variance 会减小，这便是 Bias 与Variance 之间的一个关系。

因为预测模型试图用有限的训练数据集去得到一个用来预测全数据集的模型，为了降低模型的误差率，就要尽量使模型在训练数据集上更加“准确”，这样做往往会增加模型复杂度，但却降低了模型在全数据集的泛化能力，对于新数据，模型对就会很不稳定，这样就会造成高Variance，也就是过拟合。为了避免过拟合，就不能完全依赖于有限的训练数据，需要会增加一些限制（例如泛化）来提高模型的稳定程度降低Variance。但是这样做的后果是，模型的Bias 增大，拟合能力不够造成欠拟合，所以需要要Bias 与Variance 之间寻找一个tradeoff。

7.3感知器流程与适用范围

感知器实验： Calculate weights
#dataset = [[0,0,0],[0,1,0],[1,0,0],[1,1,1]]
dataset = [[0,0,0],[0,1,1],[1,0,1],[1,1,1]] #数据集的前两个参数是输入，第三个是输出
#dataset = [[0,0,0],[0,1,1],[1,0,1],[1,1,0]]

一眼可以看出：这是逻辑与、逻辑或、逻辑异或三种关系的数据集

import  matplotlib.pyplot as plt
import numpy as npdef predict(row, weights):activation = weights[0]  #weights[0]是bias，偏差for i in range(len(row) - 1):  #循环相加activation += weights[i + 1] * row[i]#return 1.0 if activation >= 0.0 else 0.0return 1.0 if activation >0 else 0.0#使用随机梯度下降进行感知器参数的估计
def train_weights(train, l_rate, n_epoch):weights = [0.0 for i in range(len(train[0]))] #初始值为0for epoch in range(n_epoch): #每一轮，使用所有的训练值更新参数sum_error = 0.0print("当前参数值：")print(weights)for row in train:print("训练值： ")print(row)prediction = predict(row, weights) #对每一个训练值使用当前的权重进行预测print("Expected=%d, Predicted=%d" % (row[-1], prediction))error = row[-1] - prediction  #使用训练值减去预测值sum_error += error ** 2   #错误的个数需要对错误值进行平方；防止正负抵消weights[0] = weights[0] + l_rate * error   #更新参数，直接使用错误值； biasfor i in range(len(row) - 1):  #对每一个错误，更新所有的参数weights[i + 1] = weights[i + 1] + l_rate * error * row[i]  #梯度下降print("训练后参数：")print(weights)print('>epoch=%d, lrate=%.3f, error=%.3f' % (epoch, l_rate, sum_error))print(weights)return weights# Calculate weights
#dataset = [[0,0,0],[0,1,0],[1,0,0],[1,1,1]]
dataset = [[0,0,0],[0,1,1],[1,0,1],[1,1,1]]
#dataset = [[0,0,0],[0,1,1],[1,0,1],[1,1,0]]
l_rate = 0.1
n_epoch = 5
#n_epoch = 5
weights = train_weights(dataset, l_rate, n_epoch)
print(weights)for row in dataset:prediction = predict(row, weights)print("Expected=%d, Predicted=%d" % (row[-1], prediction))for data in dataset:print(data)if data[-1] == 1:plt.scatter(data[0],data[1],25,'r')else:plt.scatter(data[0], data[1], 25,'g')X = np.arange(-2, 2, 0.1)
Y = [-(weights[0]+weights[1]*x)/weights[2] for x in X]plt.plot(X, Y, 'y*')plt.show()

简单的感知器不能解决非线性可分的问题，例如“异或问题”，就无能为力。对于逻辑AND和逻辑OR线性可分类问题较好的效果。所以，前几
十年，这也是感知器被打入冷宫的原因。

8.1 浅层神经网络

浅层神经网络包括：

1. 隐藏层
2. 激活函数
3. 前馈神经网络

单个感知器无法解决“异或XOR”问题。于是，扩展单层感知器！！！

多层神经网络中，我们就不称运算个体是感知器，称为“神经元”

权重的维度：

input与hidden	hidden与output
例题中是2*3;通用公式是：hidden维度Xinput维度	例题中是1*3;通用公式是：input维度Xhidden维度

前馈神经网络：输出不影响输入。

多层神经网络可以解决非线性问题了。

补充“前馈神经网络”-2月14

其他的神经网络结构：ART，SOM

8.2 BP反向传播：更新权值

XOR问题利用两层神经网络解决：

# -*- coding: utf-8 -*-import numpy as np
import matplotlib.pyplot as pltdef sigmoid(x):  #转换函数；在隐藏层和输出层使用return 1/(1+np.exp(-x))def s_prime(z):return np.multiply(z, 1.0-z)  #sigmoid函数的导数形式#return np.multiply(sigmoid(z) , (1 - sigmoid(z)))def init_weights(layers, epsilon):weights = []for i in range(len(layers)-1):  #对每一层生成参数；每一个输入值与下一层的所有节点连接w = np.random.rand(layers[i+1], layers[i]+1)  #layers[i+1] 下一层节点的个数；layers[i]+1 有biasw = w * 2*epsilon - epsilon  #rand生成的值在0~1之间，epsilon=1，（2*w-1）可以将w的值范围变为-1~1weights.append(np.mat(w))print(weights)return weights#a_s 保存输入值、每一层经计算sigmoid的值；def back(X, Y, w):# now each para has a grad equals to 0w_grad = ([np.mat(np.zeros(np.shape(w[i])))for i in range(len(w))])  # len(w) equals the layer numberm, n = X.shape  #训练集的大小 4*2output = np.zeros((m, 1))  # 所有样本的预测值, 4个for i in range(m):  #对每个训练样本；X，Y都为矩阵x = X[i]y = Y[0,i]# forward propagatea = x  #每个训练样本a_s = []for j in range(len(w)):  #总共有3-1层；w的长度是神经网络的层数a = np.mat(np.append(1, a)).T  #1用于与bias相乘，weights向量的第一项是bias的值a_s.append(a)  # 这里保存了前L-1层的a值: 输入层；隐藏层net = w[j] * aa = sigmoid(net) #上一层的输出是下一层的输入#print('a_s',a_s,)output[i, 0] = a# back propagatedelta = a - y.T #计算预测值和真实值之间的差；也是交叉熵和sigmoid求导之后的乘积w_grad[-1] += delta * a_s[-1].T  # L-1层的梯度#print("delta:")#print(delta)# 倒过来，从倒数第二层开始for j in reversed(range(1, len(w))):  #len(2)= 2; 所以j仅取1delta = np.multiply(w[j].T*delta, s_prime(a_s[j]))  # #中间的每一层都使用了sigmoid函数；s_prime是sigmoid的导数形式；#print(s_prime(a_s[j]))#print('delta new:')#print(delta)#print(a_s[j-1])w_grad[j-1] += (delta[1:] * a_s[j-1].T)  #delta[0] = 0; 因为 s_prime(a_s[j][0]=1)；常数项不会对权重产生影响#print("weight")#print(delta[1:] * a_s[j-1].T)w_grad = [w_grad[i]/m for i in range(len(w))]#print(w_grad)cost = (1.0 / m) * np.sum(-Y * np.log(output) - (np.array([[1]]) - Y) * np.log(1 - output))  #交叉熵代价函数return {'w_grad': w_grad, 'cost': cost, 'output': output}X = np.mat([[0,0],[0,1],[1,0],[1,1]])print(X)Y = np.mat([0,1,1,0])print(Y)layers = [2,2,1]  #神经网络结构
epochs = 2000  #迭代次数
alpha = 0.5    #参数更新步长
w = init_weights(layers, 1)
result = {'cost': [], 'output': []}
w_s = {}
for i in range(epochs):back_result = back(X, Y, w)w_grad = back_result.get('w_grad')cost = back_result.get('cost')output_current = back_result.get('output')result['cost'].append(cost)result['output'].append(output_current)for j in range(len(w)):w[j] -= alpha * w_grad[j]if i == 0 or i == (epochs - 1):# print('w_grad', w_grad)w_s['w_' + str(i)] = w_grad[:]plt.plot(result.get('cost'))
plt.show()
print(w_s)
print('output:')
print(result.get('output')[0], '\n',result.get('output')[-1])#绘制出异或的点
plt.figure()
X = np.asarray(X)
Y = np.asarray(Y)
for i in range(len(Y[0])):#print(X[i])#print(Y[0])if Y[0][i] == 1:plt.scatter(X[i][0],X[i][1],25,'r')else:plt.scatter(X[i][0],X[i][1], 25,'g')#绘制出根据反向传播计算得出的参数plt.show()

8.3 超参数

参考：https://zhuanlan.zhihu.com/p/41785031

layers = [2,2,1]  #神经网络结构
epochs = 2000  #迭代次数
alpha = 0.5    #参数更新步长

超参数，也成为框架参数，是我们控制模型结构、功能、效率等的 调节旋钮。【超参数】是影响所求【参数】最终取值的参数，是学习模型的框架参数。【超参数】是手工指定并不断调整的。网络的效果，取决于超参数的取值。

learning rate
epochs(迭代次数，也可称为 num of iterations)
num of hidden layers(隐层数目)
num of hidden layer units(隐层的单元数/神经元数)
activation function(激活函数)
batch-size(用mini-batch SGD的时候每个批量的大小)
optimizer(选择什么优化器，如SGD、RMSProp、Adam)
用诸如RMSProp、Adam优化器的时候涉及到的β1，β2等等
......

太多了，上面是一些最常见的超参数，一般的深度学习框架就是调节这些框架参数。
另外，层数越多，越准确，但训练时间也越大，但是计算量越大；全连接层应该少，计算量太大

参数的定义：

【参数】是我们训练神经网络 最终要学习的目标，最基本的就是神经网络的权重 W和bias（b），我们训练的目的，就是要找到一套好的模型参数，用于预测未知的结果。这些参数我们是不用调的，是模型来训练的过程中自动更新生成的。

8.4 两层神经网络解决手写数字识别

#生成神经网络对象，神经网络结构为三层，每层节点数依次为（784, 30, 10）
net = Network([784, 30, 10])
#用（mini-batch）梯度下降法训练神经网络（权重与偏移），并生成测试结果。
#训练轮数=30, 用于随机梯度下降法的最小样本数=10，学习率=3.0
net.back(training_data, 30, 10, 3.0, test_data=test_data)

784：因为输入的图像是28像素x28像素
10：因为输出是0~9，十个数字
30：节点数目是30个，来自于经验。可以是：输入层与输出层数目乘积，然后开根号，或者log等待，来源于经验。

2层的神经网络，一层30个节点，也能得到很好的效果。

代码：

# %load network.pyimport random
import numpy as npimport mnist_loaderclass Network(object):def __init__(self, sizes):"""size是神经网络的大小；（784, 30, 10）即表示输入层是784个节点；隐藏层是30个节点；输出是10个节点"""self.num_layers = len(sizes)self.sizes = sizes#为全连接网络生成随机初始的参数#bias是对除输入层之外的所有层次都要生成self.biases = [np.random.randn(y, 1) for y in sizes[1:]]#weights相邻两层之间，每一个输入都对下一层的节点有一个权重self.weights = [np.random.randn(y, x)for x, y in zip(sizes[:-1], sizes[1:])]"""主要用于测试集，查看效果"""def feedforward(self, a):"""权重和值相乘，加上偏移，然后使用sigmoid计算"""for b, w in zip(self.biases, self.weights):a = sigmoid(np.dot(w, a)+b)return adef back(self, training_data, epochs, mini_batch_size, eta,  #随机梯度下降test_data=None):"""使用Mini-batch的随机梯度方法来更新梯度"""training_data = list(training_data)n = len(training_data)if test_data:test_data = list(test_data)n_test = len(test_data)for j in range(epochs):random.shuffle(training_data)#挑选出一些输入点进行参数更新mini_batches = [training_data[k:k+mini_batch_size]for k in range(0, n, mini_batch_size)]for mini_batch in mini_batches:self.update_mini_batch(mini_batch, eta)#打印出正确分类的个数if test_data:print("Epoch {} : {} / {}".format(j,self.evaluate(test_data),n_test));else:print("Epoch {} complete".format(j))def update_mini_batch(self, mini_batch, eta):"""使用向后传播进行计算"""nabla_b = [np.zeros(b.shape) for b in self.biases]nabla_w = [np.zeros(w.shape) for w in self.weights]for x, y in mini_batch:delta_nabla_b, delta_nabla_w = self.backprop(x, y)nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]self.weights = [w-(eta/len(mini_batch))*nwfor w, nw in zip(self.weights, nabla_w)]self.biases = [b-(eta/len(mini_batch))*nbfor b, nb in zip(self.biases, nabla_b)]def backprop(self, x, y):#得出每一层的参数的大小nabla_b = [np.zeros(b.shape) for b in self.biases]nabla_w = [np.zeros(w.shape) for w in self.weights]# feedforwardactivation = xactivations = [x] # 所计算出的每一层（经过sigmoid计算）的值；在参数更新中会用到zs = [] # 经过线性计算的每层的值#对每一层进行前向计算for b, w in zip(self.biases, self.weights):z = np.dot(w, activation)+bzs.append(z)activation = sigmoid(z)activations.append(activation)# 向后计算，以下三行是更新最后一层的参数delta = self.cost_derivative(activations[-1], y) * sigmoid_prime(zs[-1])nabla_b[-1] = deltanabla_w[-1] = np.dot(delta, activations[-2].transpose())#从倒数第二层开始，计算方法相同，可以进行循环#bias和weights分开计算#weights的值依赖于上一层的输出for layer in range(2, self.num_layers):z = zs[-layer]sp = sigmoid_prime(z)delta = np.dot(self.weights[-layer+1].transpose(), delta) * spnabla_b[-layer] = deltanabla_w[-layer] = np.dot(delta, activations[-layer-1].transpose())return (nabla_b, nabla_w)def evaluate(self, test_data):"""统计出来正确分类的个数;argmax表示数组中最大的值的位置；因为最终output的结果是0,1向量，只有一个值为1，也就是判别的种类"""test_results = [(np.argmax(self.feedforward(x)), y)for (x, y) in test_data]print(test_results)return sum(int(x == y) for (x, y) in test_results)def cost_derivative(self, output_activations, y):  #使用的是均方误差；均方误差的微分形式"""计算输出与真实值的差."""return (output_activations-y)def sigmoid(z):"""The sigmoid function."""return 1.0/(1.0+np.exp(-z))def sigmoid_prime(z):"""sigmoid函数的微分."""return sigmoid(z)*(1-sigmoid(z))training_data, validation_data, test_data = mnist_loader.load_data_wrapper()
# 生成神经网络对象，神经网络结构为三层，每层节点数依次为（784, 30, 10）
net = Network([784, 30, 10])
# 用（mini-batch）梯度下降法训练神经网络（权重与偏移），并生成测试结果。
# 训练轮数=30, 用于随机梯度下降法的最小样本数=10，学习率=3.0
net.back(training_data, 30, 10, 3.0, test_data=test_data)

8.5 激活函数

对网络的性能有大影响

函数	有点	缺点
step	很好的模拟了神经元	1、不是连续可导，BP过程更新W是需要对激活函数求导；2、输入的扰动对输出的影响巨大
sigmoid	早期运用广泛	sigmoid函数值恒大于零，导致模型收敛速度变慢，对于更新状态可能导致锯齿状，更新效果不是很好；sigmoid计算量大；导致梯度消失！！！！！
tanh	改进sigmoid；范围是（-1，+1）；倒数（0，1）	计算量大，网络足够深，也会有梯度消失问题
ReLu	可以解决梯度消失问题	存在大梯度的样本，导致一些神经元处于“死”的状态

9.1 tensorflow（很像一种语法）

9.2 数据流

交互式环境下面：

定义数据：创建Tensor，添加Op

执行计算：

在会话session中执行图,session 会占用系统资源，使用完毕后需要释放资源

• sess= tf.InteractiveSession()

with tf.Session() as s:print(s.run(x))#print(z.eval())

代码示例：

import tensorflow as tfa = tf.constant(1)
b = tf.constant(2)
c = tf.constant(3)
x = tf.add(a,b)
y = tf.add(x,c)
z = tf.add(x,y)#print(y.graph)
#print(x.graph)with tf.Session() as s:print(s.run(x))#print(z.eval())writer = tf.summary.FileWriter('./graph/',tf.get_default_graph())
writer.add_graph(s.graph)writer.close()

变量

• 注意： 使用变量之前，需要初始化变量：w.initializer，然后sess.run(op)
  
  也可以采用：
  

变量的初始化非常重要，operation一定要在sessions中运算。

import tensorflow as tfw = tf.Variable([[1,2,4],[3,4,6]])
v = tf.Variable([[3,4],[1,2],[5,6]])
y = tf.Variable(5.0)op = w.assign(w * 2)
u = tf.matmul(w,v)t = tf.sigmoid(y)**x = tf.global_variables_initializer()**# 一次性全部初始化变量with tf.Session() as s:#s.run(w.initializer)#s.run(v.initializer)#s.run(y.initializer)s.run(x)s.run(op)print(w.value())print(w.eval())print(u.eval())print(s.run(t))

占位符

import tensorflow as tfx = tf.placeholder(tf.string)
u = tf.placeholder(tf.string)
y = tf.placeholder(tf.int32)
z = tf.placeholder(tf.float32)
t = tf.placeholder(tf.int32)w = tf.Variable(1)op = w.assign(y+t)with tf.Session() as sess:output = sess.run(x, feed_dict={x: 'Hello World'})output1, o2, o3 = sess.run([u, y, z], feed_dict={u: 'Test String', y: '123', z: 45})#o3 = sess.run(u, feed_dict={u: 'Test String', y: 123.45, z: 45})print(output1,o2,output,o3)#print(o2+o3)print(type(o3))print(tf.string_join([output,output]).eval())print(sess.run(op,{y:1,t:2}))#print(sess.run(op,{t:2}))#result = sess.run(op)print(x.eval()) #error

权值、偏置、导数等数据一般用变量表示，因为需要变动且要保留；但是训练数据用占位符，不用保存，只是一个传递作用

Graph

import tensorflow as tfc=tf.constant(value=1)
print(c.graph)
print(tf.get_default_graph())#生成新图
g1=tf.Graph()
print("g1:",g1)
with g1.as_default():d=tf.constant(value=2)print(d.graph)#生成新图
g2=tf.Graph()
print("g2:",g2)
g2.as_default()
e=tf.constant(value=15)
print(e.graph)with g1.as_default():c1 = tf.constant([1.0])
with tf.Graph().as_default() as g2:c2 = tf.constant([2.0])with tf.Session(graph=g1) as sess1:print(sess1.run(c1))print(sess1.run(c2))#print(sess1.run(c))
with tf.Session(graph=g2) as sess2:print(sess2.run(c2))writer = tf.summary.FileWriter('./graph/',tf.get_default_graph())
writer.add_graph(sess1.graph)writer.close()

TensorBoard

暂时结束！！明天继续

2月10日 感知器+浅层神经网络+反向传播+tensorflow相关推荐

1. 【历史上的今天】10 月 8 日：Netflix 创始人诞生；反向传播算法经典论文发表；Android 4.0 发布

   整理 | 王启隆 透过「历史上的今天」,从过去看未来,从现在亦可以改变未来. 今天是 2022 年 10 月 8 日,家喻户晓的三国时期杰出人物诸葛亮在今天逝世,他对丰功伟绩被许多文献记载,他对巴蜀的 ...

2. CS231n 两层神经网络反向传播实现

   今天写了cs231n 作业1的两层神经网络的部分,听视频和看讲义的时候觉得挺简单的没在意,后来真正写的时候发现了问题,而且也领悟到了新的东西,反向传播代码实现的奥妙之处. 同时也把之前的loss函数梯 ...

3. 10月10日~10月17 产品资讯

   2017年10月10日 星期二 [起点学院早报] 1. 京东官方宣布,已建成全球首个全流程无人仓并亮相上海.据悉,该无人仓实现了货物从入库.存储.包装.分拣的全流程.全系统的智能化和无人化.京东称,无 ...

4. 【历史上的今天】9 月 10 日：互联网上第一个搜索工具诞生；微软首席架构师出生；马云诞生

   整理 | 王启隆 透过「历史上的今天」,从过去看未来,从现在亦可以改变未来. 今天是 2021 年 9 月 10 日,教师节.中国的第一个教师节诞生于 1985 年的今天,旨在肯定教师为教育事业所做的 ...

5. 【不容错过】12月10日：纳米孔测序科研团队大会NCM 2020亚太区特别专场

   一年一度的纳米孔测序科研团体大会(NCM 2020)主会场已于美国东部时间12月初在线上成功召开,汇集了全球超过50位领先的纳米孔测序学者,分享他们的纳米孔测序最新研究成果. 2020年12月10日, ...

6. 从腾讯朋友圈揭秘内部AI部门竞争关系，谁能像微信当年一样熬出头？ By 微胖2017年11月10日 09:06 撰文 | 宇多田 在腾讯合作伙伴大会上，腾讯首席运营官任宇昕提出的「AI in All」

   从腾讯朋友圈揭秘内部AI部门竞争关系,谁能像微信当年一样熬出头? By 微胖2017年11月10日 09:06 撰文 | 宇多田 在腾讯合作伙伴大会上,腾讯首席运营官任宇昕提出的「AI in All」 ...

7. AI：2020年7月10日世界人工智能大会WAIC青少年人工智能创新发展论坛《人工智能从娃娃抓起》

   AI:2020年7月10日世界人工智能大会WAIC青少年人工智能创新发展论坛<人工智能从娃娃抓起> 导读:教育是生态系统,包括北大清华的本硕博正在逐设人工智能课程,五年以后,中国将会迈向人 ...

8. 正在更新office_Windows 9月10日累积更新：已修复和损坏的问题

   随着Windows 10的发布,Microsoft重新设计了Windows Update计划,以及如何更新设备.在第二个星期二,将发布新的累积更新,作为"星期二补丁"版本的一部分, ...

9. 总结一下silverlight文章,然后死等10月10日的正式版

   这三天参加了微软关于WPF&Silverlight的培训(昨天结束),与美国微软总部过来的专家Jaime Rodriguez, Laurence Moroney,做了面对面的技术交流,感觉受益 ...

10. 阴阳师服务器维护更新,阴阳师服务器3月10日维护更新了什么 阴阳师服务器3月10日维护更新一览...

    网易阴阳师安卓版1.0.17.6 官方最新版 类型:角色扮演大小:623M语言:中文 评分:6.3 标签: 立即下载 阴阳师今早凌晨进行服务器的更新维护,暂时不能进行登录,不少小伙伴想知道这次更新维护 ...

最新文章

1. 强化学习常用算法+实际应用 ，必须get这些核心要点！
2. MyBatis中ThreadLocal
3. Python 俄罗斯方块， 基于pyqt5实现俄罗斯方块 --pyqt5 进阶
4. 启动/关闭Spring boot服务脚本
5. python学习笔记 day33 ftp大作业（未完成）
6. 自动控制原理概念梳理（脑图）
7. php 打印所有常量,php中输出常量
8. 自制计算机考试系统,用WPS表格制作考试系统 -电脑资料
9. 微信打飞机项目小结-屏幕适配
10. android模拟器登录用户,如何在模拟器上登录小米账号的游戏
11. matlab直观数据处理,霍尔效应实验数据处理 [霍尔效应实验的MATLAB数据处理]
12. 计算机共享访问权限,设置电脑共享权限、电脑文件共享权限设置、设置共享文件夹访问权限的方法...
13. 移动用户免费领取15G流量（秒到）
14. 织梦后台登陆界面如何修改
15. python print怎么用_Python学习路线分享Beeprint怎么用
16. 计算机13E怎么转换成十进制,十六进制换算(进制转换计算器)
17. 富文本样式文字图片处理
18. 移动端html尺寸,移动端页面的三种尺寸
19. 一个新的开始，fightting！
20. 万字长文让您搞懂云原生！

热门文章

1. NLP中的预训练方法总结 word2vec、ELMO、GPT、BERT、XLNET
2. Google 出品的 Java 编码规范，强烈推荐，权威又科学！
3. 用c 语言创建web项目,使用Maven创建Web应用程序项目
4. 阴阳师bug以及服务器维护问题,阴阳师业原火bug处理公告汇总
5. c语言加密字母向右移两位,C语言二进制除法用左右移位来表示
6. python中的threading_python中threading的用法
7. mysql修改密码1054_Mysql修改密码异常处理(ERROR 1054)
8. 图片轮播html1001无标题,轮播图采用js、jquery实现无缝滚动和非无缝滚动的四种案例实现，兼容ie低版本浏览器...
9. python-gui-pyqt5的使用方法-1
10. Python列表中数据插入数据库