付威的网络博客

为了防止博客被爬，本站的所有文章的图片都添加水印。前几天刚刚学习完python，拿来练练手，确实有很多不熟悉的类库和代码，权当试试水了。。

#! /usr/bin/python
# coding:utf-8 
import os
from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
import random

def Watermark(fname, text):
    # 设置字体
    font = ImageFont.truetype("STLITI.TTF", 25)  # 不同的电脑可能不存在这里的字体，导致最后没有输出结果；如果你的电脑上没有这几种字体，请自行修改

    # 实例化图片对象
    imageFile = fname
    img = Image.open(imageFile).convert('RGBA')
    text_overlay=Image.new("RGBA",img.size,(255,255,255,0))
    draw = ImageDraw.Draw(text_overlay)

    t=max(text)
    t_len=len(t)

    for i in range(0, img.size[0], t_len*20+100):
        for j in range(0, img.size[1], t_len*20):
            draw.text((i, j), random.choice(text), font=font, fill=(0, 0, 0, 50))

    text_overlay = text_overlay.rotate(45)
    image_with_text = Image.alpha_composite(img, text_overlay)
    # 另存图片
    image_with_text.save("{}_marked.png".format(fname.split(".")[0]))



def drawText(path,text):
    if not os.path.exists(path):
        print("没有这个路径：",path)
    fileList= [os.path.join(fpathe,f) for fpathe,dirs,fs in os.walk(path) for f in fs if f.split(".")[1] in ["png","jpg"] and not f.split(".")[0][-6:]=="marked"]
    for img in fileList:
        Watermark(img,text)


if __name__ == '__main__':

    path="root"
    drawText(path,["text1","text2"])

本站的图片加水印对比效果：
{:height=”600px” width=”600px”}
{:height=”600px” width=”600px”}

正则化缓解过拟合

有时候发现，模型在训练数据集的准确率非常高，但很难预测新的数据，这样我们称为，模型存在了过拟合的现象。 正则化是缓解过拟合一种有效的方法.

正则化在损失函数中引入模型复杂度指标，利用给W加权值，弱化训练数据的噪声（一般不正则化b） ，具体公式如下:

其中，模型中所有参数的损失函数如：交叉熵，均方误差 。
用超参数REGULARIZER给出参数w在总loss中的比例，及正则化的权重 w是正则化的参数.

使用tensorflow表示：

1
2
3
4
5
6
7
8

loss(w)=tf.contrib.layers.l1_regularizer(REGULARIZER)(w) #w加和
loss(w)=tf.contrib.layers.l2_regularizer(REGULARIZER)(w) # w平方加和   

tf.add_to_collection('losses',tf.contrib.layers.l2_regularizer(regularizer)(w))    

loss=cem+tf.add_n(tf.get_collection('losses'))

我们生成几个随机点，然后利用生成分界线,代码如下：

#coding:utf-8
# 0.导入模块，生成模拟数据集
import tensorflow as tf 
import numpy as np
import matplotlib.pyplot as plt

BATCH_SIZE=30 
seed=2

# 基于seed产生随机数   
rdm=np.random.RandomState(seed)
# 随机数返回300行2列的矩阵，表示300组坐标点（x0，x1)作为输入数据集
X=rdm.randn(300,2)

#从X这个300行2列的矩阵中取出一行，判断如果两个坐标系的平方和小于2，给Y赋值1 其余赋值0. 

# 作为输入数据集的标签，
Y_=[int (x0*x0+x1*x1<2) for(x0,x1) in X]
# 遍历Y中的每个元素，1 赋值'red' 其余赋值'blue' ，这样可视化显示是人可以直观区分
Y_c=[['red' if y else 'blue'] for y in Y_]
# 对数据集X和标签Y进行shape整理，第一个元素为-1表示，随第二个参数计算得到，第二个元素表示多少列，把X整理为n行2列，把Y整理为n行1列
X=np.vstack(X).reshape(-1,2)
Y_=np.vstack(Y_).reshape(-1,1)  
print(X)
print(Y_)
print(Y_c)
#用plt.sctter画出数据集X各行中第0列元素和第1列元素的点即个行的（x0,x1)，用各行Y_c对应的值表示颜色（c是color的缩写）
plt.scatter(X[:,0],X[:,1],c=np.squeeze(Y_c))
plt.show()

x=tf.placeholder(tf.float32,shape=(None,2))
y_=tf.placeholder(tf.float32,shape=(None,1))



def get_weight(shape,regularizer):
    w=tf.Variable(tf.random_normal(shape),dtype=tf.float32)
    tf.add_to_collection("losses",tf.contrib.layers.l2_regularizer(regularizer)(w))
    return w

def get_bias(shape):
    b=tf.Variable(tf.constant(0.01,shape=shape))
    return b 


w1=get_weight([2,11],0.01)
b1=get_bias([11])
y1=tf.nn.relu(tf.matmul(x,w1)+b1)

w2=get_weight([11,1],0.01)
b2=get_bias([1])
y=tf.matmul(y1,w2)+b2

loss_mse=tf.reduce_mean(tf.square(y-y_))
loss_total=loss_mse+tf.add_n(tf.get_collection('losses'))

train_step=tf.train.AdamOptimizer(0.0001).minimize(loss_mse)

with tf.Session() as sess: 
    init_op=tf.global_variables_initializer()
    sess.run(init_op)

    STEPS=40000
    for i in range(STEPS):
        start=(i*BATCH_SIZE)%32
        end=start+BATCH_SIZE
        sess.run(train_step,feed_dict={
            x:X[start:end],y_:Y_[start:end]
        })
        if i%2000==0:
            loss_mse_v=sess.run(loss_mse,feed_dict={x:X,y_:Y_})
            print("After %d training steps,loss on all data is %s"%(i,loss_mse_v))

        xx,yy=np.mgrid[-3:3:0.1,-3:3:.01]

        grid=np.c_[xx.ravel(),yy.ravel()]

        probs=sess.run(y,feed_dict={x:grid})
        probs=probs.reshape(xx.shape)

    print("w1:",sess.run(w1))
    print("b1:",sess.run(b1))
    print("w2:",sess.run(w2))
    print("b2:",sess.run(b2))

plt.scatter(X[:,0],X[:,1],c=np.squeeze(Y_c))
plt.contour(xx,yy,probs,levels=[.5])
plt.show()

生成点的结果如下:

{:height=”600px” width=”600px”}

滑动平均

滑动平均，又叫影子值，记录了每个参数一段时间内过往值的平均，增加了模型的泛化性。

针对所有参数：w和b。（像是给参数加了影子，参数变化，影子缓慢追随）,具体的计算公式如下:

影子=衰减率*影子+(1-衰减率)* 参数

影子初值=参数初值

衰减率=$min\left({cases}MOVING\_AVERAGE\_DECAY, \frac{1+step}{10+step}\right)$

例如：

MOVING_AVERAGE_DECAY为0.99，参数w1为0，轮数global_step为0，w1的滑动平均值为0，参数w1更新为1.则：

w1滑动平均值=min(0.99,1/10)*0+(1-min(0.99,1/10))*1=0.9
轮数global_step为100是，参数w1更新为10，则：

w1滑动平均值=min(0.99,101/110)*0.9+(1-min(0.99,101/110))*10=0.826+0.818=1.644

学习率

学习率（learning_rate）是每次参数更新的幅度。

其中$W_{n+1}$时更新后的参数，$W_n$当前参数，▽是损失函数的梯度（导数）

例如：

损失函数$loss=(w+1)^2$ 梯度 $▽=\frac{\partial loss}{\partial w}=2w+2$

例如：参数w初始化为5，学习率为0.2，则：

1次 参数w：5 5-0.2*(2*5+2)=2.6
2次 参数w：2.6 2.6-0.2*(2*2.6+2)=1.16
3次 参数w：1.16 1.16-0.2*(2*1.16+2)=0.296
4次 参数w：0.296
…..

函数图像为:

{:height=”600px” width=”600px”}

根据图像我们可以看出在x=-1时，有最小值。

损失函数

在前面几个博客中说了一个学习模型，具体表现如下：

具体的计算公式：$Y=\sum_{i}^nX_iW_i$

曾经有人提出另一个神经元模型，多了激活函数和偏执项。

具体的计算公式：

其中f是激活函数,b是偏执项。

损失函数（loss）：预测值y’和已知答案y的差距

我们的优化目标就是把loss降低为最小。

反向传播

训练模型参数，在所有的参数上用梯度下降，是NN模型在训练数据上的损失函数最小。

1. 损失函数(loss)： 预测值(y)与已知答案(y’)的差距

2. 均方误差MSE： $MSE(y',y)=\sum_{i=0}^n(y-y')^2/n$

   使用tensorflow表示：
   loss=tf.reduce_mean(tf.square(y'-y))

3. 反向传播训练方法，以减小loss值为优化目标。 有以下几种方法：

1
2
3
4

train_step=tf.train.GradientDescentOptimizer(learnig_rate).minimize(loss) 
train_step=tf.train.MomentumOptimizer(learnig_rate,momentum).minimize(loss) 
train_step=tf.train.AdamOptimizer(learnig_rate).minimize(loss) 

其中leaning_rate代表学习率，决定每次更新的幅度。

实现代码

实现一个训练模型：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

#coding:utf-8
import tensorflow as tf
import numpy as np
BATCH_SIZE=8
seed=23455


#基于seed产生随机数
rng=np.random.RandomState(seed)
#随机数返回32行2列的矩阵，表示32组，体积和重量，作为输入的数据集
X=rng.rand(32,2)  

# 从X这个32x2的矩阵中，取出一行,判断如果和小于1 给Y复制1，如果不小于1 给Y赋值0
# 作为输入数据集的标签（正确答案）  

Y=[[int(x0+x1<1)] for(x0,x1) in X]

print("X:",X)
print("Y:",Y)

# 定义神经王珞丹额输入和输出，定义前向的传播过程

x=tf.placeholder(tf.float32,shape=(None,2))
y_=tf.placeholder(tf.float32,shape=(None,1))

w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))  

a=tf.matmul(x,w1)
y=tf.matmul(a,w2)

#定义损失函数 
loss=tf.reduce_mean(tf.square(y-y_))
train_step=tf.train.GradientDescentOptimizer(0.001).minimize(loss)
# train_step=tf.train.MomentumOptimizer(learnig_rate,momentum).minimize(loss) 
# train_step=tf.train.AdamOptimizer(learnig_rate).minimize(loss) 

# 生成会话，训练STEPS轮
with tf.Session() as sess: 
    init_op=tf.global_variables_initializer()
    sess.run(init_op)
    # 输出目前（未经训练）的参数值 
    print("w1:",sess.run(w1))
    print("w1:",sess.run(w2))
    print("\n")
    
    #训练模型
    STEPS=3000
    for i in range(STEPS):
        start=(i*BATCH_SIZE)%32
        end=start+BATCH_SIZE
        sess.run(train_step,feed_dict={
            x:X[start:end],y_:Y[start:end]
        })
        if i%500==0:
            total_loss=sess.run(loss,feed_dict={x:X,y_:Y})
            print("After %d training steps,loss on all data is %s"%(i,total_loss))
      
    print("w1:",sess.run(w1))
    print("w1:",sess.run(w2))
    print("\n")

输入参数

在上面一篇博客提到的一个简单的模型：

为了能够得到Y，需要准确的知道$w_1,w_2$的值，一般都是先随机给一个值，后面利用样本进行训练，得到准确的值。例如使用随机方法赋初值：

w=tf.Variable(tf.random_normal([2,3],stddev=2,mean=0,seed=1))

其中：random_normal代表随机正态分布，[2,3]产生2x3的矩阵，stddev=2代表标准差是2，mean=0均值为0，seed=1随机种子。(标准差，均值，随机种子可以不写)

除了random_normal方法外还有几个其他的生成函数：

truncated_normal：去掉过大偏离点的正态分布，如果生成的数据超过了平均值两个标准差，数据将重新生成。

random_uniform：平均分布

tf.zeros:生成全0数组，tf.zeros([3,2],int32) 生成[[0,0],[0,0],[0,0]]
tf.ones:生成全1数组，tf.zeros([3,2],int32) 生成[[1,1],[1,1],[1,1]]
tf.fill:全定值数组，tf.zeros([3,2],6) 生成[[6,6],[6,6],[6,6]]
tf.constant:直接给值，tf.constant([3,2,1]) 生成[3,2,1]

几个概念

TensorFlow是一个基于数据流编程（dataflow programming）的符号数学系统，被广泛应用于各类机器学习（machine learning）算法的编程实现，由谷歌公司开发并开源免费使用。

在接触到的智能机器中，我们都需要先输入一段抽象的数据（语音，图片等），然后机器识别结果，输出我们想要的内容。

在机器诞生的前期，需要对机器进行训练和学习，使他有能力去认识识别的样本，然后由样本来预测其他的结果。

在tensorflow中使用张量代表数据（可以简单理解为参数）,使用计算图来搭建神经网络，使用会话执行计算图，优化对应的权重。

首先我们先介绍张量：

• 张量 多维数组和列表。对于不同维数的张量有不同的名称和表示方法：

  标量: 一个数字，比如：1,2,3
  向量: 一个数组，[1,2,3]
  矩阵: 二位数组，[[1,2],[1,3],[2,3]]
  张量: 多维数组

tensorflow的数据的类型很多，与日常编程的数据类型也有点相似之处，先不一一介绍，先看看怎么使用tensorflow（使用pip命令安装对应的依赖模块）

1
2
3
4
5
6
7

import tensorflow as ts

a=ts.constant([1.0,2.0])# 定义常数
b=ts.constant([3.0,4.0])

result=a+b
print(result)

打印结果:Tensor("add:0", shape=(2,), dtype=float32)

配置tab为4个空格和显示行号：

vim ~/.vimrc 写入：
set ts=4
set nu

保存！

海龟绘图

海龟绘图画图比较简单，主要使用python的turtle模块， 就是通过编程指挥一个小海龟在屏幕上前进和左转右转。

forward: 向前走,可以指定一个距离
left：左转，指定一个角度
right：右转，指定一个角度
circle:画圆
reset：重置

根据上面的说明我们可以简单的绘制一个五角星：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import turtle
t = turtle.Pen()
for x in range(5):
    t.forward(100)
    t.right(145)
turtle.done()
```  

![海龟绘图](/img/assets/42/01_marked.png)      

绘制螺旋阵：  

``` python
import turtle
import time
turtle.pensize(2)
turtle.bgcolor("black")
turtle.tracer(False)
turtle.color("white")
for x in range(400):
    turtle.forward(2*x)
    turtle.left(60)
turtle.tracer(True)
turtle.done()

更多的方法的说明可以看官方教程