不一样的烟火

什么是SparseReward

2019-07-18T03:50:59.000Z

人们学习的过程中，常常无法及时获得回报。就像家长让小朋友写作业，小朋友可能觉得这个是负面的反馈而不去写作业（做作业让我觉得很痛苦qwq），而没有意识到以后会获得的巨大回报：写完作业后成绩提高，考上好大学，成为高富帅，从此走向巅峰赢取白富美…

这个一开始的暂时的小的reward 就叫 Sparse Reward

如何让agent在Sparse Reward 中拥有更好的学习表现？

1.“写完作业就给糖吃”

把关键的一些动作强制地定义为正的reward，这样agent就不会反感这一学习行为，从而一步步走到最大的reward

2.“兴趣是最好的老师 ” Curiosity Module

尽管是一些风吹草动，很难让agent得到一些有用的反馈。这时让agent自己预测这个动作将来的reward，这样也能达到最终的效果。让agent预测做一个动作的未来的reward，从而使agent有兴趣的学习。

3.“制定学习计划” Curriculum Learning

人来设定agent的学习顺序，使agent以从易到难的顺序学习

4.阶层式强化学习 Hierarchical RL

由上层agent提出愿景，由最下层agent来执行动作

西瓜书习题3.4(交叉验证法)

2019-07-10T09:35:02.000Z

西瓜书习题3.4 (交叉验证法)：

选择两个UCI数据集，比较10折交叉验证法和留一法所估计出的对率回归的错误率.

1.数据集长啥样？

于是就下载了一组UCI数据集，它长这样：

至于这些数据是啥意思、UCI又是啥，咱也不知道咱也不敢问qwq~，只知道有748行、5列，在咱眼里它就是一个 (748 * 5)的矩阵。第5列数据是0和1，那它肯定是labels，属于二分类问题。

2.啥是十折交叉验证法？啥是留一法？

k折交叉验证法：

我们将数据集随机分成k份，使用其中 k-1 份进行训练而将另外1份用作测试。该过程可以重复 k 次，每次使用的测试数据不同。

（1）每一次迭代中留存其中一个桶。第一次迭代中留存桶1，第二次留存桶2，其余依此类推。

（2）用其他 k-1 个桶的信息训练分类器（第一次迭代中利用从桶2到桶 k 的信息训练分类器）。

（3）最终返回这 k 次测试结果的accuracy的均值

十折交叉验证法就是 k=10 的情况

留一法则是 k=总样本数的情况，即每次迭代从总样本取一条数据做测试集，剩余的全做训练集

3.以上一顿分析猛如虎，是时候该撸码实现啦 qwq

import numpy as np
import pandas as pd


# sigmoid函数
def sigmoid(z):
    return 1.0 / (1.0 + np.exp(-z))


# 梯度上升算法
def grad(train_X, labels, iters=2000):
    m, n = train_X.shape
    # 步长alpha
    alpha = 0.05
    # 初始化权重，全设为1
    weights = np.ones((n, 1))

    # 2000次迭代
    for k in range(iters):
        # 沿着梯度方向，向前移动，并更新权重
        P = sigmoid(train_X.dot(weights))
        error = labels - P
        weights += alpha * np.dot(train_X.T, error)

    return weights


# predict function 返回一组预测结果，由0或1构成的 (m,1)矩阵
def predict(test_X, weights):
    m = test_X.shape[0]
    #由sigmoid函数的性质，z = w * x , z大于0时，sigmoid(Z)>0.5 即预测为1，反之预测为0 
    p = np.dot(test_X, weights)
    for k in range(m):
        if p[k] > 0:
            p[k] = 1
        else:
            p[k] = 0

    return p


# calculate accuracy 计算准确率，一列是预测结果，一列是真实结果，结果相同则计数
def accuracy(predict_Y, Y):
    m, n = Y.shape
    Matched = 0
    for k in range(m):
        if predict_Y[k] == Y[k]:
            Matched += 1
        else:
            Matched += 0
    return Matched / m

#数据矩阵化

df = pd.read_csv('Transfusion.txt')
df['one'] = 1
#print(df)

X = np.hstack((np.mat(df['one']).T,np.mat(df.iloc[:,0:4])))
Y = np.mat(df.iloc[:,4]).T
#print(X,Y)


# 留一法：有m个数据样本，k折交叉验证是把样本划分为10等份，留一法就是k=m时的场景，即每次留1个样本做测试集，剩余的全部做训练集
total = X.shape[0]
sum = 0
for k in range(total):
    test_index = k  # 测试集下标

    test_X = X[k]
    test_Y = Y[k]

    train_X = np.delete(X, test_index, axis=0)
    train_Y = np.delete(Y, test_index, axis=0)

    # 对率回归
    weights = grad(train_X, train_Y)

    # 统计正确率
    p = predict(test_X, weights)
    sum += accuracy(p, test_Y)

print('''LeaveOneOut's Accuracy: ''', sum / total)



#十折交叉验证,把样本分成10等分，在这10份数据中依次抽取一份做测试集，剩余9份做训练集，重复10次
total = X.shape[0]
num_split = int(total / 10)
sum = 0

for k in range(10):

    #选择测试集的下标
    test_index = range(k * num_split , (k+1) * num_split)
    
    test_X = X[test_index]
    test_Y = Y[test_index]
    
    train_X = np.delete(X,test_index,axis=0)
    train_Y = np.delete(Y,test_index,axis=0)
    
    #求对率回归最优参数
    weights = grad(train_X,train_Y)
    #print(weights)
    #统计每次组的正确率
    p = predict(test_X,weights)
    sum += accuracy(p,test_Y)
    #result += predict(test_X,weights)==test_Y ? 1:0

#正确次数 / 验证总次数 = 准确率
print('''10-foldCrossValidation's Accuracy: ''',sum/10)

结果是：

1
2
3

LeaveOneOut's Accuracy:  0.7831325301204819

10-foldCrossValidation's Accuracy:  0.7459459459459458

可以发现留一法准确率高十折交叉验证法将近4个百分点，其实差别不是很大，但使用留一法的运算时间却十分漫长

其原因是十折交叉验证法只需训练10个模型，而留一法则需要训练跟样本数量一样多的模型，而本次样本数量为748，速度慢一大截

可见，在数据集比较大时，留一法并不适用。(例如100万个样本，则需要训练100万个模型，编程几分钟，训练好几天？)

在github上建图床

2019-07-09T12:12:23.000Z

最近用hexo整了个博客，我现在的感受就是这也太tm折腾了。

用markdown写博客少不了插入图片，看似简单的操作其实可折腾了！本地的图片要部署到服务器上必须要使用图床才能实现，网上各种推荐腾讯云、七牛云来做图床，我都尝试了一下，发现要充钱才行，果断另寻她法.（发出了穷逼的声音 qaq）

现在来介绍一下如何直接在github上建图床

GitHub可谓是良心大大滴！免费，没有容量限制，只是单个文件不能超过100M，有50M的文件，就会警告了。这对搭个博客用的图床来说完全足够了。不多bb，进入上手环节：

进入repositories后new一个存储库命名为：你的github用户名.github.iogithub，点击上方的Setting并往下拉，去到GitHub Pages设置项，把Source项设定为master branch
这些都是搭博客的基本操作，已经建了这个仓库的，可以在这个仓库上上传文件。比如

图片已经上传，这个时候其实是可以直接通过图片链接访问这个图片的
图片链接的格式：https://github用户名.github.io/存储库名/你的图片名（加后缀名）

在markdown插入图片链接，就可以显示该图片了

以上是图床的基本原理！！！

博客的项目文件在每次部署的时候都会更新，这样不利于对上传图片的保存。要如何解决这个问题呢？

到博客根目录下查看_config.yml文件查找 post_asset_folder 字段确定post_asset_folder 设置为true
post_asset_folder:true
设置 post_asset_folder 参数后，在建立文件时，Hexo 会自动建立一个与文章同名的文件夹，可以把与该文章相关的所有资源都放到此文件夹内，这样就可以更方便的使用资源。像这样
把要用的图片都放在这个文件夹下，下次 hexo d 部署博客的时候可以看到
要用的图片文件都在github的仓库上了，这时用前面介绍的原理，记下文件的路径名在编写markdown的时候添加图片链接即可
图片链接的格式：https://github用户名.github.io/存储库名/你的图片名（加后缀名）
比如我上面的皮卡丘动图 2.gif 的链接就是： https://qwq1082.github.io/2019/07/09/pikachu/2.gif
写好markdown之后再次部署即可
欢迎访问呀 https://qwq1082.github.io/2019/07/09/pikachu/

'pikachu'

2019-07-09T03:12:23.000Z

在GitHub上建图床

西瓜书习题3.3(对率回归 LR)

2019-07-08T13:41:33.000Z

西瓜书习题 3.3(对率回归 LR)

编程实现对率回归，并给出西瓜数据集上的结果

西瓜数据集如下：

ID  density  Sugar_content  label

0    1    0.697         0.4600      1
1    2    0.774         0.3760      1
2    3    0.634         0.2640      1
3    4    0.608         0.3180      1
4    5    0.556         0.2150      1
5    6    0.403         0.2370      1
6    7    0.481         0.1490      1
7    8    0.437         0.2110      1
8    9    0.666         0.0910      0
9   10    0.243         0.0267      0
10  11    0.245         0.0570      0
11  12    0.343         0.0990      0
12  13    0.639         0.1610      0
13  14    0.657         0.1980      0
14  15    0.360         0.3700      0
15  16    0.593         0.0420      0
16  17    0.719         0.1030      0

这题的关键就在于对对率回归的理解，附上对率回归的手写版公式推导过程：

推导RL的过程，得到了梯度公式，接下来用梯度上升算法实现RL（还有一种是用牛顿法实现，以后有时间在补充吧qwq~）

1
2
3

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

#读取文件
df = pd.read_csv('watermelon3.0alpha.csv')
print(df)
#方便矩阵运算，添一列1
df['one'] = 1.0
#将训练集装进矩阵
train_X = np.mat(df[['one','density','Sugar_content']])
#标签
labels = np.mat(df[['label']])

1
2
3

#sigmoid函数
def sigmoid(z):
    return 1.0/(1.0 + np.exp(-z))

#梯度上升算法
def grad(train_X,labels,iters = 2000):
    m,n = train_X.shape
    #步长alpha
    alpha = 0.05
    #初始化权重，全设为1
    weights = np.ones((n,1))
    
    #2000次迭代
    for k in range(iters):
        #沿着梯度方向，向前移动，并更新权重
        P = sigmoid(train_X.dot(weights))
        error = labels - P
        weights += alpha * np.dot(train_X.T,error)

    return weights

#求出最优回归参数
weights = grad(train_X,labels)
print(weights)

求得参数如下：

1
2
3

[[-3.12066518]
 [ 0.76966008]
 [13.22972573]]

#绘图
x1,y1 = [],[]
x2,y2 = [],[]
x3,y3 = [],[]
x4,y4 = [],[]

for k in range(train_X.shape[0]):
    if labels[k] == 1:
        if sigmoid(np.dot(train_X[k,:],weights)) >= 0.5 :
            x1.append(train_X[k,1])
            y1.append(train_X[k,2])
        else:
            x2.append(train_X[k,1])
            y2.append(train_X[k,2]) 
    else:  
        if sigmoid(np.dot(train_X[k,:],weights)) < 0.5 :
            x3.append(train_X[k,1])
            y3.append(train_X[k,2])
        else:
            x4.append(train_X[k,1])
            y4.append(train_X[k,2])
            
plt.scatter(x1,y1,s=30,c='red')
plt.scatter(x2,y2,s=30,c='red',marker='x')
plt.scatter(x3,y3,s=30,c='green')
plt.scatter(x4,y4,s=30,c='green',marker='x')

#绘制直线    w0 + w1x1 +w2x2 = 0
X = np.arange(0,0.8,0.01)
Y = -(weights[0] + weights[1] * X)/weights[2]

#总结：绘制直线用 plot ， 绘制散点 用scatrer
plt.plot(X,Y)

plt.xlabel('Density')
plt.ylabel('Sugar_Content')
plt.title("LogisticRegression")
plt.show()

卷积神经网络的搭建

2019-07-02T04:11:44.000Z

卷积神经网络的搭建

1 预处理训练集与测试集图片

说明：因为我们从网上下载的图片各种格式都有大小也不统一，所以图片的批量预处理是很必要的。

（1）将图片大小统一修改成100*100，可参考下面代码

def convertjpg(jpgfile,outdir,width=100,height=100):
    img = Image.open('C:/Users/ASUS/Desktop/cat/暹罗猫/'+jpgfile)
    try:
        new_img = img.resize((width, height), Image.BILINEAR)
        new_img.save(os.path.join(outdir, os.path.basename(jpgfile)))
    except Exception as e:
        print(e)
for jpgfile in os.listdir('C:/Users/ASUS/Desktop/cat/暹罗猫'):
    print(jpgfile)
    convertjpg(jpgfile, "./Xianluo")

# 统一图片类型

def ranamesJPG(filepath, kind):     images = os.listdir(filepath)     for name in images:         os.rename(filepath+name, filepath+kind+'_'+name.split('.')[0]+'.jpg')         print(name)         print(name.split('.')[0]) ranamesJPG('C:/Users/ASUS/Desktop/cat/英国短毛猫/','3')

这里有必要说明为什么要修改文件名？

其实是这样的，因为训练集和测试集的图片一共有几百张，而我们训练时，不仅要传递图片，而且还要告诉卷积神经网络每一张图片对应的标签，如果手工添加标签的话，可想而知，会有很大的工作量。这里注明：0_xxx代表布偶猫、1_xxx代表孟买猫、2_xxx代表暹罗猫、3_xxx代表英国短毛猫。

2 训练模型与测试

import os
from PIL import Image
import numpy as np
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation, Flatten
from keras.optimizers import SGD, RMSprop, Adam
from keras.layers import Conv2D, MaxPooling2D

#--------------------------------------------------------------------------------------------

将训练集图片转换成数组

ima1 = os.listdir('./cat/train')
def read_image1(filename):
    img = Image.open('./cat/train/'+filename).convert('RGB')
    return np.array(img)

x_train = []

for i in ima1:
    x_train.append(read_image1(i))

x_train = np.array(x_train)

根据文件名提取标签

y_train = []
for filename in ima1:
    y_train.append(int(filename.split('_')[0]))

y_train = np.array(y_train)

—————————————————————————————–

将测试集图片转化成数组

ima2 = os.listdir('./cat/test')
def read_image2(filename):
    img = Image.open('./cat/test/'+filename).convert('RGB')
    return np.array(img)

x_test = []

for i in ima2:
    x_test.append(read_image2(i))

x_test = np.array(x_test)

根据文件名提取标签

y_test = []
for filename in ima2:
    y_test.append(int(filename.split('_')[0]))

y_test = np.array(y_test)
#-------------------------------------------------------------------------------------

将标签转换格式

y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)

将特征点从0255转换成01提高特征提取精度

x_train = x_train.astype(‘float32’)
x_test = x_test.astype(‘float32’)
x_train /= 255
x_test /= 255

搭建卷积神经网络

model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(100, 100, 3)))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(4, activation='softmax'))

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])

model.fit(x_train, y_train, batch_size=10, epochs=32)
model.save_weights('./cat/cat_weights.h5', overwrite=True)

score = model.evaluate(x_test, y_test, batch_size=10)
print(score)

注：需要安装h5py，用于保存和加载xx.h5类型的权重文件

直接右键run运行程序生成权重文件，用于以后的预测。

不一样的烟火

什么是SparseReward

这个一开始的暂时的小的reward 就叫 Sparse Reward

如何让agent在Sparse Reward 中拥有更好的学习表现？

1.“写完作业就给糖吃”

2.“兴趣是最好的老师 ” Curiosity Module

3.“制定学习计划” Curriculum Learning

4.阶层式强化学习 Hierarchical RL

西瓜书习题3.4(交叉验证法)

西瓜书习题3.4 (交叉验证法)：

1.数据集长啥样？

2.啥是十折交叉验证法？啥是留一法？

k折交叉验证法：

十折交叉验证法就是 k=10 的情况

留一法则是 k=总样本数 的情况，即每次迭代从总样本取一条数据做测试集，剩余的全做训练集

3.以上一顿分析猛如虎，是时候该撸码实现啦 qwq

在github上建图床

最近用hexo整了个博客，我现在的感受就是这也太tm折腾了。

现在来介绍一下如何直接在github上建图床

以上是图床的基本原理！！！

'pikachu'

西瓜书习题3.3(对率回归 LR)

西瓜书习题 3.3(对率回归 LR)

编程实现对率回归，并给出西瓜数据集上的结果

推导RL的过程，得到了梯度公式，接下来用梯度上升算法实现RL（还有一种是用牛顿法实现，以后有时间在补充吧qwq~）

卷积神经网络的搭建

将训练集图片转换成数组

根据文件名提取标签

—————————————————————————————–

将测试集图片转化成数组

根据文件名提取标签

将标签转换格式

将特征点从0255转换成01提高特征提取精度

搭建卷积神经网络

留一法则是 k=总样本数的情况，即每次迭代从总样本取一条数据做测试集，剩余的全做训练集