分类： Python技术

朴素贝叶斯处理鸢尾花

朴素贝叶斯处理鸢尾花数据集
朴素贝叶斯公式

上代码

from sklearn import datasets
from sklearn.model_selection import GridSearchCV,train_test_split,cross_val_score
iris = datasets.load_iris()#下载鸢尾花数据集
data_x = iris[“data”]#特征x
# print(data_x)
data_y = iris[“target”]#类别y
#将每一列特征划分成几份区间，标准化
num_1=5#每个特征分成五份，我这里是每个特征都分成5个区间，也可以分开。不过代码自己改
def standard_feature(feature_col,num):
max_0 = max(data_x[:,feature_col])
min_0 = min(data_x[:,feature_col])
width_0 = (max_0-min_0)/num
for j in range(len(data_x[:,feature_col])):
for i in range(1, num + 1):
if min_0+(i-1)*width_0<=data_x[j,feature_col]<=min_0+i*width_0:
data_x[j,feature_col] =i
# print(data_x[j,feature])
break
x_col_num = len(data_x[0])#获取列数及特征数目
def get_pb(one_feature,col,x_train):
”’
one_feature在该x_train数据集的col列的概率
:param one_feature:查找的特征是啥
:param col: 列
:param x_train:
:return: 返回该特征的概率
”’
fea_sum = 0
for i in x_train[:,col]:
if i == one_feature:
fea_sum+=1
col_all = len(x_train)
p_b1 =fea_sum/col_all
# if p_b1 == 0:
# print(“第几列第几个特征个数为0”,col,one_feature,len(x_train))#如果当你把x特征分的太细会出现有些特征测试集有但训练集没有。看len(x_train）当这个等于训练集总数第78行会除数为0
return p_b1
for i in range(x_col_num):#data_x将所有特征标准化
standard_feature(i,num_1)
x_train,x_test,y_train,y_test = train_test_split(data_x,data_y,test_size=0.3)#拆分成测试集，训练集
print(“训练集样本数量”,len(x_train))
print(“测试集样本数量”,len(x_test))

test_PB_list =[]#
for row_i in range(len(x_test)):
P_B = 1
for col_i in range(x_col_num):
one_pb = get_pb(x_test[row_i,col_i],col_i,x_train)
P_B *= one_pb
#经过for循环得到每个测试集样本的P（B）
test_PB_list.append(P_B)
print(“test_PB_list元素个数”,len(test_PB_list))
y =3
y_index_list = []#分别存放对应y的全部训练集的全部列索引，该列表元素的列表索引对应y
for y_num in range(y):
one_y_index_list =[]
for y_index in range(len(y_train)):
if y_train[y_index] == y_num:
one_y_index_list.append(y_index)
y_index_list.append(one_y_index_list)
print(“训练集中每类拥有索引个数”,*[len(a) for a in y_index_list])
y_num_list = []
for y_num in range(y):
one_y_num = 0
for y_index in range(len(y_train)):
if y_train[y_index] == y_num:
one_y_num+=1
y_num_list.append(one_y_num)
print(“训练集每类拥有个数”,y_num_list)
test_y_predict =[]#测试集预测Y
for test_row in range(len(x_test)):#test_row为测试集每行样本，每行样本都需要计算分类为各个y的概率，哪个概率*大，说明就是哪一类
final_y_P = []
for y_index in range(y):
x_train_yindex = x_train[y_index_list[y_index],:]
P_BinA = 1
for col_i in range(x_col_num):
one_pb = get_pb(x_test[test_row, col_i], col_i, x_train_yindex)
P_BinA *= one_pb
PAinB=(y_num_list[y_index]/len(y_train))*P_BinA/test_PB_list[test_row]
final_y_P.append(PAinB)
belong_class = final_y_P.index(max(final_y_P))
test_y_predict.append(belong_class)
print(test_y_predict)
print(list(y_test))
predict_right_num = 0
for i in range(len(test_y_predict)):
if test_y_predict[i] == y_test[i]:
predict_right_num+=1
probability = predict_right_num/len(test_y_predict)
print(“预测正确概率”,probability)

接下来打算用其他方法实现分类，以鸢尾花为数据集KNN logistic 决策树

面向对象

文章目录
面向对象
面向对象简介
什么是类(Class)
类
类的方法
类中的参数self
self参数的属性和方法
self公约
面向对象
Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的
如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念。
面向对象简介
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
方法：类中定义的函数。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
实例化：创建一个类的实例，类的具体对象。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
对象可以包含任意数量和类型的数据。
面向过程指将我们的程序分解为一个一个步骤，通过对每个步骤的抽象来完成程序
这种编写方式往往只适用于一个功能，如果要实现别的功能，往往复用性比较低
这种编程方式符号人类的思维，编写起来比较容易
1. 妈妈穿衣服穿鞋出门
2. 妈妈骑上电动车
3. 妈妈到超市门口放好电动车
4. 妈妈买西瓜
5. 妈妈结账
6. 妈妈骑电动车回家
7. 到家孩子吃西瓜

面向对象的编程语言，关注的是对象，而不注重过程，对于面向对象一切皆对象
以上方式可以用 孩子妈妈给孩子买瓜来解决
面向对象的编程思想，将所有功能统一保存到对应的对象中，要使用某个功能，直接找到对应的对象即可
这种编码方式比较容易阅读，并且易于维护，容易复用。但是编写的过程中不太符合常规的思维，编写相对麻烦
什么是类(Class)
用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
语法格式：
class ClassName:
<statement-1>
.
.
.
<statement-N>

简单来说就是

# 语法
class 名字([object或者是继承的类名]):
def 一串很牛逼的代码（）：

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。
类也是一个对象，类就是用来创建对象的对象
可以像对象中添加变量，对象中的变量称之为属性 语法：对象.属性名 = 属性值
类
类和对象都是对现实生活中事物的抽象
事物包含两部分
数据(属性)
行为(方法)
调用方法 对象.方法名()
方便调用和函数调用的区别：如果是函数调用，调用时有几个形参，就会传递几个实参。如果是方法调用，默认传递一个参数，所以方法中至少得有一个形参
在类代码块中，我们可以定义变量和函数
变量会成为该类实例的公共属性，所有的该实例都可以通过 对象.属性名的形式访问
函数会成为该类实例的公共方法，所有该类实例都可以通过 对象.方法名的形式访问
class MyClass:
“””一个简单的类实例”””
i = 12345
def f(self):
return ‘hello world’

# 实例化类
x = MyClass()

# 访问类的属性和方法
print(“MyClass 类的属性 i 为：”, x.i)
print(“MyClass 类的方法 f 输出为：”, x.f())

以上创建了一个新的类实例并将该对象赋给局部变量 x，x 为空的对象。

MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world

类的方法
在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为*个参数，self 代表的是类的实例。
#类定义
class people:
#定义基本属性
name = ”
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
#定义构造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print(“%s 说: 我 %d 岁。” %(self.name,self.age))

# 实例化类
p = people(‘runoob’,10,30)
p.speak()

runoob 说: 我 10 岁。

类中的参数self
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的*个参数名称, 按照惯例它的名称是 self。
self参数的属性和方法
类中定义的属性和方法都是公共的，任何该类实例都可以访问
属性和方法的查找流程
当我们调用一个对象的属性时，解析器会现在当前的对象中寻找是否还有该属性，如果有，则直接返回当前的对象的属性值。如果没有，则去当前对象的类对象中去寻找，如果有则返回类对象的属性值。如果没有就报错
类对象和实例对象中都可以保存属性(方法)
如果这个属性(方法)是所以的实例共享的，则应该将其保存到类对象中
如果这个属性(方法)是摸个实例独有的。则应该保存到实例对象中
一般情况下，属性保存到实例对象中 而方法需要保存到类对象中
class Test:
def prt(self):
print(self)
print(self.__class__)

t = Test()
t.prt()

<main.Test instance at 0x100771878>
main.Test

从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。
self 不是 python 关键字，我们把他换成 ZHT 也是可以正常执行的:
class Test:
def prt(ZHT):
print(ZHT)
print(ZHT.__class__)

t = Test()
t.prt()

<main.Test instance at 0x100771878>
main.Test

self公约
self在定义时需要定义，但是在调用时会自动传入。
self的名字并不是规定死的，但是*好还是按照约定是用self
self总是指调用时的类的实例

python实现Hangman游戏

游戏过程解读

计算机从一个文本中随机抽取一个单词，字符串表示，并显示出字符串长度用户一个字符一个字符去猜，手动输入猜测结果，总共有6次猜测次数，每次猜测完之后，计算机告知玩家已经猜测的结果和剩余可以猜测的字母范围玩家猜测过程是有一定的规则的：

不能猜测已经猜测过的字符，每重复猜测一次，计算机发出警告一次，总共有3次警告机会；不能猜测除了大小写字母之外的字符，如‘#’ 等一些特殊字符，每猜测一次，警告次数减 1；当警告次数没有了，玩家如果继续犯规（猜测重复，或者猜测除大小写字母之外的字符）则猜测次数减去 1；玩家猜测的字母不在目标串 secret_letters中，如果猜测的字母是元音字母，则猜测次数减 2 作为惩罚，如果是辅音字母，则猜测次数减 1这样猜对于玩家来说实在太有难度了，是否可以实现一个游戏的改进版本，每当玩家输入星号 * 时，计算机自动输出文本中所有与当前玩家已猜测结果相符合的单词呢？这样就可以大大缩小玩家的猜测范围了，降低游戏难度。

模块化编程思想

怎么实现这个游戏呢？ 我们首先要实现一些功能，这些功能如下：

计算机如何获取文本 如何从文本中随机获取单词 判断玩家猜测字符是否正确 获取玩家已猜对字母 获取剩余可猜测字母范围 计算机玩家交互过程 相关函数的代码就不分别给出了，下面直接给出整个项目的代码

游戏代码

Hangman Game
import random

import string

WORDLIST_FILENAME = “words.txt”

def load_words():#读取文件

print(“Loading word list from file…”)

# inFile: file

inFile = open(WORDLIST_FILENAME, ‘r’)

# line: string

line = inFile.readline()

# wordlist: list of strings

wordlist = line.split() #空格分开的单词

print(” “, len(wordlist), “words loaded.”)

return wordlist #返回的是一个列表

wordlist=load_words()

def choose_word(wordlist):

return random.choice(wordlist) #随机获取一个单词
1
#判断玩家猜测是否正确

def is_word_guessed(secret_word, letters_guessed):

list_secret=list(secret_word)

#只要目标中出现一个字母不在玩家猜测结果中，返回False,都在的话，返回True

for i in list_secret:

if i not in letters_guessed:

return False

return True

#获取玩家已猜对字母

def get_guessed_word(secret_word, letters_guessed):

length=len(secret_word)

list_secret=[‘_ ‘]*length #列表元素先全部初始化为’_’

for i in letters_guessed:

for j in range(length):

if i==secret_word[j]: #用猜对的字母替换掉对应位置的’_’

list_secret[j]=secret_word[j]

string=””.join(map(lambda x:str(x),list_secret)) #列表转字符串

return string

#获取剩余可猜测字母范围

def get_available_letters(letters_guessed):

#初始化可猜字母为全部小写字母

letters_all=”abcdefghijklmnopqrstuvwxyz”

for i in letters_all:

if i in letters_guessed: #如果玩家已经猜过 i 则将其替换为’_ ‘

letters_all=letters_all.replace(i,”)

return letters_all

def hangman(secret_word):

list_unique=[] #用于secret_word去重

for i in secret_word:

if i not in list_unique:

list_unique.append(i)

unique_numbers=len(list_unique) #目标单词中不同字符的数量，用于计算玩家分数

vowels=”aeiou” #元音字母

print(“Welcome to the game hangman!”)

length=len(secret_word) #目标单词长度

print(“I’m thinking of a word that is {} letters long!”.format(length))

times_left=6 #玩家剩余猜测次数

warning_left=3 #玩家剩余警告次数

print(“You have {} warnings left.”.format(warning_left))

print(“————- “)

list_guessed=[]

while times_left>0: #玩家猜测次数没用完

print(“You have {} guesses left.”.format(times_left))

print(“Available letters:”,get_available_letters(list_guessed))

char=input(“Please guess a letter:”)

x=str.lower(char)

if x in list_guessed:#玩家已经猜过这个字母

if warning_left>0: #警告次数没用完

warning_left-=1

print(“Oops! You’ve already guessed that letter.You have {} warnings left:”.format(warning_left),get_guessed_word(secret_word,list_guessed))

else: #警告次数为0了 减少猜测次数

times_left-=1

print(“Oops! You’ve already guessed that letter.You have no warnings left,so you lose one guess:”,get_guessed_word(secret_word,list_guessed))

else: #玩家尚未猜测过这个字母

list_guessed.append(x) #先存储玩家猜测结果

if not str.isalpha(x): #玩家输入不是是字母

if warning_left>0:

warning_left-=1

print(“Oops!That is not a valid letter.You have {} warnings left:”.format(warning_left),get_guessed_word(secret_word,list_guessed))

else:

times_left-=1

print(” Oops! That is not a valid letter. You have no warnings left,so you lose one guess:”,get_guessed_word(secret_word,list_guessed))

#玩家输入是字母时

elif x in secret_word:#玩家猜测字母在目标中

print(“Good guess:”,get_guessed_word(secret_word,list_guessed))

# 玩家猜出全部字母

if secret_word==get_guessed_word(secret_word,list_guessed):

print(“————- “)

print(“Congratulations, you won!”)

total_score=times_left*unique_numbers

print(“Your total score for this game is:”,total_score)

return

else: #玩家猜测字母不在目标中

print(“Oops! That letter is not in my word.”,get_guessed_word(secret_word,list_guessed))

if x in vowels: #没有猜中，且是元音字母

times_left-=2

else:

times_left-=1

print(“————- “)

print(“Sorry, you ran out of guesses.The word was {}”.format(secret_word)) #玩家失败，游戏结束

return

def del_space(string): #将字符串去除空格后转化成列表

lst=[]

for i in string:

if i!=’ ‘:

lst.append(i)

return lst

#检验两个单词是否按规则匹配

def match_with_gaps(my_word, other_word):

#先将字符串转换成列表，方便操作

list_my_word=del_space(my_word)

list_other_word=list(other_word)

if len(list_my_word)!=len(list_other_word): #长度不一致

return False

else:

length=len(list_my_word)

for i in range(length): #对应位置均是字母且不相等

if list_my_word[i]!=’_’ and list_my_word[i]!=list_other_word[i]:

return False

#list_my_word[i]==’_’时

for i in range(length):

j=i+1

for j in range(length):

if list_other_word[i]==list_other_word[j] and list_my_word[i]!=list_my_word[j]:

return False

return True

def show_possible_matches(my_word):

flag=0 #用于标记是否存在可能匹配的单词

possible_word=[] #存储可能匹配的单词

for i in wordlist:

if match_with_gaps(my_word,i):

flag=1

possible_word.append(i)

if flag==0:#不存在可能匹配的单词

print(“No matches found.”)

else:

print(“Possible word matches are:”)

for i in possible_word:

print(i,end=’ ‘)

print(“”)

def hangman_with_hints(secret_word):

list_unique=[] #用于secret_word去重

for i in secret_word:

if i not in list_unique:

list_unique.append(i)

unique_numbers=len(list_unique) #目标单词中不同字符的数量，用于计算玩家分数

vowels=”aeiou” #元音字母

print(“Welcome to the game hangman!”)

length=len(secret_word) #目标单词长度

print(“I’m thinking of a word that is {} letters long!”.format(length))

times_left=6 #玩家剩余猜测次数

warning_left=3 #玩家剩余警告次数

print(“You have {} warnings left.”.format(warning_left))

print(“————- “)

list_guessed=[]

while times_left>0: #猜测次数没没有用完时

print(“You have {} guesses left.”.format(times_left))

print(“Available letters:”,get_available_letters(list_guessed))

char=input(“Please guess a letter:”)

x=str.lower(char)

if x in list_guessed:#玩家已经猜过这个字母

if warning_left>0:

warning_left-=1

print(“Oops!You’ve already guessed that letter.You have {} warnings left:”.format(warning_left),get_guessed_word(secret_word,list_guessed))

else: #警告次数为0了 减少猜测次数

times_left-=1

print(“Oops! You’ve already guessed that letter.You have no warnings eft,so you lose one guess:”,get_guessed_word(secret_word,list_guessed))

else: #玩家尚未猜测过这个字母

list_guessed.append(x) #先存储玩家猜测结果

if x==’*’: #是 ‘*’ 的情况

my_word=get_guessed_word(secret_word,list_guessed)

show_possible_matches(my_word)

elif not str.isalpha(x): #玩家输入不是是字母且不是 * 号

if warning_left>0:

warning_left-=1

print(“Oops! That is not a valid letter.You have {} warnings left:”.format(warning_left),get_guessed_word(secret_word,list_guessed))

else:

times_left-=1

print(” Oops! That is not a valid letter.You have no warnings left,so you lose one guess:”,get_guessed_word(secret_word,list_guessed))

#玩家输入是字母时

elif x in secret_word:#玩家猜测字母在目标中

print(“Good guess:”,get_guessed_word(secret_word,list_guessed))

# 玩家猜出全部字母

if secret_word==get_guessed_word(secret_word,list_guessed):

print(“————- “)

print(“Congratulations,you won!”)

total_score=times_left*unique_numbers

print(“Your total score for this game is:”,total_score)

return

else: #玩家猜测字母不在目标中

print(“Oops! That letter is not in my word.”,get_guessed_word(secret_word,list_guessed))

if x in vowels: #没有猜中，且是元音字母

times_left-=2

else:

times_left-=1

print(“————- “)

print(“Sorry,you ran out of guesses.The word was {}”.format(secret_word)) #玩家失败，游戏结束

return

“””

if name == “main”:

secret_word=choose_word(wordlist)

hangman(secret_word)

#secret_word = choose_word(wordlist)

#hangman_with_hints(“apple”)

注意，注释掉的部分是为了实现 hangman 游戏的 改进版本，一个具有计算机提示功能的版本，每当用户输入 * 时，计算机就将文本中所有与当前已猜测结果相匹配的单词输出，以缩小玩家猜测范围作为提示。游戏效果如下： 项目代码如果有任何问题，欢迎随时指出，万分感谢！

python代码记录

python列表推导式不会改变外部变量值，但是for循环会：
x = ‘my precious’

dummy = [x for x in ‘abc’]
print(x) # x 的值依旧是 my precious

for x in ‘def’:
print(x)
print(x) # 这里可以看到 for 循环后 x 的值发生了改变

# 输出结果为：
my precious
d
e
f
f

注：python3的推导式有自己的局部作用域类似于函数，但是python2没有，所以python2中的推导式也会改变外部变量的值。

生成器比列表推导式省内存
colors = [‘black’, ‘white’]
sizes = [‘s’, ‘m’, ‘l’]

# 列表推导式，先产出了一个列表，再执行迭代
for tshirt in [‘%s %s’ % (c, s) for c in colors for s in sizes]:
print(tshirt)

# 生成器遵循迭代协议，逐个产出元素，相交列表推导式节省了内存
for tshirt in (‘%s %s’ % (c, s) for c in colors for s in sizes):
print(tshirt)

divmod函数
print(divmod(20, 8)) # 将 20 除 8 的 商 和 余数 以元组的形式返回
# 输出：
(2, 4)

bisect函数用于插入排序
import bisect
import random

SIZE = 7
random.seed(1729) # 指定种子后，无论运行多少次，输出的随机数是一样的

my_list = [] # 如果已有数据，该函数不会改变原有数据排序，只是依照大小插入新元素
for i in range(SIZE):
new_item = random.randrange(SIZE*2)
bisect.insort(my_list, new_item) # 将新的元素按照指定排序的方式插入已有序列
print(‘%2d ->’ % new_item, my_list)

# 输出：
10 -> [10]
0 -> [0, 10]
6 -> [0, 6, 10]
8 -> [0, 6, 8, 10]
7 -> [0, 6, 7, 8, 10]
2 -> [0, 2, 6, 7, 8, 10]
10 -> [0, 2, 6, 7, 8, 10, 10]

openpyxl简单使用

读取指定的excel文件
文件目录结构

excel表格数据内容

使用频率高的几个用法

# 文件readExcel.py
from openpyxl import load_workbook
workbook = load_workbook(‘demo.xlsx’) # 实例化一个excel文件操作对象
sheet = workbook[‘Sheet1’] # 指定excel表单名称Sheet1，之后操作都在Sheet1操作
row = sheet.max_row # *大行数
column = sheet.max_column # *大列数
print(workbook.sheetnames) # 打印所有表单名称
print(sheet.rows) # sheet表单的行生成器
print(sheet.cell(1, 1).value) # *行*列的值
print(row, column)

打印结果内容：
任务：
使用常用功能读取Sheet1表格所有内容展示结果：
[
{‘caseId’: 1, ‘caseName’: 2, ‘method’: 3, ‘data’: 4},
{‘caseId’: 2, ‘caseName’: 3, ‘method’: 4, ‘data’: 5},
{‘caseId’: 3, ‘caseName’: 4, ‘method’: 5, ‘data’: 6},
{‘caseId’: 4, ‘caseName’: 5, ‘method’: 6, ‘data’: 7},
{‘caseId’: 5, ‘caseName’: 6, ‘method’: 7, ‘data’: 8},
{‘caseId’: 6, ‘caseName’: 7, ‘method’: 8, ‘data’: 9},
{‘caseId’: 7, ‘caseName’: 8, ‘method’: 9, ‘data’: 10},
{‘caseId’: 8, ‘caseName’: 9, ‘method’: 10, ‘data’: 11},
{‘caseId’: 9, ‘caseName’: 10, ‘method’: 11, ‘data’: 12}
]
对应excel10行数据，*行标题为字典的键、每一行对应列表的一个元素。（为之后接口自动化数据结构奠基）

# 文件readExcel.py
class ExcelTreating:
def __init__(self, filename):
self.workbook = load_workbook(‘demo.xlsx’)

def read_excel(self, sheet_name):
test_data = []
sheet = self.workbook[sheet_name]
max_row = sheet.max_row
max_column = sheet.max_column
title = [sheet.cell(1, i+1).value for i in range(max_column)] # 将*行的值存到title列表

for row in range(2, max_row+1):
col_content = [sheet.cell(row, column).value for column in range(1, max_column+1)]
test_data.append(dict(zip(title, col_content)))
return test_data

res = ExcelTreating(‘demo.xlsx’).read_excel(‘Sheet1’)
print(res)

PyQt5 QThread倒计时

创建多线程类
全局变量 sec
class work_thread(QThread):
timer = pyqtSignal() # 每隔一秒发送信号
end = pyqtSignal() # 计数完成发送信号

def run(self) -> None:
while True:
self.sleep(1)
if sec == 0:
self.end.emit() # 发送end信号
break
self.timer.emit()

实例化线程类，绑定计数，技术结束事件
self.label.setText(“20”)
global sec
sec = 20
self.work_thread = work_thread()
self.work_thread.timer.connect(self.count_time)
self.work_thread.end.connect(self.end)

绑定开始按钮事件
self.pushButton.clicked.connect(self.start)

事件方法
def count_time(self):
global sec
sec = int(self.label.text())
sec -= 1
self.label.setText(str(sec))

def end(self):
self.statusbar.showMessage(“计数停止”)

def start(self):
self.work_thread.start() # 启动线程

基于Prompt的MLM文本分类

简介
常规NLP做文本分类时常用Transfer Learning的方式，在预训练bert上加一个分类层，哪个输出节点概率*大则划分到哪一类别。而基于Prompt的MLM文本分类是将文本分类任务转化为MLM（ Masked Language Modeling）任务，通过[MASK]位置的输出来判断类别。
例如通过文本描述判定天气好坏，类别【好、坏】：

常规方式：今天阳光明媚！ 【好】
基于Prompt的MLM： 天气[MASK]，今天阳光明媚！【天气好，今天阳光明媚！】

Prompt的设定可以有多种方式设定，手写Prompt 、自动离散Prompt、自动连续 P-Tuning，自行查找论文

实验
先手写Prompt做个实验：
就以上面?例子中的Prompt，“ 天气[MASK]+带分类文本”

import os
import logging
import datasets
import transformers
import numpy as np
from sklearn import metrics
from datasets import Dataset
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, precision_recall_fscore_support
from transformers import Trainer, TrainingArguments, BertTokenizer, BertForMaskedLM

os.environ[‘CUDA_VISIBLE_DEVICES’] = ‘4’
transformers.set_seed(1)
logging.basicConfig(level=logging.INFO)

class LecCallTag():

# 原始样本统计
def data_show(self, data_file):
with open(data_file, ‘r’, encoding=’utf-8′) as f:
data = f.readlines()
logging.info(“获取数据：%s” % len(data))
tags_data_dict = {}
for line in data:
text_label = line.strip().split(‘\t’)
if text_label[1] in tags_data_dict:
tags_data_dict[text_label[1]].append(text_label[0])
else:
tags_data_dict[text_label[1]] = [text_label[0]]
logging.info(“其中，各分类数量：”)
for k, v in tags_data_dict.items():
logging.info(“%s: %s” % (k, len(v)))
return tags_data_dict

# 数据处理
def data_process(self, data_file):
with open(data_file, ‘r’, encoding=’utf-8′) as f:
data = [line.strip().split(‘\t’) for line in f.readlines()] # 今天阳光明媚！ 好
text = [‘天气[MASK]，’+_[0] for _ in data]
label = [‘天气’+_[1]+’,’+_[0] for _ in data]
return text, label

# model, tokenizer
def create_model_tokenizer(self, model_name, n_label=0):
tokenizer = BertTokenizer.from_pretrained(model_name)
model = BertForMaskedLM.from_pretrained(model_name)
return tokenizer, model

# 构建dataset
def create_dataset(self, text, label, tokenizer, max_len):
X_train, X_test, Y_train, Y_test = train_test_split(text, label, test_size=0.2, random_state=1)
logging.info(‘训练集：%s条，\n测试集：%s条’ %(len(X_train), len(X_test)))
train_dict = {‘text’: X_train, ‘label_text’: Y_train}
test_dict = {‘text’: X_test, ‘label_text’: Y_test}
train_dataset = Dataset.from_dict(train_dict)
test_dataset = Dataset.from_dict(test_dict)
def preprocess_function(examples):
text_token = tokenizer(examples[‘text’], padding=True,truncation=True, max_length=max_len)
text_token[‘labels’] = np.array(tokenizer(examples[‘label_text’], padding=True,truncation=True, max_length=max_len)[“input_ids”]) # 注意数据类型
return text_token
train_dataset = train_dataset.map(preprocess_function, batched=True)
test_dataset = test_dataset.map(preprocess_function, batched=True)
return train_dataset, test_dataset

# 构建trainer
def create_trainer(self, model, train_dataset, test_dataset, checkpoint_dir, batch_size):
args = TrainingArguments(
checkpoint_dir,
evaluation_strategy = “epoch”,
learning_rate=2e-5,
per_device_train_batch_size=batch_size,
per_device_eval_batch_size=batch_size,
num_train_epochs=15,
weight_decay=0.01,
load_best_model_at_end=True,
metric_for_best_model=’accuracy’,
)
def compute_metrics(pred):
labels = pred.label_ids[:, 3]
preds = pred.predictions[:, 3].argmax(-1)
precision, recall, f1, _ = precision_recall_fscore_support(labels, preds, average=’weighted’)
acc = accuracy_score(labels, preds)
return {‘accuracy’: acc, ‘f1’: f1, ‘precision’: precision, ‘recall’: recall}
trainer = Trainer(
model,
args,
train_dataset=train_dataset,
eval_dataset=test_dataset,
# tokenizer=tokenizer,
compute_metrics=compute_metrics
)
return trainer

def main():
lct = LecCallTag()
data_file = ‘/data.txt’
checkpoint_dir = “/checkpoint/”
batch_size = 16
max_len = 64
n_label = 3
tags_data = lct.data_show(data_file)
text, label = lct.data_process(data_file)
tokenizer, model = lct.create_model_tokenizer(“bert-base-chinese”)
train_dataset, test_dataset = lct.create_dataset(text, label, tokenizer, max_len)
trainer = lct.create_trainer(model, train_dataset, test_dataset, checkpoint_dir, batch_size)
trainer.train()

if __name__ == ‘__main__’:
main()

实验结果
在实验数据集（自建、小样本500条）上
常规做bert-finetuning文本分类的结果：acc为84%,f1为83%
基于Prompt的MLM文本分类结果：acc为87%,f1为86%
修改Prompt，评测结果会浮动，可参考Prompt的设定方式继续优化效果

注
在分类文本前添加提示语，如将“今天阳关明媚！”变为“天气，今天阳光明媚！”在小样本下也可以使准确率提升！

激活函数

前言
在神经网络中，经常要使用激活函数。常用的激活函数有sigmoid，阶跃函数以及ReLU函数等。

sigmoid函数
sigmoid函数表达式：

比如h(1.0)=0.731….,h(2.0)=0.880….这样。

神经网络中用sigmoid函数作为激活函数，进行信号的转换，转换后的信号被传送给下一个神经元。

sigmoid函数的代码实现如下：

import numpy as np

def sigmoid(x):
return 1 / (1 + np.exp(-x))

x = np.array([-1.0, 1.0, 2.0])
print(sigmoid(x))
sigmoid函数能NumPy数组进行运算，在于Numpy函数广播功能，详细见：https://blog.csdn.net/qq_39432161/article/details/115307655

[ 0.26894142 0.73105858 0.88079708]
现在我们通过Matplotlib来绘制 sigmoid函数图形

# Author:北京
# QQ:838262020
# time:2021/3/31
import numpy as np
import matplotlib.pyplot as plt

def sigmoid(x):
return 1 / (1 + np.exp(-x))

# sigmoid函数图像
x = np.arange(-5.0, 5.0, 0.1)
y = sigmoid(x)
plt.plot(x, y)
# 指定y轴的取值范围
plt.ylim(-0.1, 1, 1)
plt.show()

阶跃函数
阶跃函数表达式：          

阶跃函数在Python中简单实现如下：

def step_function(x):
if x>0:
return 1
else:
return 0
这个实现简单，但是参数x只能接受普通数字（标量）。就是说允许形如step_function(1.0)的调用，但是不允许参数取NumPy数组,例如step_function(np.array([1.0,2.0]))。为了后期方便，我们进行修改支持NumPy数组的实现。

import numpy as np
def step_function(x):
y= x > 0
print(y)
return y.astype(np.int)

x=np.array([-1.0,1.0,2.0])
print(step_function(x))
[False True True]
[0 1 1]
现在我们通过Matplotlib来绘制阶跃函数的图形

import numpy as np
import matplotlib.pyplot as plt

def step_function(x):
return np.array(x > 0, dtype=np.int)

# 随机生成-5—5的数间隔0.1
x = np.arange(-5.0, 5.0, 0.1)
y = step_function(x)
plt.plot(x, y)
# 指定y轴地点取值范围
plt.ylim(-0.1, 1.1)
plt.ylabel(“y”)
plt.xlabel(“x”)
plt.show()

ReLU函数
ReLU函数在输入大于0时，直接输出该值，输入小于等于0，输出0

ReLU函数的表达式

ReLU函数在Python中简单实现如下：

import numpy as np
def relu(x):
return np.maximum(0,x)

x = np.array([-1.0, 1.0, 2.0])
print(relu(x))
[ 0. 1. 2.]
现在我们通过Matplotlib来绘制ReLU函数的图形

import numpy as np
import matplotlib.pyplot as plt
def relu(x):
return np.maximum(0,x)

# x = np.array([-1.0, 1.0, 2.0])
# print(relu(x))

# sigmoid函数图像
x = np.arange(-5.0, 5.0, 0.1)
y = relu(x)
plt.plot(x, y)
plt.show()

softmax函数
在神经网络的输出层经常要使用softmax函数或者恒等函数。

softmax函数公式：

softmax函数在Python中代码实现：

def softmax(a):
exp_a=np.exp(a)
sum_exp_a=np.sum(exp_a)
y=exp_a/sum_exp_a
return y

a= np.array([0.3,2.9,4.0])
print(softmax(a))

urllib库

3.1 使用urllib
urllib库是python内置的HTTP请求库。
request：它是*基本的HTTP请求模块
error：异常处理模块
parse：一个工具模块

3.1.1 发送请求
使用urllib的request模块，可以方便得实现请求的发送并得到响应

1.urlopen()
以python官网为例，我们把这个网页抓下来：

from urllib import request

respone=request.urlopen(‘https://www.python.org’)
print(respone.read().decode(‘utf-8’))

响应是一个HTTPResponse 类型的对象，主要包含read(),readinto(),getheader(name),getheaders(),fileno() 等方法，以及msg,version,status,reason,debuglevel,closed 等属性

urlopen()函数的API:
urllib.request.urlopen(url,data=None,[timeout]\* ,cafile=None,capath=None,cadefault=False,context=None)
1
timeout参数:
timeout参数用于设置超时时间，单位为秒，意思是如果请求超过了设置的这个时间，还没有得到响应，就会抛出异常。因此可以通过设置这个超时时间来控制一个网页如果长时间未响应，就跳过它的抓取。

import socket
from urllib import request,error

try:
response=request.urlopen(‘http://httpbin.org/get’,timeout=0.1)
except error.URLError as e:
if isinstance(e.reason,socket.timeout):
print(‘TIME OUT’)

2.Request
如果请求中需要加入Headers等信息，就可以利用更强大的Request类来构建

”’例子”’
from urllib import request

url=’https://www.python.org’
req=request.Request(url)
response=request.urlopen(req)#urlopen()的参数由url变成了Request类的对象
print(response.read().decode(‘utf-8′))

Request的构造方法：
class urllib.request.Request(url,data=None,headers={},origin_req_host=None，unverifiable=False,method=Npne)
1
1.*个参数url用来请求URL，这是必传参数，其他都是可选参数。
2.第二个参数data如果要传，必须传bytes（字节流）类型的。如果它是字典，可以先用urllib.parse模块里的urldecode()编码。
3.第三个参数headers是一个字典，它就是请求头，我们可以构造请求时通过headers参数直接构造，也可以通过调用请求实例的add_header() 方法添加。
4.第四个参数origin_req_host 指的是请求方的host名称或者IP地址。
5.第五个参数unverfiable
6.第六个参数method是一个字符串，用来指请求时使用的方法。
举个例子：

from urllib import request,parse

url=’http://httpbin.org/post’
headers={
‘Use-Agent’:’Mozilla/4.0(compatible;MSIE 5.5;Windows NT)’
,’Host’:’httpbin.org’
}
dict={
‘name’:’Germey’
}
data=bytes(parse.urlencode(dict),encoding=’utf-8′)
req=request.Request(url=url,headers=headers,data=data,method=’POST’)
response=request.urlopen(req)
print(response.read().decode(‘utf-8′)

运行结果：

{
“args”: {},
“data”: “”,
“files”: {},
“form”: {
“name”: “Germey”
},
“headers”: {
“Accept-Encoding”: “identity”,
“Content-Length”: “11”,
“Content-Type”: “application/x-www-form-urlencoded”,
“Host”: “httpbin.org”,
“Use-Agent”: “Mozilla/4.0(compatible;MSIE 5.5;Windows NT)”,
“User-Agent”: “Python-urllib/3.9”,
“X-Amzn-Trace-Id”: “Root=1-6065db0f-1c0ea1db629b705e722929a5”
},
“json”: null,
“origin”: “220.249.162.169”,
“url”: “http://httpbin.org/post”
}

另外，headers也可以用add_header() 的方法来添加：

req=request.Request(url=url,data=data,method=’POST’)
req.add_header(‘Use-Agent’:’Mozilla/4.0(compatible;MSIE 5.5;Windows NT)’)

3.高级用法
对于一些更高级的操作(比如Cookie处理，代理设置等)，就需要更高级的工具Handler，它是各种处理器，有专门处理登入验证的，有处理cookie的，有处理代理设置的。
urllib.request模块里的BaseHandler类，它是其他Handler的父类，它提供了*基础的方法，如default_open(),protocol_request()等。
有各种Hanler子类继承了BaseHandler类，例如：
1.HTTPDefaultErrorHandler:用于处理响应错误。
2.HTTPRedirectHandler：用于处理重定向。
3.ProxyHandler:用于处理代理设置，默认代理为空。
4.HTTPCookieProcessor：用于处理Cookies。
5.HTTPPasswordMgr:用于管理密码，它维护了用户名和密码表。
6.HTTPBasicAuthHAndler:用于管理认证。
另一个比较重要的类是OpennerDirector,我们可以称为Opener，Opener可以使用open() 方法，返回类型和urlopen()如出一辙。
举几个实例：

验证
from urllib.request import HTTPPasswordMgrWithDefaultRealm,HTTPBasicAuthHandler,build_opener
from urllib.error import URLError

username=’username’
password=’password’
url=’http://localhost:5000/’

p=HTTPPasswordMgrWithDefaultRealm()
#用add_password()添加用户名和密码
p.add_password(None,url,username,password)
#实例化HTTPBasicAuthHandler对象，其参数HTTPPasswordMgrWithDefaultRealm的对象
auth_handler=HTTPBasicAuthHandler(p)
#用handler构造opener
opener=build_opener(auth_handler)

try:
#用open()方法访问url
result=opener.open(url)
html=result.read().decode(‘utf-8’)
print(html)
except URLError as e:
print(e.reason)

代理
from urllib.request import ProxyHandler,build_opener
from urllib.error import URLError

proxy_handler=ProxyHandler({
‘http’:’http://127.0.0.1:9743′,
‘https’:’https://127.0.0.1:9743′
})
opener=build_opener(proxy_handler)
try:
result=opener.open(‘https://www.baidu.com’)
html=result.read().decode(‘utf-8′)
print(html)
except URLError as e:
print(e.reason)
”’
这里我们在本地搭建了一个代理，它运行在9743端口上。
这里使用了ProxyHandler,其参数是一个字典，键名是协议类型，键值是代理链接，可以添加多个代理。
然后，利用这个Handler及build_opener()方法构造出Opener,之后发送请求即可。
”’

Cookie
先用实例将网站的Cookies获取下来：

import http.cookiejar,urllib.request

cookie=http.cookiejar.CookieJar()
handler=urllib.request.HTTPCookieProcessor(cookie)
opener=urllib.request.build_opener(handler)
response=opener.open(‘https://baidu.com’)
for item in cookie:
print(item.name+”=”+item.value)

首先，必须声明一个CookieJar对象。接下来就需要利用HTTPCookiePocesser来构建一个Handler，*后利用build_opener()构建一个Opener，执行open()方法即可。
运行结果如下：

E:\pythonProject1\venv\Scripts\python.exe E:/expriment_1/github.py
BAIDUID=4960031CCAA92AB93BEE5567F01B4420:FG=1
BIDUPSID=4960031CCAA92AB9E8CD0B352782435C
H_PS_PSSID=33801_33810_33749_33344_31660_33779_33759_26350_33731_33803
PSTM=1617325714
BDSVRTM=0
BD_HOME=1

python两层意思
谈及python，涉及两层意思

一层代表的是python这门语言的语法风格，

另外一层代表的则是专门用来解释该语法风格的应用程序：python解释器。

python的创始人为吉多·范罗苏姆（Guido van Rossum）。Python这个名字，来自Guido所挚爱的电视剧Monty Python’s Flying Circus，他希望这个新的叫做Python的语言，能符合他的理想：创造一种C和shell之间，语法能够像shell一样简洁，易学易用、可拓展性强，同时兼顾C的强大功能。于是Guido在1989年的圣诞节期间，开始编写能够解释Python语言语法的解释器。

Python崇尚优美、清晰、简单，是一个优秀并广泛使用的语言。*新的TIOBE排行榜https://www.tiobe.com/tiobe-index/，Python已飙升至世界第二。