我们专注攀枝花网站设计 攀枝花网站制作 攀枝花网站建设
成都网站建设公司服务热线:400-028-6601

网站建设知识

十年网站开发经验 + 多家企业客户 + 靠谱的建站团队

量身定制 + 运营维护+专业推广+无忧售后,网站问题一站解决

python中lti函数 python__lt__函数

信号与系统中LTI系统的特点是什么?

信号与系统中LTI系统的特点是齐次性、叠加性、线性、时不变性、微分性和积分性。

奉新网站制作公司哪家好,找创新互联建站!从网页设计、网站建设、微信开发、APP开发、成都响应式网站建设公司等网站项目制作,到程序开发,运营维护。创新互联建站2013年至今到现在10年的时间,我们拥有了丰富的建站经验和运维经验,来保证我们的工作的顺利进行。专注于网站建设就选创新互联建站

线性时不变系统:既满足叠加原理又具有时不变特性,它可以用单位脉冲响应来表示。单位脉冲响应是输入端为单位脉冲序列时的系统输出,一般表示为h(n),即h(n)=T[δ(n)]。

任一输入序列x(n)的响应y(n)=T[x(n)]=T[ δ(n-k)];由于系统是线性的,所以上式可以写成y(n)=T[δ(n-k)];又由于系统是时不变的,即有T[δ(n-k)]=h(n-k)。

从而得y(n)=h(n-k)=x(n)*h(n);这个公式称为线性卷积,用“*”表示。

扩展资料

LTI系统的理论的基本结论是任何LTI系统都可以完全用一个单一方程来表示,称为系统的冲激响应。系统的输出可以简单表示为输入信号与系统的冲激响应的卷积。这种分析方法通常称为时域观点。相同的结果对于离散时间线性移位不变系统也成立,其中信号为离散时间取样信号,并且卷积对序列定义。

同理,任何LTI系统的特征可由频域的系统传递函数刻画,它是系统冲激响应的拉普拉斯变换(在离散时间系统的情况下为Z变换)。由于这些变换的性质,该系统在频域的输出是传递函数与输入的变换的乘积。换句话说,时域中的卷积相当于频域中的乘法。

参考资料来源:百度百科-线性时不变系统理论

参考资料来源:百度百科-线性时不变系统

如何利用Python做简单的验证码识别

先是获取验证码样本。。。我存了大概500个。

用dia测了测每个字之间的间距,直接用PIL开始切。

from PIL import Image

for j in range(0,500):

f=Image.open("../test{}.jpg".format(j))

for i in range(0,4):

f.crop((20+20*i,0,40+20*i,40)).save("test{0}-{1}.jpg".format(j,i+1))

上面一段脚本的意思是把jpg切成四个小块然后保存

之后就是二值化啦。

def TotallyShit(im):

x,y=im.size

mmltilist=list()

for i in range(x):

for j in range(y):

if im.getpixel((i,j))200:

mmltilist.append(1)

else:

mmltilist.append(0)

return mmltilist

咳咳,不要在意函数的名字。上面的一段代码的意思是遍历图片的每个像素点,颜色数值小于200的用1表示,其他的用0表示。

其中的im代表的是Image.open()类型。

切好的图片长这样的。

只能说这样切的图片还是很粗糙,很僵硬。

下面就是分类啦。

把0-9,“+”,”-“的图片挑好并放在不同的文件夹里面,这里就是纯体力活了。

再之后就是模型建立了。

这里我试了自己写的还有sklearn svm和sklearn neural_network。发现最后一个的识别正确率高的多。不知道是不是我样本问题QAQ。

下面是模型建立的代码

from sklearn.neural_network import MLPClassifier

import numpy as np

def clf():

clf=MLPClassifier()

mmltilist=list()

X=list()

for i in range(0,12):

for j in os.listdir("douplings/douplings-{}".format(i)):

mmltilist.append(TotallyShit(Image.open("douplings/douplings-{0}/{1}".format(i,j)).convert("L")))

X.append(i)

clf.fit(mmltilist,X)

return clf

大概的意思是从图片源中读取图片和label然后放到模型中去跑吧。

之后便是图像匹配啦。

def get_captcha(self):

with open("test.jpg","wb") as f:

f.write(self.session.get(self.live_captcha_url).content)

gim=Image.open("test.jpg").convert("L")

recognize_list=list()

for i in range(0,4):

part=TotallyShit(gim.crop((20+20*i,0,40+20*i,40)))

np_part_array=np.array(part).reshape(1,-1)

predict_num=int(self.clf.predict(np_part_array)[0])

if predict_num==11:

recognize_list.append("+")

elif predict_num==10:

recognize_list.append("-")

else:

recognize_list.append(str(predict_num))

return ''.join(recognize_list)

最后eval一下识别出来的字符串就得出结果了。。

顺便提一句现在的bilibili登陆改成rsa加密了,麻蛋,以前的脚本全部作废,心好痛。

登陆的代码。

import time

import requests

import rsa

r=requests.session()

data=r.get("act=getkey_="+str(int(time.time()*1000))).json()

pub_key=rsa.PublicKey.load_pkcs1_openssl_pem(data['key'])

payload = {

'keep': 1,

'captcha': '',

'userid': "youruserid",

'pwd': b64encode(rsa.encrypt((data['hash'] +"yourpassword").encode(), pub_key)).decode(),

}

r.post("",data=payload)

怎样用python构建一个卷积神经网络模型

上周末利用python简单实现了一个卷积神经网络,只包含一个卷积层和一个maxpooling层,pooling层后面的多层神经网络采用了softmax形式的输出。实验输入仍然采用MNIST图像使用10个feature map时,卷积和pooling的结果分别如下所示。

部分源码如下:

[python] view plain copy

#coding=utf-8

'''''

Created on 2014年11月30日

@author: Wangliaofan

'''

import numpy

import struct

import matplotlib.pyplot as plt

import math

import random

import copy

#test

from BasicMultilayerNeuralNetwork import BMNN2

def sigmoid(inX):

if 1.0+numpy.exp(-inX)== 0.0:

return 999999999.999999999

return 1.0/(1.0+numpy.exp(-inX))

def difsigmoid(inX):

return sigmoid(inX)*(1.0-sigmoid(inX))

def tangenth(inX):

return (1.0*math.exp(inX)-1.0*math.exp(-inX))/(1.0*math.exp(inX)+1.0*math.exp(-inX))

def cnn_conv(in_image, filter_map,B,type_func='sigmoid'):

#in_image[num,feature map,row,col]=in_image[Irow,Icol]

#features map[k filter,row,col]

#type_func['sigmoid','tangenth']

#out_feature[k filter,Irow-row+1,Icol-col+1]

shape_image=numpy.shape(in_image)#[row,col]

#print "shape_image",shape_image

shape_filter=numpy.shape(filter_map)#[k filter,row,col]

if shape_filter[1]shape_image[0] or shape_filter[2]shape_image[1]:

raise Exception

shape_out=(shape_filter[0],shape_image[0]-shape_filter[1]+1,shape_image[1]-shape_filter[2]+1)

out_feature=numpy.zeros(shape_out)

k,m,n=numpy.shape(out_feature)

for k_idx in range(0,k):

#rotate 180 to calculate conv

c_filter=numpy.rot90(filter_map[k_idx,:,:], 2)

for r_idx in range(0,m):

for c_idx in range(0,n):

#conv_temp=numpy.zeros((shape_filter[1],shape_filter[2]))

conv_temp=numpy.dot(in_image[r_idx:r_idx+shape_filter[1],c_idx:c_idx+shape_filter[2]],c_filter)

sum_temp=numpy.sum(conv_temp)

if type_func=='sigmoid':

out_feature[k_idx,r_idx,c_idx]=sigmoid(sum_temp+B[k_idx])

elif type_func=='tangenth':

out_feature[k_idx,r_idx,c_idx]=tangenth(sum_temp+B[k_idx])

else:

raise Exception

return out_feature

def cnn_maxpooling(out_feature,pooling_size=2,type_pooling="max"):

k,row,col=numpy.shape(out_feature)

max_index_Matirx=numpy.zeros((k,row,col))

out_row=int(numpy.floor(row/pooling_size))

out_col=int(numpy.floor(col/pooling_size))

out_pooling=numpy.zeros((k,out_row,out_col))

for k_idx in range(0,k):

for r_idx in range(0,out_row):

for c_idx in range(0,out_col):

temp_matrix=out_feature[k_idx,pooling_size*r_idx:pooling_size*r_idx+pooling_size,pooling_size*c_idx:pooling_size*c_idx+pooling_size]

out_pooling[k_idx,r_idx,c_idx]=numpy.amax(temp_matrix)

max_index=numpy.argmax(temp_matrix)

#print max_index

#print max_index/pooling_size,max_index%pooling_size

max_index_Matirx[k_idx,pooling_size*r_idx+max_index/pooling_size,pooling_size*c_idx+max_index%pooling_size]=1

return out_pooling,max_index_Matirx

def poolwithfunc(in_pooling,W,B,type_func='sigmoid'):

k,row,col=numpy.shape(in_pooling)

out_pooling=numpy.zeros((k,row,col))

for k_idx in range(0,k):

for r_idx in range(0,row):

for c_idx in range(0,col):

out_pooling[k_idx,r_idx,c_idx]=sigmoid(W[k_idx]*in_pooling[k_idx,r_idx,c_idx]+B[k_idx])

return out_pooling

#out_feature is the out put of conv

def backErrorfromPoolToConv(theta,max_index_Matirx,out_feature,pooling_size=2):

k1,row,col=numpy.shape(out_feature)

error_conv=numpy.zeros((k1,row,col))

k2,theta_row,theta_col=numpy.shape(theta)

if k1!=k2:

raise Exception

for idx_k in range(0,k1):

for idx_row in range( 0, row):

for idx_col in range( 0, col):

error_conv[idx_k,idx_row,idx_col]=\

max_index_Matirx[idx_k,idx_row,idx_col]*\

float(theta[idx_k,idx_row/pooling_size,idx_col/pooling_size])*\

difsigmoid(out_feature[idx_k,idx_row,idx_col])

return error_conv

def backErrorfromConvToInput(theta,inputImage):

k1,row,col=numpy.shape(theta)

#print "theta",k1,row,col

i_row,i_col=numpy.shape(inputImage)

if rowi_row or col i_col:

raise Exception

filter_row=i_row-row+1

filter_col=i_col-col+1

detaW=numpy.zeros((k1,filter_row,filter_col))

#the same with conv valid in matlab

for k_idx in range(0,k1):

for idx_row in range(0,filter_row):

for idx_col in range(0,filter_col):

subInputMatrix=inputImage[idx_row:idx_row+row,idx_col:idx_col+col]

#print "subInputMatrix",numpy.shape(subInputMatrix)

#rotate theta 180

#print numpy.shape(theta)

theta_rotate=numpy.rot90(theta[k_idx,:,:], 2)

#print "theta_rotate",theta_rotate

dotMatrix=numpy.dot(subInputMatrix,theta_rotate)

detaW[k_idx,idx_row,idx_col]=numpy.sum(dotMatrix)

detaB=numpy.zeros((k1,1))

for k_idx in range(0,k1):

detaB[k_idx]=numpy.sum(theta[k_idx,:,:])

return detaW,detaB

def loadMNISTimage(absFilePathandName,datanum=60000):

images=open(absFilePathandName,'rb')

buf=images.read()

index=0

magic, numImages , numRows , numColumns = struct.unpack_from('IIII' , buf , index)

print magic, numImages , numRows , numColumns

index += struct.calcsize('IIII')

if magic != 2051:

raise Exception

datasize=int(784*datanum)

datablock=""+str(datasize)+"B"

#nextmatrix=struct.unpack_from('47040000B' ,buf, index)

nextmatrix=struct.unpack_from(datablock ,buf, index)

nextmatrix=numpy.array(nextmatrix)/255.0

#nextmatrix=nextmatrix.reshape(numImages,numRows,numColumns)

#nextmatrix=nextmatrix.reshape(datanum,1,numRows*numColumns)

nextmatrix=nextmatrix.reshape(datanum,1,numRows,numColumns)

return nextmatrix, numImages

def loadMNISTlabels(absFilePathandName,datanum=60000):

labels=open(absFilePathandName,'rb')

buf=labels.read()

index=0

magic, numLabels  = struct.unpack_from('II' , buf , index)

print magic, numLabels

index += struct.calcsize('II')

if magic != 2049:

raise Exception

datablock=""+str(datanum)+"B"

#nextmatrix=struct.unpack_from('60000B' ,buf, index)

nextmatrix=struct.unpack_from(datablock ,buf, index)

nextmatrix=numpy.array(nextmatrix)

return nextmatrix, numLabels

def simpleCNN(numofFilter,filter_size,pooling_size=2,maxIter=1000,imageNum=500):

decayRate=0.01

MNISTimage,num1=loadMNISTimage("F:\Machine Learning\UFLDL\data\common\\train-images-idx3-ubyte",imageNum)

print num1

row,col=numpy.shape(MNISTimage[0,0,:,:])

out_Di=numofFilter*((row-filter_size+1)/pooling_size)*((col-filter_size+1)/pooling_size)

MLP=BMNN2.MuiltilayerANN(1,[128],out_Di,10,maxIter)

MLP.setTrainDataNum(imageNum)

MLP.loadtrainlabel("F:\Machine Learning\UFLDL\data\common\\train-labels-idx1-ubyte")

MLP.initialweights()

#MLP.printWeightMatrix()

rng = numpy.random.RandomState(23455)

W_shp = (numofFilter, filter_size, filter_size)

W_bound = numpy.sqrt(numofFilter * filter_size * filter_size)

W_k=rng.uniform(low=-1.0 / W_bound,high=1.0 / W_bound,size=W_shp)

B_shp = (numofFilter,)

B= numpy.asarray(rng.uniform(low=-.5, high=.5, size=B_shp))

cIter=0

while cItermaxIter:

cIter += 1

ImageNum=random.randint(0,imageNum-1)

conv_out_map=cnn_conv(MNISTimage[ImageNum,0,:,:], W_k, B,"sigmoid")

out_pooling,max_index_Matrix=cnn_maxpooling(conv_out_map,2,"max")

pool_shape = numpy.shape(out_pooling)

MLP_input=out_pooling.reshape(1,1,out_Di)

#print numpy.shape(MLP_input)

DetaW,DetaB,temperror=MLP.backwardPropogation(MLP_input,ImageNum)

if cIter%50 ==0 :

print cIter,"Temp error: ",temperror

#print numpy.shape(MLP.Theta[MLP.Nl-2])

#print numpy.shape(MLP.Ztemp[0])

#print numpy.shape(MLP.weightMatrix[0])

theta_pool=MLP.Theta[MLP.Nl-2]*MLP.weightMatrix[0].transpose()

#print numpy.shape(theta_pool)

#print "theta_pool",theta_pool

temp=numpy.zeros((1,1,out_Di))

temp[0,:,:]=theta_pool

back_theta_pool=temp.reshape(pool_shape)

#print "back_theta_pool",numpy.shape(back_theta_pool)

#print "back_theta_pool",back_theta_pool

error_conv=backErrorfromPoolToConv(back_theta_pool,max_index_Matrix,conv_out_map,2)

#print "error_conv",numpy.shape(error_conv)

#print error_conv

conv_DetaW,conv_DetaB=backErrorfromConvToInput(error_conv,MNISTimage[ImageNum,0,:,:])

#print "W_k",W_k

#print "conv_DetaW",conv_DetaW


分享标题:python中lti函数 python__lt__函数
文章分享:http://shouzuofang.com/article/dopcsje.html

其他资讯