tensorflow 与 keras python 版本对应
python查看 库和 python自己的版本
import tensorflow as tf
tf.__version__
import sys
sys.version
print默认打印一行结尾加换行 end=' '意思是末尾不换行，加空格类的初始定义变量可传可不传 def __init__(self,data,left=None)
class Node():
def __init__(self,data,left,right):# 每次调用必须是三个值
self._data = data
self._left = left
self._right = right
tree = Node(1,2,3)
print(tree._data)
class Node():
def __init__(self,data):# 每次调用必须是三个值
self._data = data
self._left = None # 这种的先赋值在打印
self._right = None
tree = Node(1)
print(tree._left)
tree._left=100
print(tree._data)
print(tree._left)
输入：x[ batch_size, channels, height_1, width_1 ]
batch_size，一个batch中样本的个数 3
channels，通道数，也就是当前层的深度 1
height_1， 图片的高 5
width_1， 图片的宽 4
卷积操作：Conv2d[ channels, output, height_2, width_2 ]
channels，通道数，和上面保持一致，也就是当前层的深度 1
output ，输出的深度 4【需要4个filter】
height_2，卷积核的高 2
width_2，卷积核的宽 3
输出：res[ batch_size,output, height_3, width_3 ]
batch_size,，一个batch中样例的个数，同上 3
output， 输出的深度 4
height_3， 卷积结果的高度 4
width_3，卷积结果的宽度 2
import torch
x = torch.randn(3,1,5,4)
print(x)
conv = torch.nn.Conv2d(1,4,(2,3))
res = conv(x)
print(res.shape) # torch.Size([3, 4, 4, 2])
1. 写一个动物类（Animal），初始化函数输入名称（name），分类（category），类型均为字符串，再写一个狗类（Dog）继承动物类，初始化函数输入名称（name），分类（category）和颜色（color）
class Animal():# 定义类
def __init__(self,name,category):
self.name=name
self.category=category
class Dog(Animal): # 继承类
def __init__(self,name,category,color) # 定义子类和父类继承的所有的参数
super().__init__(name,category) # 初始化父类的参数 要跟父类参数一一对应
self.color=color
def print_color(self):# 定义一个函数 这个可以随便定义
print('Dog color:',self.color)
dog=Dog("狗","动物","黑色")
dog.print_color()
plt多个图显示在一个图上 调整标签大小
from gensim.models import Word2Vec
from random import sample
from sklearn.manifold import TSNE
from pylab import mpl
mpl.rcParams['font.sans-serif'] = ['SimHei'] #中文字体
mpl.rcParams['axes.unicode_minus'] = False #防止负号出现异常显示
#进行图的选取 选取两个图的点在一个图中显示！！！！！！！
G_sum_nodes_2=[]
G_sum_nodes_2.append(G_sum_nodes[7])
G_sum_nodes_2.append(G_sum_nodes[13])
G_sum_nodes_2.append(G_sum_nodes[25])
G_sum_nodes_2.append(G_sum_nodes[29])
plt.figure(figsize=(15,15)) #定义画布大小
color=['b',"r","g","k"] # 定义颜色 参数c 可以等于：['c', 'b', 'g', 'r', 'm', 'y', 'k', 'w']
color_label=['b',"r","g","k"]
marker=[" "," "," "," "]
for iddx,G in enumerate(G_sum_nodes_2):
tokens=[]
labels=[]
for i in G:
labels.append(i[2])
tokens.append(i[1]) # 存储的是向量
tsne_model = TSNE(perplexity=20, n_components=2, init='pca', n_iter=2500, random_state=23)
# perplexity: 默认为30，数据集越大，需要参数值越大，建议值位5-50 , n_components=2 默认为2，嵌入空间的维度（嵌入空间的意思就是结果空间）,别的参数估计不重要
# print(tokens)
new_values = tsne_model.fit_transform(tokens)
# 将X投影到一个嵌入空间并返回转换结果
#降维处理
# print(new_values)
x = []
y = []
for value in new_values:
x.append(value[0])
y.append(value[1])
for i in range(len(x)):
plt.scatter(x[i],y[i],c=color[iddx],marker=marker[iddx])
plt.text(x[i],y[i], labels[i], fontsize=25,color=color_label[iddx])
plt.xticks(fontsize=25)
plt.yticks(fontsize=25)
plt.savefig("ceshi.png")
plt.show()
创建 dataframe 数据类型 dataframe增加一列
df1 = pd.DataFrame(data_x_1)
df1["label"]=data_y_1
python 查看某一个安装包的信息
constant连续一样的值填充，有关于其填充值的参数。 constant_values=（x, y）时前面用x填充，后面用y填充。缺参数是为0000。。。
edge用边缘值填充
linear_ramp边缘递减的填充方式
maximum, mean, median, minimum分别用最大值、均值、中位数和最小值填充
reflect, symmetric都是对称填充。前一个是关于边缘对称，后一个是关于边缘外的空气对称
wrap用原数组后面的值填充前面，前面的值填充后面
也可以有其他自定义的填充方法
# constant连续一样的值填充，有关于其填充值的参数。 constant_values=（x, y）时前面用x填充，后面用y填充。缺参数是为0000。。。
# edge用边缘值填充
# linear_ramp边缘递减的填充方式
# maximum, mean, median, minimum分别用最大值、均值、中位数和最小值填充
# reflect, symmetric都是对称填充。前一个是关于边缘对称，后一个是关于边缘外的空气对称╮(╯▽╰)╭
# wrap用原数组后面的值填充前面，前面的值填充后面
# 也可以有其他自定义的填充方法
import numpy as np
A = np.arange(95,103).reshape(2,4)
print(A)
# ((0,2),(1,2)) 第一个括号(0,2)表示 在每行的后边填充两行 ，前边不填充。第二个括号(1,2)表示 在每行值的前边填充一个值 ，后边填充两个值。
# constant_values=(2, 10) 每行前边填充的值 是 2 ，后边填充的值是 10
B = np.pad(A,((0,2),(1,2)), 'constant',constant_values=(2, 10))# constant连续一样的值填充
print(B)
C = np.pad(A,((0,2),(1,2)), 'edge') # edge用边缘值填充
print(C)
padding 数据做补齐或者是截断
from keras_preprocessing import sequence
MaxLen=15
x = [[1,2,4,5,6], [2,5,4,4,4,4,], [3,9,9,4,8,4,4,4,4,]] # 特征
y = [2, 4, 6] # 标签
# padding padding='post'or padding='pre'------------------------
x0=sequence.pad_sequences(x,maxlen=MaxLen,value=0,padding='post')
print(x0) # 用 0填充
x1=sequence.pad_sequences(x,maxlen=MaxLen,value=0,padding='pre')
print(x1)
# 截断 truncating='post' or truncating='pre'-----------
x = [[1,2,4,5,6], [2,5,4,4,4,4,], [3,9,9,4,8,4,4,4,4,]] # 特征
y = [2, 4, 6] # 标签
MaxLen=3
x0=sequence.pad_sequences(x,maxlen=MaxLen,value=0,truncating='post')
print(x0)
x1=sequence.pad_sequences(x,maxlen=MaxLen,value=0,truncating='pre')
print(x1)
x=np.array([1,2,3,4,9,9,9,9])
x=torch.tensor(x)
mask = torch.logical_not(torch.eq(x, torch.tensor(9)))
print(x)
print(mask)
x1=np.array([[[1,2,3,4,9,9,9,9]]])
print(x1.shape)
x1=torch.tensor(x)
print(x1.shape)
mask = torch.logical_not(torch.eq(x1, torch.tensor(9)))
print(x1)
print(mask)
import torch
x=np.array([1,2,3,4,9,9,9,9])
x=torch.tensor(x)
mask = torch.logical_not(torch.eq(x, torch.tensor(9)))
print(type(mask))
print(mask)
print(torch.masked_select(x,mask))
安装 torchcrf：pip install pytorch-crf -i https://pypi.tuna.tsinghua.edu.cn/simple/
pip list 显示的时候是 TorchCRF 然而导入的时候是用 import torchcrf 或者 from torchcrf import CRF
import torch
# 安装 torchcrf pip install pytorch-crf -i https://pypi.tuna.tsinghua.edu.cn/simple/
# pip list 显示的时候是 TorchCRF 然而导入的时候是用 import torchcrf 或者 from torchcrf import CRF
from torchcrf import CRF
num_tags = 5 # 实体命名识别 每个汉字可以预测多少中类型
# model = CRF(num_tags,batch_first=True)
model = CRF(num_tags)
seq_length = 3 # 句子长度（一个句子有三个单词）
batch_size = 1 # batch大小 一共输入几个句子 在这里是一个 句子
hidden= torch.randn(batch_size,seq_length,num_tags) # 输入的是 batch：几个句子 ，seq_length：每个句子的长度
print(hidden.shape)# torch.Size([1, 3, 5])
# 表示：一个句子 句子长度是3 每个单词的维度是 5 ，为什么是5呢？因为是为每个单词打标签，一共有五个标签 所以
print(hidden)
mask = torch.tensor([[1,1,0]], dtype=torch.uint8) # mask的意思是 有的汉字的向量 不进行标签的预测
# mask的形状是:[batch，seq_length]
# 这句话由于torchcrf版本不同 进而 函数设置不同 batch_first=True 假设没有这句话 那么输入模型的第一个句子序列的 mask都是true，假设有这句话 就没事 ，mask是正常的
# mask的作用是：因为是中文的句子 那么每句话都要padding 一定的长度 所以 告诉模型那些是padding的
tags = torch.tensor([[0,2,3]], dtype=torch.long) #(batch_size, seq_length)
# tags 是真实的每个单词的标签 在crf模型中用不到啊
loss=model(hidden,tags,mask) # 计算对数似然（用于向前） loss
print(loss)
a=model.viterbi_decode(hidden,mask) # 或者用 model.decode(hidden,mask)
print(a)
tensor 维度变化 获取形状tensor.size() tensor.shape
transpose只能选择tensor中两个维度进行转置，比如第1和2维转置：
a.transpose(1,2)
reshape 和view方法的结果是一致的，但是view没有开辟新的内存空间，而reshape开辟了新的内存空间。尽管reshape开辟了新的内存空间，但是指向的底层元素地址依旧没有变换
a.view((2,3,2))
a.reshape((2,3,2))
可以通过tensor.size()或者tensor.shape得到。这两者不同的是tensor.szie()调用的是方法，tensor.shape访问的是张量的属性。相同的是两者返回的结果的数据类型都为torch.Size
tensor的unsqueeze()函数和squeeze()unsqueeze(a)用于增加一个维度。在tensor 第a个维度上增加一维
squeeze(a)函数来删除第a个维度,而且这个第a个维度必须是1维度
import torch
from torch import nn
from torch import optim
import math
# import tensorflow as tf
import numpy as np
import pandas as pd
a = np.array([2,3.2])
print(a.dtype)
a = np.array([2,3])
print(a.dtype)
a.dtype = 'float32'
print(a.dtype)
a.dtype = 'float64'
print(a.dtype)
a1=torch.rand(3,3)#随机产生0-1之间的数值，不包括1
b1 = torch.randint(1,10,[3,3])#随机产生1-10之间的整数，其shape为(3,3)
c1=torch.normal(mean=torch.full([10],0),std=torch.arange(1,0,-0.1))
#均值全为0，方差为[1,0.9,...,0.1]
#第1个数据从N(0,1)中采样，第2个数据从N(0,0.9)中采样...第10个数据从N(0,0.1)中采样
d1=torch.randn(3,3)
np.array创建规则
np.random的各种生成随机数方法_雪山飞狐-CSDN博客
写代码的统一规范：随机种子设置
SEED = 1210
def seed_everything(seed):
random.seed(seed)
os.environ["PYTHONHASHSEED"] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
seed_everything(SEED) #设置几乎所有的随机种子 随机种子，可使得结果可复现
#在写代码得时候 统一使用 FloatTensor:torch.float32类型进行计算：按照一下格式：
PyTorch出现错误“RuntimeError: Found dtype Double but expected Float”
如果a[FloatTensor]和b[DoubleTensor]是两个参与运算的张量，且有运算代码“loss = criterion(a,b)”,则会引发上面的问题。
使用double()则会占用很多显存
过用double():torch.float64 进行运算，不过这样显存占用会增大许多，而很可能出现显存爆炸的情况，所以最后还是使用FloatTensor:torch.float32类型。
Pytorch里的tensor创建时默认是Torch.FloatTensor类型（torch.float32)
torch.set_default_tensor_type(torch.FloatTensor) #如果想要创建变量类型都是Float32 类型
#创建 np.array的时候
a = np.array([2,3.2])
a.dtype = 'float32'
# numpy转 tensor
b=torch.from_numpy(a)# 数据类型不变
# 创建tensor的时候
d=torch.FloatTensor([2,3.2])
# 列表转tensor
list_1=[2,3.2]
d=torch.Tensor(list_1) # torch.set_default_tensor_type(torch.FloatTensor) 这句话的作用
# print(d.dtype) #torch.float32
# 一个小数直接转化成tensor
t=torch.Tensor([3.01]) #torch.set_default_tensor_type(torch.FloatTensor) 这句话的作用
print(t)
print(t.dtype)
# tensor([3.0100])
# torch.float32
# 一个整数直接转化成 tensor
y=torch.Tensor([5]) #torch.set_default_tensor_type(torch.FloatTensor) 这句话的作用
print(y)
print(y.dtype)
# tensor([5.])
# torch.float32
e=torch.Tensor(2) # 随机产生 数据tensor #torch.set_default_tensor_type(torch.FloatTensor) 这句话的作用
print(e)
print(e.dtype)
# tensor([0.0000, 2.3125])
# torch.float32
np.array 矩阵填充到固定长度
appended = np.zeros((20,5))
appended[10:, :] = np.ones((1,5))[0]
print(appended)
1、什么是生成器？
生成器仅仅保存了一套生成数值的算法，并且没有让这个算法现在就开始执行，而是我什么时候调它，它什么时候开始计算一个新的值，并给你返回。
2、为什么要用生成器？
列表所有数据都在内存中，如果有海量数据的话将会非常耗内存。
如：仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
如果列表元素按照某种算法推算出来，那我们就可以在循环的过程中不断推算出后续的元素，这样就不必创建完整的list，从而节省大量的空间。
简单一句话：我又想要得到庞大的数据，又想让它占用空间少，那就用生成器
a=(x*2 for x in range(10))
print(list(a))
a=(x*2 for x in range(10))
print(a)
for i in a:print(i)
方法二， 如果一个函数中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator。调用函数就是创建了一个生成器（generator）对象。
def foo():
print("starting...")
while True:
res = yield 4
print("res:",res)
g = foo()
print(next(g))
print("*"*20)
print(next(g))
print("*"*20)
print(g.send(7))
yield 就是在程序中返回某个值，返回之后程序就不再往下运行了 。下一次调用这个函数的时候会接着这个 yield 的下一句代码执行。
1.程序开始执行以后，因为foo函数中有yield关键字，所以foo函数并不会真的执行，而是先得到一个生成器g(相当于一个对象)
2.直到调用next方法，foo函数正式开始执行，先执行foo函数中的print方法，然后进入while循环
3.程序遇到yield关键字，然后把yield想想成return,return了一个4之后，程序停止，并没有执行赋值给res操作，此时next(g)语句执行完成，所以输出的前两行（第一个是while上面的print的结果,第二个是return出的结果）是执行print(next(g))的结果，
4.程序执行print("*"*20)，输出20个*
5.又开始执行下面的print(next(g)),这个时候和上面那个差不多，不过不同的是，这个时候是从刚才那个next程序停止的地方开始执行的，也就是要执行res的赋值操作，这时候要注意，这个时候赋值操作的右边是没有值的（因为刚才那个是return出去了，并没有给赋值操作的左边传参数），所以这个时候res赋值是None,所以接着下面的输出就是res:None,
6.程序会继续在while里执行，又一次碰到yield,这个时候同样return 出4，然后程序停止，print函数输出的4就是这次return出的4.
7.程序执行g.send(7)，程序会从yield关键字那一行继续向下运行，send会把7这个值赋值给res变量
8.由于send方法中包含next()方法，所以程序会继续向下运行执行print方法，然后再次进入while循环
9.程序执行再次遇到yield关键字，yield会返回后面的值后，程序再次暂停，直到再次调用next方法或send方法。
pandas datetime 模块的使用：
# 先用这个函数来识别这一列 ：
train2018['Time_time'] = pd.to_datetime(train2018['Time'])
train2019['Time_time'] = pd.to_datetime(train2019['Time'])
train2020['Time_time'] = pd.to_datetime(train2020['Time'])
test['Time_time'] = pd.to_datetime(test['Time'])
# 就可以根据这个固定的格式来进行筛选了
train2019Mon2 = train2019[(train2019['Time_time'] >= '2019-2-1') & (train2019['Time_time'] <= '2019-2-28')]
train2019Mon1 = train2019[(train2019['Time_time'] >= '2019-1-1') & (train2019['Time_time'] <= '2019-1-28')]
匿名函数 ：a= lambda x,y: (x*y+1,y**2)
a= lambda x,y: (x*y+1,y**2)
# 输入变量： 输入的变量进行什么操作
print(a(3,2))
# 结果：
(7, 4)
异常处理：
try:
data=pd.read_csv("www.csv")
except : # 跳过所有类型的异常 也可以写上异常的命名称
print ("Error: 没有找到文件或读取文件失败")
pandas DataFrame表格 根据删除重复的行
df.drop_duplicates() #保留第一个值，返回副本
df.drop_duplicates(keep='last') #保留最后一个值，返回副本
df.drop_duplicates(keep=False) #删除所有重复值，返回副本
df.drop_duplicates('k1') #删除第一列重复值，返回副本
df.drop_duplicates(['k1','k2']) #删除全部列重复值，返回副本
pandas DataFrame表格 根据某一列数值进行排序
# 按照行生成 DataFrame
daliebiao=[]
daliebiao.append(["wang",5,])
daliebiao.append(["song",1,])
daliebiao.append(["chen",0])
columns=["名字","idx"]
df=pd.DataFrame(data=daliebiao,columns=columns)
print(df)
df=df.sort_values('idx').drop_duplicates()
print(df)
最近在造dataset的时候，突然发现，在输入图像转tensor的时候，我可以用torch.Tensor直接强制转型将numpy类转成tensor类，也可以用torch.from_numpy这个方法将numpy类转换成tensor类，那么，torch.Tensor和torch.from_numpy这两个到底有什么区别呢？既然torch.Tensor能搞定，那torch.from_numpy留着不就是冗余吗？
有区别，使用torch.from_numpy更加安全，使用tensor.Tensor在非float类型下会与预期不符。
s=[1,2,3]
print(s[-1])
print(s[-2])
列表循环生成字典
b=[1,2,3,4,]
a={word: idx for idx, word in enumerate(b)}
b={idx: word for idx, word in enumerate(b)}
print(a)
print(b)
字符串列表 逆置
a = 'Python is a powerful languange.'
re_a = a[::-1]
print(re_a)
得到列表元素的下标
a = ['a', 'b', 'c', 'd', 'e', 'f']
a_i = a.index("b")
print(a_i)
把列表的元素转化成一个字符串
string = ['a','b','c','d','e','f','g']
s=''.join(string)
print(s)
ｉｆ ｅｌｓｅ 语句 简写
a=0
a=100 if a>-1 else 1
print(a)
a=0
a="你好" if a>-1 else 1
print(a)
python 定义单链表结构
class Node():
'''定义单链表节点类'''
def __init__(self,data,next = None):
'''data为数据项，next为下一节点的链接，初始化节点默认链接为None'''
self.data = data
self.next = next
# 定义3个节点对象分别为node1、node2和node3
node1 = Node(1,None)
node2 = Node(2,node1)
node3 = Node(3,node2)
print(node1.next,node2.next ,node3.next)
print(node1.data,node2.data ,node3.data)
列表元素逆置
lists = [1,3,4,5,6,7,9,2]
# 切片
print(lists[::-1])
获取目录文件下面的文件名称
query_namejpg= os.listdir("samples_test_support/query/0")
print(query_namejpg[0:10])
class aceshi():
def __init__(self,sum):
self.sum=sum
def call(self,d):
return self.sum*d
aceshi=aceshi(4) # 实例化对象 就相当于倪创建了一个对象 对象有sum 这个属性 然后你在实例化你这个对象的时候 要 把 sum这个属性赋值
a=aceshi.call(4) # def call(self,d):对象中定义了一个函数 ，需要传入一个外部的参数 d 所以你先实例化 对象然后再从 外部传参数 ！
print(a)
class aceshi():
def __init__(self,sum):
self.sum=sum
def call(self,d):
return self.sum*d
a=aceshi(4).call(2) # 实例化对象
print(a)
正如前面所说的，args类型是一个tuple元组，而kwargs则是一个字典dict，并且args只能位于kwargs的前面。
**kwargs则是将一个可变的关键字参数的字典传给函数实参，同样参数列表长度可以为0或为其他值
*args就是就是传递一个可变参数元组给函数实参 不是列表，这个参数列表的数目未知，甚至长度可以为0
# 正如前面所说的，args类型是一个tuple，而kwargs则是一个字典dict，并且args只能位于kwargs的前面。代码的运行结果如下
# **kwargs则是将一个可变的关键字参数的字典传给函数实参，同样参数列表长度可以为0或为其他值
# *args就是就是传递一个可变参数元组给函数实参 不是列表，这个参数列表的数目未知，甚至长度可以为0
def test_kwargs(first, *args, **kwargs):
print('first: ', first)
print(type(kwargs))
for v in args:
print ('v in (args): ', v)
for k, v in kwargs.items():
print (k, v)
test_kwargs(1, 2, 3, 4, k1=5, k2=6,k3=0)
class Dog():# 类的首字母要大写
def __init__(self,name,age):
# self会自动传递后边的参数 name,age
self.name=name
self.age=age
def sit(self):
print(self.name.title())
return self.name.title()+"—+sit()"
def roll(self):
print(self.age)
def modify_age(self,name1):
self.age=name1
class Dog_son(Dog):
def __init__(self,name,age):#初始化父类的属性
super().__init__(name,age) # super 超类
self.high="170" #子类新建的属性
def high_1(self):
print(self.name,self.age,self.high)
def high_2(self):
print(self.name,self.age,self.high)
return self.name+"--"+self.age+"--"+self.high
def roll(self):
print("重写父类roll方法")
print("------类实例化+打印类属性值-------")
my_dag=Dog("wang","19")
print(my_dag.name)
print(my_dag.age)
print("------类实例化+调用类函数-------")
sit=my_dag.sit()
roll=my_dag.roll()
print(sit)
print(roll)
print("------创建多个实例化类-------")
you_dog=Dog("周","26")
print(you_dog.name)
print("-----类：属性赋值-----")
Dog.name="王"
Dog.age="22"
print(Dog.name)
print(Dog.age)
print("-----类实例化：修改属性值-----")
you_dog.age="100"
print(you_dog.name)
print(you_dog.age)
print("-----类里定义函数：修改属性值-----")
her_dog=Dog("张","10")
her_dog.modify_age("30")
print(her_dog.age)
print("-----继承父类+子类新建赋值+函数操作-----")
a_dog=Dog_son("李","21")
print(a_dog.high_1())
print(a_dog.high_2())
print("-----继承父类+重写父类方法+子类调用父类方法+函数操作-----")
a_dog=Dog_son("李","21")
print(a_dog.sit())
print(a_dog.roll())
class Dog():# 类的首字母要大写
def __init__(self,name,age):
# self 这时候调用类或者实例化，必须传入参数！
self.name="王"
self.age="00"
def prin(self):
print(self.name,self.age)
a=Dog("张","10")# 传参也不管用 还是使用的：self.name="王" self.age="00"这两个参数
print(a.prin())
class Dog_t():# 类的首字母要大写
def __init__(self,name,age):
# self 这时候调用类或者实例化，必须传入参数！
self.name=name
self.age=age
def prin(self):
print(self.name,self.age)
a=Dog_t("张","10")# 使用传入的参数,Dog_t("张","10")
print(a.prin())
class Dog_g():# 类的首字母要大写
def __init__(self):
# self后边没东西，这时候不需要串参数！
self.name="wang"
self.age="00"
def prin(self):
print(self.name,self.age)
a=Dog_g() # Dog("张","10") 传参会报错！
print(a.prin())
from functools import reduce
n = 3
print(reduce(lambda x,y:x*y,range(1,n+1)))
np.random的各种生成随机数矩阵的方法
np.random的各种生成随机数方法_雪山飞狐-CSDN博客
生成全0tensor
a=torch.zeros(1,len(matrix[0]),dtype=torch.float64)[0]
print(a)
python内置函数
1)对于一个列表排序
sorted([100, 98, 102, 1, 40])
>>>[1, 40, 98, 100, 102]
2)通过key参数/函数
比如一个长列表里面嵌套了很多字典元素，我们要按照每个元素的长度大小排序
L = [{1:5,3:4},{1:3,6:3},{1:1,2:4,5:6},{1:9}]
new_line=sorted(L,key=lambda x:len(x))
print(new_line)
>>>[{1: 9}, {1: 5, 3: 4}, {1: 3, 6: 3}, {1: 1, 2: 4, 5: 6}]
3)对由tuple组成的List排序
students = [('wang', 'A', 15), ('li', 'B', 12), ('zhang', 'B', 10)]
print(sorted(students, key=lambda student : student[2]))
>>>[('zhang', 'B', 10), ('li', 'B', 12), ('wang', 'A', 15)]
4）用cmp函数排序
students = [('wang', 'A', 15), ('li', 'B', 12), ('zhang', 'B', 10)]
print(sorted(students, cmp=lambda x,y : cmp(x[0], y[0])) )
>>>[('li', 'B', 12), ('wang', 'A', 15), ('zhang', 'B', 10)]
2.map()
map可以根据提供的函数对指定序列做映射，它接受一个函数f和一个list,并通过把函数f以此作用在list上的每个元素，然后返回一个新的list,map函数的入参也可以是多个.注意这个函数一定要有返回值(值值值重要的说三遍)。
不然就会返回新的list 类似[None, None, None, None, None, None, None, None, None]
3.enumerate()
Python中，迭代永远是取出元素本身，而非元素的索引,有的时候我们需要知道元素的索引比如在一个很长的列表里面是一些网站名，我们希望在打印的时候，也能列出索引。若没有这个函数，我们需要在加一个变量，在循环打印的时候让这个计数变量递增，现在有了enumerate，就不用这么麻烦了，直接搞定.
4.zip()
zip函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表
x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
xyz = zip(x, y, z)
>>print xyz
5.filter()
filter函数接受一个函数f和一个list,这个函数f的作用是对每个元素进行判断,返回True或者False,这样可以过滤掉一些不符合条件的元素，然后返回符合条件的list.
def is_even(x):
return x%2==0
print(filter(is_even,[1,2,3,4,5]))
>>>[2, 4]
6.reduce()
注意在python3里面reduce已经从全局函数里面移除了，需要用的话要from functools import reduce
reduce函数的用法和map很类似,也是一个函数f和一个list,但是函数的入口参数一定要是两个，reduce也是对每个元素进行反复调用，最后返回最终的值，而map是返回一个list
x=[1,2,3,2,1,3,4,5,4,3,2,1,1]
x_one_hot=tf.keras.utils.to_categorical(x)
print(x_one_hot)
对列表进行从小到大排序 返回 排序后原来元素的下标
sorted_id = sorted(range(len(result)), key=lambda k: result[k], reverse=False)# 对列表进行从小到大排序 返回 排序后原来元素的下标
py固定范围生成固定个数的随机数
a= random.sample(range(0, 23826), 23826) me v 18340082396
py固定范围产生一个随机小数
t=random.uniform(0,1)
print(t)
if break 跳出for 循环 的先后问题
t=0
for a in seg:
try:
vec = wd2[a] #从词库里面取出这些词对应的向量
# print(vec)
except KeyError: #当在词向量模型中没有这个单词的向量的时候可以设置错误跳过 然后把这个单词的向量设置为全0
vec=np.zeros((1,200))
meihang_wenben_juzhen[int(t)]=vec
if t==300:
break 这个地方break跳出for 循环 后边的 print(t)还会执行 只是说 下一个for 循环不执行了
t=t+1
print(t)
字典循环取值：
print(type(sum_day_data_train_x[0][0][-1]))
print(sum_day_data_train_x[0][0][-1])
for key in sum_day_data_train_x[0][0][-1].keys():
print(key)
for value in sum_day_data_train_x[0][0][-1].values():
print(value)
from collections import Counter
for key in Counter(quanbu_juzi).items():
word.append(key[0])
summ.append(key[1])
列表求均值 最大值 最小值 中位数
print(np.mean(length))# 均值
print(max(length))# 最大值
print(min(length))# 最小值
a=np.median(length)# 中位数
print(a)
tensor 取值
值.item()
读取 txt 读取 csv 打开任意格式的文件
data=pd.read_csv('nextlinks.txt',encoding='utf-8',sep=' ',delimiter="\t")
data.values
model=[]
with open('ranksvm/gnonormalizationmodel', 'r') as f:
for line in f:
model.append(line)
model=model[-1].split(" ")[1:-1]文件夹改名 + 文件先改名在移动
# 题目要求：有这样的文件夹 然后要求合并到一个大的文件夹
为了避免重复应该先改名 然后再合并：
文件改名代码：
import os
import shutil
Olddir=os.path.join("0005/","1.jpg") # 原来的文件路径
Newdir=os.path.join("0005/",(str("5_")+"1.jpg")) # 新的文件路径
print(Olddir)
print(Newdir)
os.rename(Olddir,Newdir)
文件移动加改名：
import os
import shutil
for i in range(6,9,1): # 几个文件夹
# 原文件夹
old_path = str(str("0")*(4-len(str(i)))+str(i))
# 查看原文件夹下所有的的文件
filenames = os.listdir(old_path)
target_path = "合并" # 新文件夹
if not os.path.exists(target_path):
os.mkdir(target_path)
print("filenames",filenames)
for file in filenames:# 遍历每个图片文件
#改名：
Olddir=os.path.join( old_path+str("/"),file) # 原来的文件路径
filename=os.path.splitext(file)[0] # 文件名
Newdir=os.path.join(str(old_path)+str("/"),str(str(i)+"_")+str(file)) # 新的文件路径
os.rename(Olddir,Newdir) # 改名
# 将文件移动到新文件夹中
shutil.move(Newdir, target_path)
def visualize_model(model):
daliebiao=[]
model.eval（)
fig = plt.figure()
with torch.no_grad():
for i, inputs in tqdm(enumerate(dataloaders_query["query"])):
pred_jpgname_label=[]
inputs = inputs[0].to(device)
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
pred_jpgname_label.append(query_namejpg[i])
pred_jpgname_label.append(preds.item()+201)
daliebiao.append(pred_jpgname_label)
return daliebiao
daliebiao=visualize_model(cnn_model)
columns=["filename","label"]
df=pd.DataFrame(data=daliebiao,columns=columns)
df.to_csv('submit_sample.csv')
seg=["11","ss","334e"]
seg=" ".join(i for i in seg)
print(seg)
11 ss 334e
把数据从gpu拿到cpu
outputs = bert_classifier_model(input_ids,attention_mask)
outputs = outputs.cpu().numpy()
文本分词处理
juzi=[]
for i in train_data:
zifuchuan=""
for ii in re.findall('[\u4E00-\u9FA5\\s]',i):
zifuchuan=zifuchuan+str(ii)
zifuchuan=zifuchuan.replace(" ","")
seg = jieba.lcut(zifuchuan)
seg=" ".join(i for i in seg)
juzi.append(seg)
李雪莉 数据处理
zonghe=[]
a=["01", "02", "03", "04", "05","06", "07", "08", "09", "10","12"]
for i in a:
data=pd.read_excel("2020年社保医疗明细/医疗明细2020"+str(i)+".xlsx")
a=data.sum() # 数据按列求和
zonghe.append(a)
data1=pd.read_excel("2020年社保医疗明细/医疗明细2020"+str("01")+".xlsx")
print(len(data1.columns))
print(data1.columns)
zong=pd.DataFrame(np.array(zonghe))
# print(zong)
print(len(list(zong.sum())))
print(list(zong.sum()))
pandas 基础
datxt=pd.read_csv("./测试.txt",sep='\t',header=None,names=["1","2"])
# 列分隔符 sep # \t 空格 \n 表示换行 names 表示自己设置列名
data.columns
data[['w','z']] #选择表格中的'w'、'z'列
df=df.fillna(0)#所有的空值都填0 。df中的内容没有变。na代表空值 print(data.fillna(0))
data.shape
data.index
data.dtypes
data.describe()
data["AQI"].unique() # 有多少个不一样的取值
data.cov()# 协方差
data.corr()
# 删除 date这一列
data.drop("date",axis=1)
# 删除某一行 # 删除的是第一行
data.drop(0,axis=0)
# 每行求一个均值
data.mean(axis=1)
# 每列求一个均值
data.mean(axis=0)
data["PM10"].corr(data["PM2.5"]) # 查看两列的相关系数
# 创建Series dataframe中的一行或者一列数据
sdata=pd.Series([11,23,33,42],index=[1,2,3,4])
print(sdata)
sdata=pd.Series({1:"王",2:"33",3:"ee"})
print(sdata)
# 查询Series =查询字典
print(sdata[1]) 就是查询 1 对应的 王
# 自己创建dataframe
data={
"数字":[1,2,3,4],
"字母":["w","e","r","t"]
}
sdata=pd.DataFrame(data)
data[['date', 'hour', 'AQI']]# 查询多列
data.loc[1] # 查询一行
data.loc[1:9]#查询多行 把把最后一个9也包含了
# 设置某一列数据来代替index, 这一列数据不删除：drop=False，删除是用True
data.set_index("date",inplace=True,drop=False)
# 查找值
data.loc["20131205",["AQI","PM10"]] # 查询索引是20131205 列是 "AQI","PM10" 两个值
# 查询好几个索引的值
data.loc[["20201231","20131205"],["AQI","PM10"]]
# 查询 值
data["AQI"]==47.0 # 返回的是一个 Series 布尔值
# 条件查询
data.loc[data["AQI"]==47.0,:]# 先选取行，后选取列：是取全部的列
# 多条件查询
data.loc[(data["AQI"]==47.0)&(data["PM10"]<=12.0),:]
# 统计一列数据的 数据分布
data["AQI"].value_counts() # 每个值出现了多少次
# 列的修改：
# 对某一列进行修改
data.loc[:,"hour"]=0.00 # 把这一列的数据都设置为0
data.loc[:,"hour"].astype("int32") # 修改数据类型
data.loc[:,"hour"]=data["AQI"]-data["PM10"]
# 用汉字的描述来代替列数据中的值
def aqi_react(x):
if x["PM10"]>100:
return "严重"
else:
return "一般"
data.loc[:,"AQI"]=data.apply(aqi_react,axis=1)
# 新增一列 不是在原来的数据上进行修改的 是产生了一个新的对象
a=data.assign(
xinzeng=data["AQI"] #列名是 xinzeng
)
# 新建一列但是这一列数据是根据前边的数据操作而创建的
data["条件创建列"]="" # 创建空列
data.loc[(data["PM2.5"]>80)&(data["PM10"]>80),"条件创建列"]="天气污染严重" # 对新建的空列进行赋值
# pandas缺失值的处理
data=pd.read_excel("./第一部分.xlsx")# 有一个参数是 skiprows 是掠过几个空行的意思
data.isnull() # False True 来表示数据
data["AQI"].isnull()
# 筛选没有空值得 AQI 得所有行
data.loc[data["AQI"].notnull(),:]
# 删除掉全是空值得列
data.dropna(axis="columns",how="all",inplace=True)
#删除掉全是空值得行
data.dropna(axis="index",how="all",inplace=True)
# 把某列 数值 为空得值 填充为 什么
data["PM10"]=data["PM10"].fillna(2) # fillna(method="ffill") # 空值处使用前边得值进行填充 bfill 是后边得值进行填充
# pandas对数据进行排序
data.sort_values(by=["PM10"],ascending=False) #行根据某个值进行排序 False是降序
data.sort_values(by=["PM10","PM2.5"],ascending=[False,True]) #行根据多个列值 进行排序 升序还是降序
# pandas 索引的index的用处
# 随机打乱数据
# 魔法函数看函数的执行时间 %timeit
from sklearn.utils import shuffle
%timeit data_sh=shuffle(data)
# 按照某一列数据进行分组
df=data.groupby("date")
df.head()统计列表中相同元素得个数 然后取相同次数最多得前多少名画图 from collections import Counter
from collections import Counter
forword_wors_count=Counter(forword_wors)
word=[]
summ=[]
for key in Counter(forword_wors_count).items():
word.append(key[0])
summ.append(key[1])
sorted_id = sorted(range(len(summ)), key=lambda k: summ[k], reverse=True)
sorted_word=[]
for i in sorted_id[0:20]:
sorted_word.append(word[i])
sorted_sum=[]
for i in sorted_id[0:20]:
sorted_sum.append(summ[i])
plt.rcParams["font.sans-serif"] = ['Simhei']
plt.rcParams["axes.unicode_minus"] = False
import pandas as pd
import matplotlib.pyplot as plt
plt.figure(figsize=(10,50))#设置画布的尺寸
plt.title('词频统计图',fontsize=20)#标题，并设定字号大小
plt.xlabel(u'词',fontsize=14)#设置x轴，并设定字号大小
plt.ylabel(u'数目',fontsize=14)#设置y轴，并设定字号大小
#alpha：透明度；width：柱子的宽度；facecolor：柱子填充色；edgecolor：柱子轮廓色；lw：柱子轮廓的宽度；label：图例；
plt.bar(sorted_word,sorted_sum, alpha=0.2,width = 0.8, facecolor = 'deeppink', edgecolor = 'darkblue', lw=1,)
plt.legend(loc=2)#图例展示位置，数字代表第几象限
plt.show()#显示图像
nn.Embedding(20,3)
词汇表所有单词的个数 可以比实际的数量多 后边是每个单词的维度定义 是一个几维的向量
embedding=nn.Embedding(20,3)
input=torch.LongTensor([[1,2,4,5],[4,3,2,9]])
embedding(input)
a=[[1,2,3] for i in range(5)]
import torch
A=torch.ones(4,3) #2x3的张量（矩阵）
B=2*torch.ones(4,3)#4x3的张量（矩阵）
print(A)
print(B)
C=torch.cat((A,B),1)#按维数0（行）拼接
print(C)
import torch
A=torch.ones(4,3) #2x3的张量（矩阵）
B=2*torch.ones(4,3)#4x3的张量（矩阵）
print(A)
print(B)
C=torch.cat((A,B),0)#按维数0（行）拼接
print(C)
# 并且相乘的两个矩阵，要满足一定的维度要求：input（p,m,n) * mat2(p,n,a) ->output(p,m,a)。
import torch
batch1 = torch.randn(8, 2, 6)
batch2 = torch.randn(8, 6, 10)
res = torch.bmm(batch1, batch2)
print(res.size())
torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor)
沿给定dim维度返回输入张量input中 k 个最大值。
如果不指定dim，则默认为input的最后一维。
如果为largest为 False ，则返回最小的 k 个值。
返回一个元组 (values,indices)，其中indices是原始输入张量input中测元素下标。
如果设定布尔值sorted 为_True_，将会确保返回的 k 个值被排序。
