波士顿房价预测

项目已经放置在Ai studio，欢迎fork三连

从手写到基于paddle2.0的波士顿房价预测
https://aistudio.baidu.com/aistudio/projectdetail/2079294

文章目录

  • 波士顿房价预测
    • 线性回归模型介绍
    • 线性回归模型的神经网络结构
  • 完整代码编写流程详解
    • 第一步 数据处理
      • 1.1 数据读取
      • 1.2 数据形状变换
      • 1.3 数据集划分
      • 1.4 数据归一化处理
      • 1.5 封装成load data函数
    • 第二步 模型设计
      • 1.前向计算
      • 2.损失函数编写
      • 3.梯度下降法
      • 4.随机梯度下降法训练数据
  • 基于paddle2.0的波士顿房价预测
    • 第一步 加载所需要的库
    • 第二步 数据处理
    • 第三步 模型设计
    • 第四步 训练配置
    • 第五步 训练
    • 第六步 保存并测试模型
      • 保存模型
      • 测试模型
    • 总结
    • 个人总结

神经网络的基本概念（如神经元、多层连接、前向计算、计算图）

模型结构三要素（模型假设、评价函数和优化算法）

本项目将以“波士顿房价预测”任务为例，向读者介绍使用Python语言和Numpy库来构建神经网络模型的思考过程和操作方法。

波士顿房价预测是一个经典的机器学习任务，类似于程序员世界的“Hello World”。和大家对房价的普遍认知相同，波士顿地区的房价受诸多因素影响。该数据集统计了13种可能影响房价的因素和该类型房屋的均价，期望构建一个基于13个因素进行房价预测的模型，如下图所示。

对于预测问题，可以根据预测输出的类型是连续的实数值，还是离散的标签，区分为回归任务和分类任务。因为房价是一个连续值，所以房价预测显然是一个回归任务。下面我们尝试用最简单的线性回归模型解决这个问题，并用神经网络来实现这个模型。

线性回归模型介绍

假设房价和各影响因素之间能够用线性关系来描述：

模型的求解即是通过数据拟合出每个wjw_jwj​和b。

其中，wjw_jwj​和b分别表示该线性模型的权重和偏置。一维情况下，wjw_jwj​和 b 是直线的斜率和截距。

线性回归模型使用均方误差作为损失函数（Loss），用以衡量预测房价和真实房价的差异，公式如下：

线性回归模型的神经网络结构

神经网络的标准结构中每个神经元由加权和与非线性变换构成，然后将多个神经元分层的摆放并连接形成神经网络。

线性回归模型可以认为是神经网络模型的一种极简特例，是一个只有加权和、没有非线性变换的神经元（无需形成网络），如下图所示

完整代码编写流程详解

第一步 数据处理

数据处理包含五个部分：数据导入、数据形状变换、数据集划分、数据归一化处理和封装load data函数。数据预处理后，才能被模型调用。

1.1 数据读取

import numpy as np
import json
datafile = 'data/data95203/housing.data'
data = np.fromfile(datafile,sep=' ')

#查看数据集的数据结构
print(data)
print(data.shape[0])

[6.320e-03 1.800e+01 2.310e+00 ... 3.969e+02 7.880e+00 1.190e+01]
7084

可能还不清晰，放上csv的图，输出的数据依次对应表格数据

1.2 数据形状变换

刚刚输出的结果可以看出，读入的原始数据是1维的，所有数据都连在一起。

因此需要我们将数据的形状进行变换，形成一个2维的矩阵，每行为一个数据样本（14个值），每个数据样本包含13个X（影响房价的特征）和一个Y（该类型房屋的均价）。

# 读入之后的数据被转化成1维array，其中array的第0-13项是第一条数据，第14-27项是第二条数据，以此类推....
# 这里对原始数据做reshape，变成N x 14的形式
feature_names = [ 'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE','DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV' ]
feature_num = len(feature_names)
# 在Python中“/”表示浮点数除法，返回浮点结果，也就是结果为浮点数，而“//”在Python中表示整数除法，返回不大于结果的一个最大的整数，意思就是除法结果向下取整。
data = data.reshape([data.shape[0] // feature_num, feature_num])

# 查看数据
x = data[0]
print(x.shape)
print(x) #x对应上面表格的第一行数据

(14,)
[6.320e-03 1.800e+01 2.310e+00 0.000e+00 5.380e-01 6.575e+00 6.520e+014.090e+00 1.000e+00 2.960e+02 1.530e+01 3.969e+02 4.980e+00 2.400e+01]

1.3 数据集划分

将数据集划分成训练集和测试集，其中训练集用于确定模型的参数，测试集用于评判模型的效果。

一般划分为8:2

ratio = 0.8
offset = int(data.shape[0] * ratio) #506*0.8=404分为训练集
training_data = data[:offset]
print(training_data.shape)
print(training_data[0])

(404, 14)
[6.320e-03 1.800e+01 2.310e+00 0.000e+00 5.380e-01 6.575e+00 6.520e+014.090e+00 1.000e+00 2.960e+02 1.530e+01 3.969e+02 4.980e+00 2.400e+01]

1.4 数据归一化处理

对每个特征进行归一化处理，使得每个特征的取值缩放到0~1之间。

这样做有两个好处：

  1. 一是模型训练更高效；
  2. 二是特征前的权重大小可以代表该变量对预测结果的贡献度（因为每个特征值本身的范围相同）。
# 计算train数据集的最大值，最小值，平均值
maximums, minimums, avgs = \training_data.max(axis=0), \training_data.min(axis=0), \training_data.sum(axis=0) / training_data.shape[0]
# 对数据进行归一化处理
for i in range(feature_num):#print(maximums[i], minimums[i], avgs[i])data[:, i] = (data[:, i] - minimums[i]) / (maximums[i] - minimums[i])

1.5 封装成load data函数

将上述几个数据处理操作封装成load data函数，以便下一步模型的调用，实现方法如下。

def load_data():# 从文件导入数据datafile = 'data/data95203/housing.data'data = np.fromfile(datafile, sep=' ')# 每条数据包括14项，其中前面13项是影响因素，第14项是相应的房屋价格中位数feature_names = [ 'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', \'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV' ]feature_num = len(feature_names)# 将原始数据进行Reshape，变成[N, 14]这样的形状data = data.reshape([data.shape[0] // feature_num, feature_num])# 将原数据集拆分成训练集和测试集# 这里使用80%的数据做训练，20%的数据做测试# 测试集和训练集必须是没有交集的ratio = 0.8offset = int(data.shape[0] * ratio)training_data = data[:offset]# 计算训练集的最大值，最小值，平均值maximums, minimums, avgs = training_data.max(axis=0), training_data.min(axis=0), \training_data.sum(axis=0) / training_data.shape[0]# 对数据进行归一化处理for i in range(feature_num):#print(maximums[i], minimums[i], avgs[i])data[:, i] = (data[:, i] - minimums[i]) / (maximums[i] - minimums[i])# 训练集和测试集的划分比例training_data = data[:offset]test_data = data[offset:]return training_data, test_data

# 获取数据
training_data, test_data = load_data()
x = training_data[:, :-1]
y = training_data[:, -1:]
# 查看数据
print(x[1])
print(y[1])

[2.35922539e-04 0.00000000e+00 2.62405717e-01 0.00000000e+001.72839506e-01 5.47997701e-01 7.82698249e-01 3.48961980e-014.34782609e-02 1.14822547e-01 5.53191489e-01 1.00000000e+002.04470199e-01]
[0.36888889]

第二步 模型设计

模型设计是深度学习模型关键要素之一，也称为网络结构设计，相当于模型的假设空间，即实现模型“前向计算”（从输入到输出）的过程。

1.前向计算

2.损失函数编写

3.梯度下降法

4.随机梯度下降法训练数据

class Network(object):def __init__(self, num_of_weights):# 随机产生w的初始值# 为了保持程序每次运行结果的一致性，此处设置固定的随机数种子#np.random.seed(0)self.w = np.random.randn(num_of_weights, 1)self.b = 0.def forward(self, x):# 求预测值 正是y= w1x1+w2x2+...+bz = np.dot(x, self.w) + self.breturn zdef loss(self, z, y):# 损失函数 采用均方差（回归问题常用）error = z - ynum_samples = error.shape[0]cost = error * errorcost = np.sum(cost) / num_samplesreturn costdef gradient(self, x, y):# 梯度下降法 z = self.forward(x)N = x.shape[0]gradient_w = 1. / N * np.sum((z-y) * x, axis=0)# gradient_w的形状是(13,)，而www的维度是(13, 1)。# 导致该问题的原因是使用np.mean函数时消除了第0维。# 为了加减乘除等计算方便，gradient_w和www必须保持一致的形状。# 因此我们将gradient_w的维度也设置为(13,1)gradient_w = gradient_w[:, np.newaxis]gradient_b = 1. / N * np.sum(z-y)return gradient_w, gradient_bdef update(self, gradient_w, gradient_b, eta = 0.01):# 更新w和b，实际上就是不断地改变这俩值找到最优解，eta也就是学习率，每次改变的大小self.w = self.w - eta * gradient_wself.b = self.b - eta * gradient_bdef train(self, training_data, num_epochs, batch_size=10, eta=0.01):n = len(training_data)losses = []for epoch_id in range(num_epochs):# 在每轮迭代开始之前，将训练数据的顺序随机打乱# 然后再按每次取batch_size条数据的方式取出np.random.shuffle(training_data)# 将训练数据进行拆分，每个mini_batch包含batch_size条的数据mini_batches = [training_data[k:k+batch_size] for k in range(0, n, batch_size)]for iter_id, mini_batch in enumerate(mini_batches):#print(self.w.shape)#print(self.b)# 依次使用每个mini_batch的数据x = mini_batch[:, :-1]y = mini_batch[:, -1:]a = self.forward(x)loss = self.loss(a, y)gradient_w, gradient_b = self.gradient(x, y)self.update(gradient_w, gradient_b, eta)losses.append(loss)print('Epoch {:3d} / iter {:3d}, loss = {:.4f}'.format(epoch_id, iter_id, loss))return losses

# 获取数据
train_data, test_data = load_data()
x = train_data[:, :-1]
y = train_data[:, -1:]

# 创建网络
net = Network(13)
num_iterations=1000

# 启动训练 （输出太长，已经删除，下图即为输出值变化曲线）
losses = net.train(train_data, num_epochs=50, batch_size=100, eta=0.1)

import matplotlib.pyplot as plt
%matplotlib inline# 画出损失函数的变化趋势
plot_x = np.arange(len(losses))
plot_y = np.array(losses)
plt.plot(plot_x, plot_y)
plt.show()

得到最终的w和b

y= wx+b

net.w

array([[-1.69854808],[-0.91744872],[ 0.50710449],[ 0.12872548],[-0.83883171],[-0.0215474 ],[-0.1770615 ],[ 0.67046724],[ 0.64234646],[-0.14771003],[-0.7989083 ],[ 0.26872525],[ 0.09388977]])

net.b

0.7196680949465608

即如下为最终得出的公式

print("y = ")
j=1
for i in net.w:print(i,"x",j,"+")j=j+1
print(net.b," .")

y =
-1.698548080x1 +
-0.917448720x2 +
0.507104490x3 +
0.128725480x4 +
-0.83883171x5 +
-0.02154740x6 +
-0.17706150x7 +
0.670467240x8 +
0.642346460x9 +
-0.14771003x10 +
-0.79890830x11 +
0.26872525x12 +
0.09388977x13 + 0.7196680949465608  .

x = test_data[:, :-1]
y = test_data[:, -1:]print(x[0])
print(y[0])

[0.46670716 0.         0.70027789 0.         0.63374486 0.377466950.84963955 0.04344861 1.         1.         0.80851064 0.793192270.70778146]
[0.07777778]

# ，预测值的函数就是net.forward()
# 这里的结果是负数，并没有出错，是归一化的数据结果，只要两者结果一致，就没有问题。
# 如果想要真实数据，进行反归一化就行了，就是将前面的归一化进行逆运算。y = net.forward(x[0])print("预测结果为：",y[0],"w.")
print("实际结果为：",y[0],"w.")

预测结果为： -0.2506738961322095 w.
实际结果为： -0.2506738961322095 w.

基于paddle2.0的波士顿房价预测

任务不再描述，后面将使用paddle2.0进行重写房价预测模型

第一步 加载所需要的库

paddle库、Numpy和相关类库

#加载飞桨、Numpy和相关类库
import paddle
from paddle.nn import Linear
import paddle.nn.functional as F
import numpy as np
import os
import random

/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/layers/utils.py:26: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.
Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecationsdef convert_to_list(value, n, name, dtype=np.int):

第二步 数据处理

def load_data():# 从文件导入数据datafile = 'data/data95203/housing.data'data = np.fromfile(datafile, sep=' ', dtype=np.float32)# 每条数据包括14项，其中前面13项是影响因素，第14项是相应的房屋价格中位数feature_names = [ 'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', \'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV' ]feature_num = len(feature_names)# 将原始数据进行Reshape，变成[N, 14]这样的形状data = data.reshape([data.shape[0] // feature_num, feature_num])# 将原数据集拆分成训练集和测试集# 这里使用80%的数据做训练，20%的数据做测试# 测试集和训练集必须是没有交集的ratio = 0.8offset = int(data.shape[0] * ratio)training_data = data[:offset]# 计算train数据集的最大值，最小值，平均值maximums, minimums, avgs = training_data.max(axis=0), training_data.min(axis=0), \training_data.sum(axis=0) / training_data.shape[0]# 记录数据的归一化参数，在预测时对数据做归一化global max_valuesglobal min_valuesglobal avg_valuesmax_values = maximumsmin_values = minimumsavg_values = avgs# 对数据进行归一化处理for i in range(feature_num):data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i])# 训练集和测试集的划分比例training_data = data[:offset]test_data = data[offset:]return training_data, test_data

第三步 模型设计

模型定义的实质是定义线性回归的网络结构，paddle建议通过创建Python类的方式完成模型网络的定义，该类需要继承paddle.nn.Layer父类，并且在类中定义init函数和forward函数。

forward函数是框架指定实现前向计算逻辑的函数，程序在调用模型实例时会自动执行forward方法。在forward函数中使用的网络层需要在init函数中声明。

class Regressor(paddle.nn.Layer):# self代表类的实例自身def __init__(self):# 初始化父类中的一些参数super(Regressor, self).__init__()# 定义一层全连接层，输入维度是13，输出维度是1self.fc = Linear(in_features=13, out_features=1)# 网络的前向计算def forward(self, inputs):x = self.fc(inputs)return x

第四步 训练配置

  1. 声明定义好的回归模型Regressor实例，并将模型的状态设置为训练。
  2. 使用load_data函数加载训练数据和测试数据。
  3. 设置优化算法和学习率，优化算法采用随机梯度下降SGD，学习率设置为0.01。
# 声明定义好的线性回归模型
model = Regressor()
# 开启模型训练模式
model.train()
# 加载数据
training_data, test_data = load_data()
# 定义优化算法，使用随机梯度下降SGD
# 学习率设置为0.01
opt = paddle.optimizer.SGD(learning_rate=0.01, parameters=model.parameters())

第五步 训练

  1. 数据准备：将一个批次的数据先转换成np.array格式，再转换成paddle内置tensor格式。
  2. 前向计算：将一个批次的样本数据灌入网络中，计算输出结果。
  3. 计算损失函数：以前向计算结果和真实房价作为输入，通过损失函数square_error_cost API计算出损失函数值（Loss）。
  4. 反向传播：执行梯度反向传播backward函数，即从后到前逐层计算每一层的梯度，并根据设置的优化算法更新参数。
EPOCH_NUM = 100   # 设置外层循环次数
BATCH_SIZE = 10  # 设置batch大小# 定义外层循环
for epoch_id in range(EPOCH_NUM):# 在每轮迭代开始之前，将训练数据的顺序随机的打乱np.random.shuffle(training_data)# 将训练数据进行拆分，每个batch包含10条数据mini_batches = [training_data[k:k+BATCH_SIZE] for k in range(0, len(training_data), BATCH_SIZE)]# 定义内层循环for iter_id, mini_batch in enumerate(mini_batches):x = np.array(mini_batch[:, :-1]) # 获得当前批次训练数据y = np.array(mini_batch[:, -1:]) # 获得当前批次训练标签（真实房价）# 将numpy数据转为飞桨动态图tensor形式house_features = paddle.to_tensor(x)prices = paddle.to_tensor(y)# 前向计算predicts = model(house_features)# 计算损失loss = F.square_error_cost(predicts, label=prices)avg_loss = paddle.mean(loss)if iter_id%20==0:print("epoch: {}, iter: {}, loss is: {}".format(epoch_id, iter_id, avg_loss.numpy()))# 反向传播avg_loss.backward()# 最小化loss,更新参数opt.step()# 清除梯度opt.clear_grad()

第六步 保存并测试模型

保存模型

将模型当前的参数数据model.state_dict()保存到文件中（通过参数指定保存的文件名 bsd_model），以备预测或校验的程序调用，代码如下所示。

# 保存模型参数，文件名为bsd_model.pdparams
paddle.save(model.state_dict(), 'bsd_model.pdparams')
print("模型保存成功，模型参数保存在bsd_model.pdparams中")

模型保存成功，模型参数保存在bsd_model.pdparams中

测试模型

  1. 配置模型预测的机器资源。
  2. 将训练好的模型参数加载到模型实例中。
    由两个语句完成，第一句是从文件中读取模型参数；第二句是将参数内容加载到模型。
    加载完毕后，需要将模型的状态调整为eval()（校验）。
  3. 将待预测的样本特征输入到模型中，打印输出的预测结果。

通过load_one_example函数实现从数据集中抽一条样本作为测试样本，具体实现代码如下所示。

def load_one_example():# 从上边已加载的测试集中，随机选择一条作为测试数据idx = np.random.randint(0, test_data.shape[0])idx = -10one_data, label = test_data[idx, :-1], test_data[idx, -1]# 修改该条数据shape为[1,13]one_data =  one_data.reshape([1,-1])return one_data, label

# 参数为保存模型参数的文件地址
model_dict = paddle.load('bsd_model.pdparams')
model.load_dict(model_dict)
model.eval()# 参数为数据集的文件地址
one_data, label = load_one_example()
# 将数据转为动态图的variable格式
one_data = paddle.to_tensor(one_data)
predict = model(one_data)# 对结果做反归一化处理
predict = predict * (max_values[-1] - min_values[-1]) + avg_values[-1]
# 对label数据做反归一化处理
label = label * (max_values[-1] - min_values[-1]) + avg_values[-1]print("预测房价是 {}".format(predict.numpy()))
print("实际房价是 {}".format(label))

预测房价是 [[13.31676]]
实际房价是 19.700000762939453

总结

我们详细介绍了如何使用Numpy实现梯度下降算法，构建并训练了一个简单的线性模型实现波士顿房价预测，可以总结出，使用神经网络建模房价预测有三个要点：

  1. 构建网络，初始化参数w和b，定义预测和损失函数的计算方法。
  2. 随机选择初始点，建立梯度的计算方法和参数更新方式。
  3. 从总的数据集中抽取部分数据作为一个mini_batch，计算梯度并更新参数，不断迭代直到损失函数几乎不再下降。

个人总结

我是iterhui(全网同名)

我在AI Studio上获得黄金等级，点亮8个徽章，来互关呀~

https://aistudio.baidu.com/aistudio/personalcenter/thirdview/643467

[Paddle2.0学习之第一步]实现波士顿房价预测相关推荐

  1. 波士顿房价预测——机器学习入门级案例

    一.数据处理 1.1 数据集介绍 本实验使用波士顿房价预测数据集,共506条样本数据,每条样本包含了13种可能影响房价的因素和该类房屋价格的中位数,各字段含义如下表所示: 字段名 类型 含义 CRIM ...

  2. [Paddle2.0学习之第四步]（下）词向量之CBOW

    [Paddle2.0学习之第四步]词向量之CBOW 项目已放在aistudio: [Paddle2.0学习之第四步](下)词向量之CBOW 文章目录 [Paddle2.0学习之第四步]词向量之CBOW ...

  3. 新手零基础学习Python第一步，搭建开发环境！

    如何在电脑上面搭建Python开发环境?本文会解答这个问题. Python是一门计算机编程语言,通过给计算机下达精确的指令以完成相应的任务或者事情. 人类掌握Python后,就可以利用这个工具告诉计算 ...

  4. 加速度测试什么软件,错题整理神器，喵喵错题APP实现高效学习的第一步

    错题整理神器,喵喵错题APP实现高效学习的第一步 "如何高效的提升学习效率?",关于这一问题,近期我是做了不少功课.因为家里的孩子已经幼升小,但经过一年级上学期半年的学习,孩子的成 ...

  5. 听说写博客是程序猿学习的第一步

    听说写博客是程序猿学习的第一步 对ICT类技术神往已久,尤其是编程和算法.只是苦于自制力有限,始终无法入门.每每看到别人学习编程.解决了问题,我总是很兴奋,憧憬着自己也能像他们一样用代码实现一些自己的 ...

  6. 【SEO学习】第一步：了解搜索引擎基本工作原理和工作流程

    我们常用的搜索引擎一般都是百度.谷歌.搜狗.360.bing这五种,对于搜索引擎的原理和工作流程应该是一样的.今天郑州SEO老冯先给大家说一下百度搜索引擎的工作原理以及抓取过程.这是SEO学习的第一步 ...

  7. 教你使用百度深度学习框架PaddlePaddle完成波士顿房价预测（新手向）

    首先,本文是一篇纯新手向文章,我自己也只能算是入门,有说错的地方欢迎大家批评讨论 目录 一.人工智能.机器学习.深度学习 二.PaddlePaddle(飞桨) 三.波士顿房价预测模型 数据处理 模型设 ...

  8. 深度学习入门——波士顿房价预测

    基于神经网络模型的波士顿房价预测 波士顿房价预测是一个经典的机器学习任务,类似于程序员世界的"Hello World".以"波士顿房价预测"任务为例,我们学习如 ...

  9. 使用Python和Numpy进行波士顿房价预测任务（二）【深度学习入门_学习笔记】

    使用Python和Numpy进行波士顿房价预测任务–详解 目录: 一.数据处理 (1)读入数据 (2)数据形状变换 (3)数据集划分 (4)数据归一化处理 (5)封装成load data函数 二.模型 ...

  10. 深度学习（波士顿房价预测）

    本程序采用百度paddlepaddle深度学习框架,并在百度AI Studio平台上运行. 目录 1实验背景 2 实验过程 2.1 数据处理 2.1.1数据集导入并按规定形状保存 2.1.2数据集的划 ...

最新文章

  1. usaco contact
  2. 深度丨AlphaGo Zero的启示：监督学习和无监督学习的利弊
  3. 人工智能算法_人工智能的灵魂——算法
  4. ORACLE初始化参数文件概述
  5. C#4.0和VS2010新特性（三）
  6. hdu3987 最小割边数
  7. php销毁three.js量,javascript – ThreeJS：从场景中删除对象
  8. python3之协程(1)---协程简介
  9. 用PHP写出显示客户端IP与服务器IP的代码
  10. xshell和Xftp连接Linux
  11. Agile PLM EC Understand the BOM Publishing Process
  12. 07-08软工升本考试原题——SQL与关系代数
  13. ZXing条码扫描----竖屏解决方案
  14. hive 添加字段_Hive分区表动态添加字段
  15. Android流光动画,流光相机app_流光相机官网-多特软件站安卓网
  16. 洋酒销售系统的设计与实现（附源码+资料+论文+截图+数据库）
  17. 在线TSV转CSV工具
  18. 网络上怎么赚钱？这3个赚钱方式目前最稳妥！
  19. mysql 所有字符集_mysql字符集
  20. 技术总结-技术方案模板

热门文章

  1. 2021-3-18大学化学无机原理（3）热力学能与热力学第一定律
  2. Windows软件之——RocketDock之无法拖放图标到dock栏
  3. 解决hashcat报错
  4. 苍蓝誓约服务器维护什么时候结束,《苍蓝誓约》12月10日09:30停服维护公告
  5. 大禹电子：元宵佳节逛花灯，猜灯谜好不热闹
  6. postman更换皮肤
  7. 如何才能解决堵车？这个实验告诉你答案！
  8. 程序猿转行为什么这么难
  9. python 设计单张扑克牌类Card 设计整副扑克牌类Cards
  10. 高德导航车机5.3~6.2共存制作