python机器学习之神经网络(二)


Posted in Python onDecember 20, 2017

由于Rosenblatt感知器的局限性,对于非线性分类的效果不理想。为了对线性分类无法区分的数据进行分类,需要构建多层感知器结构对数据进行分类,多层感知器结构如下:

python机器学习之神经网络(二)

该网络由输入层,隐藏层,和输出层构成,能表示种类繁多的非线性曲面,每一个隐藏层都有一个激活函数,将该单元的输入数据与权值相乘后得到的值(即诱导局部域)经过激活函数,激活函数的输出值作为该单元的输出,激活函数类似与硬限幅函数,但硬限幅函数在阈值处是不可导的,而激活函数处处可导。本次程序中使用的激活函数是tanh函数,公式如下:

python机器学习之神经网络(二)

tanh函数的图像如下:

python机器学习之神经网络(二)

程序中具体的tanh函数形式如下:

python机器学习之神经网络(二)

python机器学习之神经网络(二)就是神经元j的诱导局部域

它的局部梯度分两种情况:

(1)神经元j没有位于隐藏层:

python机器学习之神经网络(二)

(2)神经元j位于隐藏层:

python机器学习之神经网络(二)

其中k是单元j后面相连的所有的单元。

局部梯度得到之后,根据增量梯度下降法的权值更新法则

python机器学习之神经网络(二)

即可得到下一次的权值w,经过若干次迭代,设定误差条件,即可找到权值空间的最小值。

python程序如下,为了能够可视化,训练数据采用二维数据,每一个隐藏层有8个节点,设置了7个隐藏层,一个输出层,输出层有2个单元:

import numpy as np 
import random 
import copy 
import matplotlib.pyplot as plt 
 
 
#x和d样本初始化 
train_x = [[1,6],[3,12],[3,9],[3,21],[2,16],[3,15]] 
d =[[1,0],[1,0],[0,1],[0,1],[1,0],[0,1]] 
warray_txn=len(train_x[0]) 
warray_n=warray_txn*4 
 
#基本参数初始化 
oldmse=10**100 
fh=1 
maxtrycount=500 
mycount=0.0 
if maxtrycount>=20: 
    r=maxtrycount/5 
else: 
    r=maxtrycount/2 
#sigmoid函数 
ann_sigfun=None 
ann_delta_sigfun=None 
#总层数初始化,比非线性导数多一层线性层 
alllevel_count=warray_txn*4 
# 非线性层数初始化 
hidelevel_count=alllevel_count-1 
 
#学习率参数  
learn_r0=0.002  
learn_r=learn_r0    
#动量参数 
train_a0=learn_r0*1.2 
train_a=train_a0 
expect_e=0.05 
#对输入数据进行预处理 
ann_max=[] 
for m_ani in xrange(0,warray_txn):       #找出训练数据中每一项的最大值 
  temp_x=np.array(train_x) 
  ann_max.append(np.max(temp_x[:,m_ani])) 
ann_max=np.array(ann_max) 
 
def getnowsx(mysx,in_w): 
    '''''生成本次的扩维输入数据 ''' 
    '''''mysx==>输入数据,in_w==>权值矩阵,每一列为一个神经元的权值向量''' 
    global warray_n 
    mysx=np.array(mysx) 
    x_end=[]   
    for i in xrange(0,warray_n): 
        x_end.append(np.dot(mysx,in_w[:,i])) 
    return x_end 
 
def get_inlw(my_train_max,w_count,myin_x): 
    '''''找出权值矩阵均值接近0,输出结果方差接近1的权值矩阵''' 
    #对随机生成的多个权值进行优化选择,选择最优的权值 
    global warray_txn 
    global warray_n 
    mylw=[] 
    y_in=[] 
    #生成测试权值 
    mylw=np.random.rand(w_count,warray_txn,warray_n) 
    for ii in xrange (0,warray_txn): 
      mylw[:,ii,:]=mylw[:,ii,:]*1/float(my_train_max[ii])-1/float(my_train_max[ii])*0.5 
 
    #计算输出 
    for i in xrange(0,w_count): 
        y_in.append([]) 
        for xj in xrange(0,len(myin_x)): 
            y_in[i].append(getnowsx(myin_x[xj],mylw[i])) 
    #计算均方差 
    mymin=10**5 
    mychoice=0 
    for i in xrange(0,w_count): 
        myvar=np.var(y_in[i]) 
        if abs(myvar-1)<mymin: 
            mymin=abs(myvar-1) 
            mychoice=i 
    #返回数据整理的权值矩阵 
    return mylw[mychoice] 
mylnww=get_inlw(ann_max,300,train_x) 
 
def get_inputx(mytrain_x,myin_w): 
    '''''将训练数据经过权值矩阵,形成扩维数据''' 
    end_trainx=[] 
    for i in xrange(0,len(mytrain_x)): 
        end_trainx.append(getnowsx(mytrain_x[i],myin_w))     
    return end_trainx 
     
x=get_inputx(train_x,mylnww)#用于输入的扩维数据 
#对测试数据进行扩维 
def get_siminx(sim_x): 
    global mylnww 
    myxx=np.array(sim_x) 
    return get_inputx(myxx,mylnww) 
#计算一层的初始化权值矩阵 
def getlevelw(myin_x,wo_n,wi_n,w_count): 
    mylw=[] 
    y_in=[] 
    #生成测试权值 
    mylw=np.random.rand(w_count,wi_n,wo_n) 
    mylw=mylw*2.-1 
 
    #计算输出 
    for i in xrange(0,w_count): 
        y_in.append([]) 
        for xj in xrange(0,len(myin_x)): 
          x_end=[]   
          for myii in xrange(0,wo_n): 
            x_end.append(np.dot(myin_x[xj],mylw[i,:,myii])) 
          y_in[i].append(x_end) 
    #计算均方差 
    mymin=10**3 
    mychoice=0 
    for i in xrange(0,w_count): 
        myvar=np.var(y_in[i]) 
        if abs(myvar-1)<mymin: 
            mymin=abs(myvar-1) 
            mychoice=i 
    #返回数据整理的权值矩阵 
    csmylw=mylw[mychoice] 
    return csmylw,y_in[mychoice]     
ann_w=[] 
def init_annw(): 
  global x 
  global hidelevel_count 
  global warray_n 
  global d 
  global ann_w 
  ann_w=[] 
  
  lwyii=np.array(x) 
  #初始化每层的w矩阵 
  for myn in xrange(0,hidelevel_count):         
    #层数 
    ann_w.append([])  
    if myn==hidelevel_count-1: 
      for iii in xrange(0,warray_n): 
        ann_w[myn].append([]) 
        for jjj in xrange(0,warray_n): 
                ann_w[myn][iii].append(0.0) 
    elif myn==hidelevel_count-2:       
      templw,lwyii=getlevelw(lwyii,len(d[0]),warray_n,200) 
      for xii in xrange(0,warray_n): 
        ann_w[myn].append([]) 
        for xjj in xrange(0,len(d[0])):  
          ann_w[myn][xii].append(templw[xii,xjj])  
        for xjj in xrange(len(d[0]),warray_n): 
          ann_w[myn][xii].append(0.0) 
    else:  
      templw,lwyii=getlevelw(lwyii,warray_n,warray_n,200) 
      for xii in xrange(0,warray_n): 
        ann_w[myn].append([]) 
        for xjj in xrange(0,warray_n):  
          ann_w[myn][xii].append(templw[xii,xjj])         
  ann_w=np.array(ann_w) 
 
def generate_lw(trycount): 
  global ann_w 
  print u"产生权值初始矩阵",        
  meanmin=1  
  myann_w=ann_w     
  alltry=30 
  tryc=0 
  while tryc<alltry: 
    for i_i in range(trycount): 
      print ".", 
      init_annw() 
      if abs(np.mean(np.array(ann_w)))<meanmin: 
        meanmin=abs(np.mean(np.array(ann_w))) 
        myann_w=ann_w 
    tryc+=1 
    if abs(np.mean(np.array(myann_w)))<0.008:break 
     
  ann_w=myann_w 
  print 
  print u"权值矩阵平均:%f"%(np.mean(np.array(ann_w))) 
  print u"权值矩阵方差:%f"%(np.var(np.array(ann_w)))    
generate_lw(15) 
 
#前次训练的权值矩阵 
ann_oldw=copy.deepcopy(ann_w) 
#梯度初始化 
#输入层即第一层隐藏层不需要,所以第一层的空间无用 
ann_delta=[] 
for i in xrange(0,hidelevel_count): 
    ann_delta.append([])    
    for j in xrange(0,warray_n): 
        ann_delta[i].append(0.0) 
ann_delta=np.array(ann_delta) 
 
#输出矩阵yi初始化 
ann_yi=[] 
for i in xrange(0,alllevel_count): 
    #第一维是层数,从0开始 
    ann_yi.append([]) 
    for j in xrange(0,warray_n): 
        #第二维是神经元 
        ann_yi[i].append(0.0) 
ann_yi=np.array(ann_yi)    
 
 
    
#输出层函数     
def o_func(myy): 
    myresult=[] 
    mymean=np.mean(myy) 
    for i in xrange(0,len(myy)): 
        if myy[i]>=mymean: 
            myresult.append(1.0) 
        else: 
            myresult.append(0.0) 
    return np.array(myresult) 
     
def get_e(myd,myo): 
    return np.array(myd-myo) 
def ann_atanh(myv): 
    atanh_a=1.7159#>0 
    atanh_b=2/float(3)#>0 
    temp_rs=atanh_a*np.tanh(atanh_b*myv) 
    return temp_rs 
def ann_delta_atanh(myy,myd,nowlevel,level,n,mydelta,myw): 
  anndelta=[] 
  atanh_a=1.7159#>0 
  atanh_b=2/float(3)#>0  
  if nowlevel==level: 
    #输出层 
    anndelta=(float(atanh_b)/atanh_a)*(myd-myy)*(atanh_a-myy)*(atanh_a+myy) 
  else: 
    #隐藏层 
    anndelta=(float(atanh_b)/atanh_a)*(atanh_a-myy)*(atanh_a+myy)       
    temp_rs=[] 
    for j in xrange(0,n): 
        temp_rs.append(sum(myw[j]*mydelta))         
    anndelta=anndelta*temp_rs     
  return anndelta 
 
def sample_train(myx,myd,n,sigmoid_func,delta_sigfun): 
    '''''一个样本的前向和后向计算''' 
    global ann_yi 
    global ann_delta 
    global ann_w 
    global ann_wj0 
    global ann_y0 
    global hidelevel_count 
    global alllevel_count 
    global learn_r 
    global train_a 
    global ann_oldw 
    level=hidelevel_count 
    allevel=alllevel_count 
     
    #清空yi输出信号数组     
    hidelevel=hidelevel_count 
    alllevel=alllevel_count 
    for i in xrange(0,alllevel): 
        #第一维是层数,从0开始 
        for j in xrange(0,n): 
            #第二维是神经元 
            ann_yi[i][j]=0.0 
    ann_yi=np.array(ann_yi) 
    yi=ann_yi 
 
    #清空delta矩阵 
    for i in xrange(0,hidelevel-1):   
        for j in xrange(0,n): 
            ann_delta[i][j]=0.0 
    delta=ann_delta    
    #保留W的拷贝,以便下一次迭代 
    ann_oldw=copy.deepcopy(ann_w) 
    oldw=ann_oldw 
    #前向计算 
 
    #对输入变量进行预处理        
    myo=np.array([]) 
    for nowlevel in xrange(0,alllevel): 
        #一层层向前计算 
        #计算诱导局部域 
        my_y=[] 
        myy=yi[nowlevel-1]  
        myw=ann_w[nowlevel-1]         
        if nowlevel==0: 
            #第一层隐藏层 
            my_y=myx 
            yi[nowlevel]=my_y             
        elif nowlevel==(alllevel-1): 
            #输出层 
            my_y=o_func(yi[nowlevel-1,:len(myd)]) 
            yi[nowlevel,:len(myd)]=my_y 
        elif nowlevel==(hidelevel-1): 
            #最后一层输出层 
            for i in xrange(0,len(myd)): 
                temp_y=sigmoid_func(np.dot(myw[:,i],myy)) 
                my_y.append(temp_y)             
            yi[nowlevel,:len(myd)]=my_y  
        else: 
            #中间隐藏层 
            for i in xrange(0,len(myy)): 
                temp_y=sigmoid_func(np.dot(myw[:,i],myy)) 
                my_y.append(temp_y) 
            yi[nowlevel]=my_y 
 
    
    #计算误差与均方误差 
    myo=yi[hidelevel-1][:len(myd)] 
    myo_end=yi[alllevel-1][:len(myd)] 
    mymse=get_e(myd,myo_end) 
  
    #反向计算 
    #输入层不需要计算delta,输出层不需要计算W 
 
 
    #计算delta 
    for nowlevel in xrange(level-1,0,-1): 
        if nowlevel==level-1: 
            mydelta=delta[nowlevel] 
            my_n=len(myd) 
        else: 
            mydelta=delta[nowlevel+1] 
            my_n=n 
        myw=ann_w[nowlevel]         
        if nowlevel==level-1: 
            #输出层 
            mydelta=delta_sigfun(myo,myd,None,None,None,None,None) 
##            mydelta=mymse*myo 
        elif nowlevel==level-2: 
            #输出隐藏层的前一层,因为输出结果和前一层隐藏层的神经元数目可能存在不一致 
            #所以单独处理,传相当于输出隐藏层的神经元数目的数据 
            mydelta=delta_sigfun(yi[nowlevel],myd,nowlevel,level-1,my_n,mydelta[:len(myd)],myw[:,:len(myd)]) 
        else: 
            mydelta=delta_sigfun(yi[nowlevel],myd,nowlevel,level-1,my_n,mydelta,myw) 
             
        delta[nowlevel][:my_n]=mydelta 
    #计算与更新权值W  
    for nowlevel in xrange(level-1,0,-1): 
        #每个层的权值不一样 
        if nowlevel==level-1: 
            #输出层 
            my_n=len(myd) 
            mylearn_r=learn_r*0.8 
            mytrain_a=train_a*1.6 
        elif nowlevel==1: 
            #输入层 
            my_n=len(myd) 
            mylearn_r=learn_r*0.9 
            mytrain_a=train_a*0.8             
        else: 
            #其它层 
            my_n=n 
            mylearn_r=learn_r 
            mytrain_a=train_a 
 
        pre_level_myy=yi[nowlevel-1] 
        pretrain_myww=oldw[nowlevel-1] 
        pretrain_myw=pretrain_myww[:,:my_n] 
 
        #第二个调整参数 
        temp_i=[]         
         
        for i in xrange(0,n): 
            temp_i.append([]) 
            for jj in xrange(0,my_n): 
                temp_i[i].append(mylearn_r*delta[nowlevel,jj]*pre_level_myy[i]) 
        temp_rs2=np.array(temp_i) 
        temp_rs1=mytrain_a*pretrain_myw 
        #总调整参数 
        temp_change=temp_rs1+temp_rs2         
        my_ww=ann_w[nowlevel-1]         
        my_ww[:,:my_n]+=temp_change 
 
    return mymse 
 
def train_update(level,nowtraincount,sigmoid_func,delta_sigfun): 
    '''''一次读取所有样本,然后迭代一次进行训练''' 
    #打乱样本顺序 
    global learn_r 
    global train_a 
    global train_a0 
    global learn_r0 
    global r 
    global x 
    global d 
    global maxtrycount 
    global oldmse 
    x_n=len(x) 
    ids=range(0,x_n) 
    train_ids=[] 
    sample_x=[] 
    sample_d=[] 
 
    while len(ids)>0: 
        myxz=random.randint(0,len(ids)-1) 
        train_ids.append(ids[myxz]) 
        del ids[myxz] 
             
    for i in xrange(0,len(train_ids)): 
        sample_x.append(x[train_ids[i]]) 
        sample_d.append(d[train_ids[i]]) 
    sample_x=np.array(sample_x) 
    sample_d=np.array(sample_d) 
 
         
    #读入x的每个样本,进行训练     
    totalmse=0.0 
    mymse=float(10**-10)    
    for i in xrange(0,x_n): 
         
        mymse=sample_train(sample_x[i],sample_d[i],warray_n,sigmoid_func,delta_sigfun) 
        totalmse+=sum(mymse*mymse) 
    totalmse=np.sqrt(totalmse/float(x_n)) 
    print u"误差为:%f" %(totalmse) 
    nowtraincount[0]+=1 
    learn_r=learn_r0/(1+float(nowtraincount[0])/r) 
    train_a=train_a0/(1+float(nowtraincount[0])/r) 
    if nowtraincount[0]>=maxtrycount: 
        return False,True,totalmse          
    elif totalmse<expect_e: 
    #(totalmse-oldmse)/oldmse>0.1 and (totalmse-oldmse)/oldmse<1: 
        print u"训练成功,正在进行检验" 
        totalmse=0.0 
        for i in xrange(0,x_n): 
            mytemper=(sample_d[i]-simulate(sample_x[i],sigmoid_func,delta_sigfun))             
            totalmse+=sum(mytemper*mytemper) 
        totalmse=np.sqrt(totalmse/float(x_n)) 
        if totalmse<expect_e: 
            return False,False,totalmse 
    oldmse=totalmse 
    return True,False,totalmse 
                 
def train(): 
    '''''训练样本,多次迭代''' 
    global hidelevel_count 
    nowtraincount=[] 
    nowtraincount.append(0) 
    #sigmoid函数指定 
    delta_sigfun=ann_delta_atanh 
    sigmoid_func=ann_atanh 
     
    tryerr=0     
    while True: 
        print u"-------开始第%d次训练---------"%(nowtraincount[0]+1), 
        iscontinue,iscountout,mymse=train_update(hidelevel_count,nowtraincount,sigmoid_func,delta_sigfun) 
        if not iscontinue: 
            if iscountout : 
                print u"训练次数已到,误差为:%f"%mymse  
                tryerr+=1  
                if tryerr>3: 
                  break 
                else: 
                  print u"训练失败,重新尝试第%d次"%tryerr 
                  nowtraincount[0]=0 
                  generate_lw(15+tryerr*2)                                                       
            else: 
                print u"训练成功,误差为:%f"%mymse                
                break 
        
def simulate(myx,sigmoid_func,delta_sigfun): 
    '''''一个样本的仿真计算''' 
    print u"仿真计算中"     
    global ann_yi 
    global ann_w 
    global ann_wj0 
    global ann_y0 
    global hidelevel_count 
    global alllevel_count 
    global d 
    myd=d[0] 
 
    myx=np.array(myx) 
    n=len(myx) 
 
    level=hidelevel_count 
    allevel=alllevel_count 
     
    #清空yi输出信号数组     
    hidelevel=hidelevel_count 
    alllevel=alllevel_count 
    for i in xrange(0,alllevel): 
        #第一维是层数,从0开始 
        for j in xrange(0,n): 
            #第二维是神经元 
            ann_yi[i][j]=0.0 
    ann_yi=np.array(ann_yi) 
    yi=ann_yi 
 
    #前向计算 
    myo=np.array([]) 
    myy=np.array([]) 
    for nowlevel in xrange(0,alllevel): 
        #一层层向前计算 
        #计算诱导局部域 
        my_y=[] 
        myy=yi[nowlevel-1] 
        myw=ann_w[nowlevel-1]         
        if nowlevel==0: 
            #第一层隐藏层 
            my_y=myx 
            yi[nowlevel]=my_y             
        elif nowlevel==(alllevel-1): 
            #线性输出层,使用线性激活 
            my_y=o_func(yi[nowlevel-1,:len(myd)]) 
            yi[nowlevel,:len(myd)]=my_y             
        elif nowlevel==(hidelevel-1): 
            #最后一层隐藏输出层,使用线性激活 
            for i in xrange(0,len(myd)): 
                temp_y=sigmoid_func(np.dot(myw[:,i],myy)) 
                my_y.append(temp_y)               
            yi[nowlevel,:len(myd)]=my_y  
        else: 
            #中间隐藏层 
            #中间隐藏层需要加上偏置 
            for i in xrange(0,len(myy)): 
                temp_y=sigmoid_func(np.dot(myw[:,i],myy)) 
                my_y.append(temp_y) 
            yi[nowlevel]=my_y 
 
    return yi[alllevel-1,:len(myd)]     
train() 
 
delta_sigfun=ann_delta_atanh 
sigmoid_func=ann_atanh 
 
 
for xn in xrange(0,len(x)): 
    if simulate(x[xn],sigmoid_func,delta_sigfun)[0]>0: 
        plt.plot(train_x[xn][0],train_x[xn][1],"bo") 
    else: 
        plt.plot(train_x[xn][0],train_x[xn][1],"b*") 
 
 
              
temp_x=np.random.rand(20)*10 
temp_y=np.random.rand(20)*20+temp_x 
myx=temp_x 
myy=temp_y 
plt.subplot(111) 
x_max=np.max(myx)+5 
x_min=np.min(myx)-5 
y_max=np.max(myy)+5 
y_min=np.min(myy)-5 
plt.xlim(x_min,x_max) 
plt.ylim(y_min,y_max) 
for i in xrange(0,len(myx)): 
    test=get_siminx([[myx[i],myy[i]]]) 
    if simulate(test,sigmoid_func,delta_sigfun)[0]>0:       
        plt.plot(myx[i],myy[i],"ro") 
    else: 
        plt.plot(myx[i],myy[i],"r*")  
 
plt.show()

python机器学习之神经网络(二)

图中蓝色是训练数据,红色是测试数据,圈圈代表类型[1,0],星星代表类型[0,1]。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持三水点靠木。

Python 相关文章推荐
Python中的数学运算操作符使用进阶
Jun 20 Python
Python3 XML 获取雅虎天气的实现方法
Feb 01 Python
Python使用googletrans报错的解决方法
Sep 25 Python
python 利用for循环 保存多个图像或者文件的实例
Nov 09 Python
python查询文件夹下excel的sheet名代码实例
Apr 02 Python
Python字符串内置函数功能与用法总结
Apr 16 Python
Python3将数据保存为txt文件的方法
Sep 12 Python
基于Pycharm加载多个项目过程图解
Jan 19 Python
Python 实现黑客帝国中的字符雨的示例代码
Feb 20 Python
Python线程协作threading.Condition实现过程解析
Mar 12 Python
python框架flask入门之路由及简单实现方法
Jun 07 Python
Python将list元素转存为CSV文件的实现
Nov 16 Python
PyCharm 常用快捷键和设置方法
Dec 20 #Python
python机器学习之神经网络(一)
Dec 20 #Python
使用python实现ANN
Dec 20 #Python
python 计算数组中每个数字出现多少次--“Bucket”桶的思想
Dec 19 #Python
浅谈Python实现贪心算法与活动安排问题
Dec 19 #Python
Python实现感知器模型、两层神经网络
Dec 19 #Python
python实现感知器
Dec 19 #Python
You might like
用php解析html的实现代码
2011/08/08 PHP
ThinkPHP简单使用memcache缓存的方法
2016/11/15 PHP
PHP实现网站应用微信登录功能详解
2019/04/11 PHP
浅谈laravel框架sql中groupBy之后排序的问题
2019/10/17 PHP
获取当前网页document.url location.href区别总结
2008/05/10 Javascript
Javascript 篱式条件判断
2008/08/22 Javascript
让复选框只能选择一项的方法
2013/10/08 Javascript
封装好的一个万能检测表单的方法
2015/01/21 Javascript
JavaScript SweetAlert插件实现超酷消息警告框
2016/01/28 Javascript
Javascript 跨域知识详细介绍
2016/10/30 Javascript
基于jquery二维码生成插件qrcode
2017/01/07 Javascript
jquery Easyui Datagrid实现批量操作(编辑,删除,添加)
2017/02/20 Javascript
详解Vue学习笔记入门篇之组件的内容分发(slot)
2017/07/17 Javascript
浅谈Webpack打包优化技巧
2018/06/12 Javascript
javascript面向对象程序设计实践常用知识点总结
2019/07/29 Javascript
layer弹出层自定义提交取消按钮的例子
2019/09/10 Javascript
使用Layui搭建后台管理界面的操作方法
2019/09/20 Javascript
vue resource发送请求的几种方式
2019/09/30 Javascript
[33:39]DOTA2上海特级锦标赛C组小组赛#2 LGD VS Newbee第二局
2016/02/27 DOTA
Python中使用pprint函数进行格式化输出的教程
2015/04/07 Python
python如何使用unittest测试接口
2018/04/04 Python
Python(TensorFlow框架)实现手写数字识别系统的方法
2018/05/29 Python
利用ctypes获取numpy数组的指针方法
2019/02/12 Python
python可视化text()函数使用详解
2020/02/11 Python
Python单链表原理与实现方法详解
2020/02/22 Python
python pyqtgraph 保存图片到本地的实例
2020/03/14 Python
python要安装在哪个盘
2020/06/15 Python
使用Python提取文本中含有特定字符串的方法示例
2020/12/09 Python
Feelunique美国:欧洲大型的在线美妆零售电商
2018/11/04 全球购物
智能钱包:Ekster
2019/11/21 全球购物
《独坐敬亭山》教学反思
2014/04/08 职场文书
庆祝教师节活动总结
2015/03/23 职场文书
教师节主题班会教案
2015/08/17 职场文书
导游词之太湖
2019/10/08 职场文书
Python中22个万用公式的小结
2021/07/21 Python
Pygame游戏开发之太空射击实战敌人精灵篇
2022/08/05 Python