【无标题】

最新推荐文章于 2024-01-04 16:34:47 发布

啦啦啦……~

最新推荐文章于 2024-01-04 16:34:47 发布

阅读量234

点赞数

文章标签： python pandas

本文链接：https://blog.csdn.net/qq_45032870/article/details/127532428

版权

np.unique和pd.nunique

np.unique用法
返回参数数组中所有不同的值，并按照从小到大排序,用于list
pd.nunique()
可直接统计dataframe中每列的不同值的个数,也可用于series,但不能用于list.返回的是不同值的个数

import numpy as np
import pandas as pd
A = [1, 2, 1, 3, 1, 3,4]
C=pd.Series(A)
print("原列表：", A)
print("--------------------------")
# return_index=True： 返回新列表中的每个元素在原列表中第一次出现的索引值，因此元素个数与新列表中元素个数一样
# return_inverse=True：返回原列表中的每个元素在新列表中出现的索引值，因此元素个数与原列表中元素个数一样
# 返回全部三个参数值
a, s, p = np.unique(C, return_index=True, return_inverse=True)
aa=np.unique(A, return_index=True, return_inverse=True)[0]
ss=np.unique(A, return_index=True, return_inverse=True)[1]
pp=np.unique(A, return_index=True, return_inverse=True)[2]

c=C.nunique()
print(c)
print("新列表：", a)
print("aa和a一样嘛", a == aa )
print("return_index", s)
print("ss和s一样嘛", s==ss)

df=pd.DataFrame({'A':[0,1,1],'B':[0,5,6]})
print(df)
print(df.nunique())
#    A  B
# 0  0  0
# 1  1  5
# 2  1  6
# A    2
# B    3
# dtype: int64
all_user_repay = all_user_repay.groupby(['user_id'])['listing_id'].agg(['nunique']).reset_index()
#    user_id  nunique
# 0       40        1
# 1       56        1
# 2       98        1
# 3      103        1
# 4      122        1

嵌入会用到
C是索引，取a里面的值

C=pd.Series((1,2,3,4,5,0,1,4,5,1))
print(C)
a=pd.array([12,45,5,1,2,3,5])
b=a[C]
print(b)
# 0    1
# 1    2
# 2    3
# 3    4
# 4    5
# 5    0
# 6    1
# 7    4
# 8    5
# 9    1
# dtype: int64
# <IntegerArray>
# [45, 5, 1, 2, 3, 12, 45, 2, 3, 45]
# Length: 10, dtype: Int64

a.view()

作用为调整形状大小，-1为动态调整

v1 = torch.range(1, 16) 
v2 = v1.view(-1, 4) #v2的shape为4*4，

torch.matmul

矩阵相乘。对于二维，就是矩阵相乘，对于高维的，前面的维度必须要相同，然后最里面的两个维度符合矩阵相乘的形状限制：i×j，j×k。所以对于神经网络，两个维度的矩阵相乘一般需要

torch.matmul(q, k.transpose(-2, -1))

pytorch中的contiguous()

当调用contiguous()时，会强制拷贝一份tensor，让它的布局和从头创建的一模一样，但是两个tensor完全没有联系。
具体看http://t.csdn.cn/L2Nj6

masked_fill

masked_fill方法有两个参数，maske和value，mask是一个pytorch张量（Tensor），元素是布尔值，value是要填充的值，填充规则是mask中取值为True位置对应于self的相应位置用value填充。

masked_fill_(mask, value) 。in-place version 在 PyTorch 中是指当改变一个 tensor 的值的时候，不经过复制操作，而是直接在原来的内存上改变它的值。
masked_fill(mask, value)。out-of-place version 在 PyTorch 中是指当改变一个 tensor 的值的时候，经过复制操作，不是直接在原来的内存上改变它的值，而是修改复制的 tensor

可以进行广播

import torch
a=torch.tensor([[[5,5,5,5], [6,6,6,6], [7,7,7,7]], [[1,1,1,1],[2,2,2,2],[3,3,3,3]]])
print(a)
 # tensor([[[5, 5, 5, 5],
 #         [6, 6, 6, 6],
 #         [7, 7, 7, 7]],
 # 
 #        [[1, 1, 1, 1],
 #         [2, 2, 2, 2],
 #         [3, 3, 3, 3]]])
print(a.size())
#torch.Size([2, 3, 4])
mask = torch.ByteTensor([[[0]],[[1]]])
print(mask)
# tensor([[[0]],
# 
#         [[1]]], dtype=torch.uint8)
print(mask.size())
# torch.Size([2, 1, 1])
bb= a.masked_fill(mask==0, value=torch.tensor(111))#为True的时候，用111进行填充
print(bb)
# tensor([[[111, 111, 111, 111],
#          [111, 111, 111, 111],
#          [111, 111, 111, 111]],
# 
#         [[  1,   1,   1,   1],
#          [  2,   2,   2,   2],
#          [  3,   3,   3,   3]]])
mask1 = torch.tensor([True,False,False,False])
mask2 = torch.tensor([True])
print(mask1.size())
# torch.Size([4])
b = a.masked_fill(mask1, value=torch.tensor(111))#为True的时候，用111进行填充
b1 = a.masked_fill(mask1==1, value=torch.tensor(111))#True为1，False为0
b2 = a.masked_fill(mask2, value=torch.tensor(111))
print(b)
# tensor([[[111,   5,   5,   5],
#          [111,   6,   6,   6],
#          [111,   7,   7,   7]],
# 
#         [[111,   1,   1,   1],
#          [111,   2,   2,   2],
#          [111,   3,   3,   3]]])
print(b1)
# tensor([[[111,   5,   5,   5],
#          [111,   6,   6,   6],
#          [111,   7,   7,   7]],
# 
#         [[111,   1,   1,   1],
#          [111,   2,   2,   2],
#          [111,   3,   3,   3]]])
print(b2)
# tensor([[[111, 111, 111, 111],
#          [111, 111, 111, 111],
#          [111, 111, 111, 111]],
# 
#         [[111, 111, 111, 111],
#          [111, 111, 111, 111],
#          [111, 111, 111, 111]]])

torch.cumsum

q1 = torch.arange(0, 16).view(2, 2, 4)
print(q1)
w1 = torch.cumsum(q1, dim=0)  
e1 = torch.cumsum(q1, dim=1)  
r1 = torch.cumsum(q1, dim=2)  
t1 = torch.cumsum(q1, dim=-1)  
print(w1)
print(e1)
print(r1)
print(t1)
tensor([[[ 0,  1,  2,  3],
         [ 4,  5,  6,  7]],

        [[ 8,  9, 10, 11],
         [12, 13, 14, 15]]])原输出
tensor([[[ 0,  1,  2,  3],不变
         [ 4,  5,  6,  7]],不变

        [[ 8, 10, 12, 14],dim为0，第一层不变，第二层加上第一层
         [16, 18, 20, 22]]])8+0，9+1，10+2，类比
tensor([[[ 0,  1,  2,  3],不变
         [ 4,  6,  8, 10]],dim为1，第一行不变，第二行累加第一行
							4+0，5+1，6+2，类比
        [[ 8,  9, 10, 11],不变
         [20, 22, 24, 26]]])
tensor([[[ 0,  1,  3,  6],dim为2，第一列不变，后面的累加前面的列
         [ 4,  9, 15, 22]],0，4，8，12不变，0+1，0+1+2，0+1+2+3类比

        [[ 8, 17, 27, 38],
         [12, 25, 39, 54]]])
tensor([[[ 0,  1,  3,  6],
         [ 4,  9, 15, 22]],

        [[ 8, 17, 27, 38],
         [12, 25, 39, 54]]])