精华内容
下载资源
问答
  • np.random.permutation
    2021-03-10 15:59:11

    现象

    我们发现np.random.permutation要比np.random.shuffle快很多

    x = np.random.rand(50000, 2)
    # 933 µs 
    %timeit x.take(np.random.permutation(x.shape[0]), axis=0)
    # 1.41 ms
    %timeit x[np.random.permutation(x.shape[0])]
    # 1.41 ms
    %timeit np.random.permutation(x)
    # 46.3 ms
    %timeit np.random.shuffle(x)
    
    933 µs ± 2.74 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    1.41 ms ± 5.87 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    1.41 ms ± 4.22 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    46.3 ms ± 413 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
    

    原因

    np.random.shuffle 是原地修改数组,因此需要开辟一个buffer作为交换空间buf = np.empty_like(x[0]),而且需要for循环反复交换

    # https://github.com/numpy/numpy/blob/18f2385b29bdd62701a1a82d7bf33fd87430a05e/numpy/random/mtrand/mtrand.pyx#L4841
        # Shuffling and permutations:
        def shuffle(self, object x):
            """
            shuffle(x)
            Modify a sequence in-place by shuffling its contents.
            This function only shuffles the array along the first axis of a
            multi-dimensional array. The order of sub-arrays is changed but
            their contents remains the same.
            """
            # ......
            elif isinstance(x, np.ndarray) and x.ndim > 1 and x.size:
                # Multidimensional ndarrays require a bounce buffer.
                buf = np.empty_like(x[0])
                with self.lock:
                    for i in reversed(range(1, n)):
                        j = rk_interval(i, self.internal_state)
                        buf[...] = x[j]
                        x[j] = x[i]
                        x[i] = buf
    

    np.random.permutation 是返回一个新数组,因此只用shuffle idx即可,比较快

    # https://github.com/numpy/numpy/blob/18f2385b29bdd62701a1a82d7bf33fd87430a05e/numpy/random/mtrand/mtrand.pyx#L4917
        def permutation(self, object x):
            """
            permutation(x)
            Randomly permute a sequence, or return a permuted range.
            If `x` is a multi-dimensional array, it is only shuffled along its
            first index.
            """
            # ......
            # Shuffle index array, dtype to ensure fast path
            idx = np.arange(arr.shape[0], dtype=np.intp)
            self.shuffle(idx)
            return arr[idx]
    
    更多相关内容
  • np.random.permutation函数

    千次阅读 2022-06-03 23:31:21
    np.random.permutation函数的作用就是按照给定列表生成一个打乱后的随机列表

    目录

    一:函数介绍

    二:实例

    2.1 直接处理数组或列表数

    2.2 间接处理:不改变原数据(对数组下标的处理)

    2.3 实例:鸢尾花数据中对鸢尾花的随机打乱(可以直接用)


    一:函数介绍

    np.random.permutation() 总体来说他是一个随机排列函数,就是将输入的数据进行随机排列,官方文档指出,此函数只能针对一维数据随机排列,对于多维数据只能对第一维度的数据进行随机排列。

    简而言之:np.random.permutation函数的作用就是按照给定列表生成一个打乱后的随机列表

    在处理数据集时,通常可以使用该函数进行打乱数据集内部顺序,并按照同样的顺序进行标签序列的打乱。

    二:实例

    2.1 直接处理数组或列表数

    import numpy as np

    data = np.array([1,2,3,4,5,6,7])
    a = np.random.permutation(data)
    b = np.random.permutation([5,0,9,0,1,1,1])
    print(a)
    print( "data:", data )
    print(b)

    2.2 间接处理:不改变原数据(对数组下标的处理)

    label = np.array([1,2,3,4,5,6,7])
    a = np.random.permutation(np.arange(len(label)))
    print("Label[a] :" ,label[a] )

    补:一般只能用于N维数组 只能将整数标量数组转换为标量索引

    why?label1[a1]  label1是列表,a1是列表下标的随机排列 但是! 列表结构没有标量索引 label1[a1]报错

    label1=[1,2,3,4,5,6,7]
    print(len(label1))

    a1 = np.random.permutation(np.arange(len(label1)))#有结果

    print(a1)

    print("Label1[a1] :" ,label1[a1] )#这列表结构没有标量索引 所以会报错

    2.3 实例:鸢尾花数据中对鸢尾花的随机打乱(可以直接用)

    from sklearn import svm
    from sklearn import datasets #sklearn 的数据集
    iris = datasets.load_iris()
    iris_x = iris.data
    iris_y = iris.target
    indices = np.random.permutation(len(iris_x))

    #此时 打乱的是数组的下标的排序
    print(indices)
    print(indices[:-10])#到倒数第10个为止
    print(indices[-10:])#最后10个

    # print(type(iris_x))   <class 'numpy.ndarray'>

    #9:1分类
    #iris_x_train = iris_x[indices[:-10]]#使用的数组打乱后的下标
    #iris_y_train = iris_y[indices[:-10]]
    #iris_x_test= iris_x[indices[-10:]]
    #iris_y_test= iris_y[indices[-10:]]    

    数组下标 即标量索引的重新分布情况: 下标是0开始

    展开全文
  • Permutation:(一组事物可能的一种) 序列,排列,排列中的任一组数字或文字; 这个函数的使用来随机排列一个数组的,第一个例子如图1所示: ...permutation = list(np.random.permutation(m)) #m为样本数 s

    Permutation:(一组事物可能的一种) 序列,排列,排列中的任一组数字或文字;
    这个函数的使用来随机排列一个数组的,第一个例子如图1所示:
    在这里插入图片描述
    对多维数组来说,是多维随机打乱而不是1维,例如:
    第一次运行结果(代码在左侧),如图2所示:
    在这里插入图片描述
    第二次运行结果(代码在左侧),如图3所示:
    在这里插入图片描述
    如果要利用次函数对输入数据X、Y进行随机排序,且要求随机排序后的X Y中的值保持原来的对应关系,可以这样处理:
    permutation = list(np.random.permutation(m)) #m为样本数
    shuffled_X = X[permutation]
    shuffled_Y = Y[permutation].reshape((1,m))
    图4中的代码是针对一维数组来说的,(图片中右侧为运行结果):
    在这里插入图片描述
    图5中的代码是针对二维数组来说的,(图片中右侧为运行结果):
    在这里插入图片描述
    代码示例:

    # permutation()函数使用示例
    def testPermutation():
        print("==================打乱数组元素的顺序==================")
        x = np.arange(10).reshape(5, 2)
        print("原数组:")
        print(x)
        x_permutation = np.random.permutation(x)
        print("打乱后的数组:")
        print(x_permutation)
    
        print("\n==================对应打乱2个数组元素的顺序==================")
        print("原数组:")
        x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
        y = np.array([1, 0, 1, 0, 1, 0, 1, 0, 1, 0])
        print(x)
        print(y)
    
        m = 10 # 元素个数
        permutation_array = np.random.permutation(m) # <class 'numpy.ndarray'> [0 7 3 2 1 8 4 6 5 9]
        permutation = list(permutation_array) # [0, 7, 3, 2, 1, 8, 4, 6, 5, 9]
    
        shuffled_X = x[permutation]
        shuffled_Y = y[permutation]
        print("打乱后的数组:")
        print(shuffled_X) # [0 7 3 2 1 8 4 6 5 9]
        print(shuffled_Y) # [1 0 0 1 0 1 1 1 0 0]
    
    

    运行结果:

    **加粗样式**==================打乱数组元素的顺序==================
    原数组:
    [[0 1]
     [2 3]
     [4 5]
     [6 7]
     [8 9]]
    打乱后的数组:
    [[8 9]
     [2 3]
     [4 5]
     [6 7]
     [0 1]]
    
    ==================对应打乱2个数组元素的顺序==================
    原数组:
    [0 1 2 3 4 5 6 7 8 9]
    [1 0 1 0 1 0 1 0 1 0]
    打乱后的数组:
    [5 7 4 9 8 0 3 1 2 6]
    [0 0 1 0 1 1 0 0 1 1]
    
    
    

    shuffle()函数使用示例:
    shuffle() 方法将序列的所有元素随机排序

    # shuffle函数使用示例:
    def testShuffle():
        list = [20, 16, 10, 5]
        np.random.seed(12)
        np.random.shuffle(list)
        print("随机排序列表 : ", list)
        np.random.seed(12)
        np.random.shuffle(list)
        print("随机排序列表 : ", list)
    
    
    **运行结果:**
    
    
    随机排序列表 :  [20, 16, 10, 5]
    随机排序列表 :  [20, 16, 10, 5]
    
    展开全文
  • print(np.random.permutation(4)) print(np.random.permutation(10)) print(np.random.permutation(4)) print("第二次") np.random.seed(0) print(np.random.permutation(10)) print(np.random.permutation(4)) ...

    1 np.random.permutation

    np.random.seed()函数 - 知乎
    https://zhuanlan.zhihu.com/p/266472620

    顺序要一样,每次得到的结果也一样

    import gdal
    import numpy as np
    from PIL import Image
    import matplotlib.pyplot as plt
    from collections import Counter
    import time
    
    # np.random.seed后,np.random.permutation出现的顺序必须一致才对应,否则不对应,可以理解为seed是堆
    np.random.seed(0)
    print(np.random.permutation(10))
    print(np.random.permutation(4))
    print("第一次")
    np.random.seed(0)
    print(np.random.permutation(4))
    print(np.random.permutation(10))
    print(np.random.permutation(4))
    print("第二次")
    np.random.seed(0)
    print(np.random.permutation(10))
    print(np.random.permutation(4))
    print("第三次")
    np.random.seed(0)
    print(np.random.permutation(10))
    print(np.random.permutation(4))
    

    在这里插入图片描述

    2 训练集和验证集

    def get_voc_datagen(train_img_path,train_label_path,val_img_path=None,val_label_path=None,num_class, batch_size, target_size):
        """
        进行文件的读取和预处理
        :param train_img_path:训练集影像文件夹
        :param train_label_path:
        :param val_img_path:如果验证集为None,就从训练集中拿出20%
        :param val_label_path:
        :param num_class:
        :param batch_size:
        :param img_preprocess:
        :param mask_preprocess:
        :param target_size:
        :return:
        """
    
        train_imgs = os.listdir(train_img_path)
        train_labels = os.listdir(train_label_path)
        train_image_paths = [os.path.join(train_img_path, imgname) for imgname in train_imgs]
        train_label_paths = [os.path.join(train_label_path, labelname) for labelname in train_labels]
        # 设置随机数种子,之后打乱数据集
        np.random.seed(0)
        index = np.random.permutation(len(train_image_paths))
        train_image_paths = np.array(train_image_paths)[index]
        train_label_paths = np.array(train_label_paths)[index]
    
        # 如果验证集为None, 就从训练集中拿出20%当作验证集
        if val_img_path == None and val_label_path==None:
            train_number = int(len(train_image_paths) * 0.8)
            val_image_paths = train_image_paths[train_number:]
            val_label_paths = train_label_paths[train_number:]
    
            train_image_paths = train_image_paths[:train_number]
            train_label_paths = train_label_paths[:train_number]
    
        else:
            val_images = os.listdir(val_img_path)
            val_labels = os.listdir(val_label_path)
            val_image_paths = [os.path.join(val_img_path, imgname) for imgname in val_images]
            val_label_paths = [os.path.join(val_label_path, imgname) for imgname in val_labels]
    
        # 检查标签和图像一一对齐
        for i in range(len(train_image_paths)):
            img = train_image_paths[i].split("\\")[-1]
            label = train_label_paths[i].split("\\")[-1]
            if img[:-4] != label[:-4]:
                print("出错了" * 1000)
    
        for i in range(len(val_image_paths)):
            img = val_image_paths[i].split("\\")[-1]
            label = val_label_paths[i].split("\\")[-1]
            if img[:-4] != label[:-4]:
                print("出错了" * 1000)
    	return train_image_paths, train_label_paths,val_image_paths, val_label_paths,
    
    
    展开全文
  • np.randompermutation(x) :不在原数组上进行,返回新的数组,不改变自身数组。 1. np.random.shuffle(x) 1. 对一维数组重新排序: import numpy as np arr = np.arange(10) print(arr) np.random.shuffle(arr)...
  • np.random.permutation() 随机排列序列 多维度
  • np.random.permutation函数的使用

    千次阅读 2021-12-05 11:54:12
    处理后的结果: ...np.random.permutation函数的作用就是按照给定列表生成一个打乱后的随机列表 在处理数据集时,通常可以使用该函数进行打乱数据集内部顺序,并按照同样的顺序进行标签序列的打乱。 ...
  • 1.np.random.permutation() 总体来说他是一个随机排列函数,就是将输入的数据进行随机排列,官方文档指出,此函数只能针对一维数据随机排列,对于多维数据只能对第一维度的数据进行随机排列。 如果还是不太懂的...
  • numpy-np.random.permutation

    2020-11-17 19:17:31
    numpy.random.permutation(x) 作用是:随机置换序列,或返回置换范围。如果x是多维数组,则仅沿其第一个索引随机排列 如果x是整数,则随机置换np.arange(x)。 如果x是一个数组,请进行复制并随机随机排列这些...
  • np.random.beta();np.random.permutation()

    千次阅读 2022-01-01 20:19:01
    np.random.beta: 参考https://www.cnblogs.com/kuangmeng/p/15727345.html numpy.random.beta(a,b,size=None) 从β分布中提取样本。β分布是狄里克莱分布的一个特例,与伽马分布有关。 在这里我们将参数(3个参数)...
  • np.random.permutation()用法

    千次阅读 2021-02-06 19:53:05
    permutation1=np.random.permutation(x) permutation2 = np.random.permutation(7) x=np.array([[1,9,6],[1,1,1],[9,5,2],[8,8,8]]) permutation3 = np.random.permutation(x) print(permutation1) print...
  • import numpy as np arr=np.arange(10) print (arr) mat=np.arange(9).reshape(3,3) ...mat_per=np.random.permutation(mat) print(mat_per) 结果为: [0 1 2 3 4 5 6 7 8 9] [[0 1 2]  [3 4 5]  [6 7 8]] [[...
  • np.random.permutation():随机排列序列。 例1:对0-5之间的序列进行随机排序 例2:对一个list进行随机排序 多维度的咋回事? 来看一个例子: a矩阵输出为: 在这里插入图片描述 现在看c矩阵,我运行了两次: 第...
  • shuffle与permutation的区别 函数shuffle与permutation都是对原来的数组进行重新洗牌(即随机打乱原来的元素顺序)。区别在于shuffle直接在原来的数组上进行操作,改变原来数组的顺序...import numpy as np a = n...
  • np.random.permutation()解析

    千次阅读 2020-06-09 10:27:45
    np.random.permutation():随机排列序列。 例1:对0-5之间的序列进行随机排序 例2:对一个list进行随机排序 多维度的咋回事? 来看一个例子: a矩阵输出为: 现在看c矩阵,我运行了两次: 第一次运行结果...
  • andom.seed(0)作用:使得随机数据可预测,即只要seed的值一样,后续...numpy.random.seed(0) ; numpy.random.rand(4) array([ 0.55, 0.72, 0.6 , 0.54]) numpy.random.seed(0) ; numpy.random.rand(4) array...
  • permutation = list(np.random.permutation(m)) #m为样本数 shuffled_X = X[permutation] shuffled_Y = Y[permutation].reshape((1,m)) 图4中的代码是针对一维数组来说的,(图片中右侧为运行结果): 图 4 图5中的...
  • random.permutation(x):随机排列...np.random.permutation(10) array([1, 7, 4, 3, 0, 9, 2, 5, 8, 6]) # random 例2:对一维数组进行随机排序 np.random.permutation([1, 4, 9, 12, 15]) array([15, 1, 9, 4, 12]
  • 【numpy】np.random.permutation() Randomly permute a sequence, or return a permuted range. 即随机排列序列,或返回随机范围。 例1:对0-5之间的序列进行随机排序 import numpy as np b = np.random....
  • randomnp.random、torch.random总结

    千次阅读 2022-03-28 18:52:13
    np.random random() 生成一个[0, 1.)之间的随机浮点数 random([3, 2]) 生成形状为3×2的[0, 1.)之间的随机浮点数 rand(3, 2) 和random([3, 2])相同 randint(a ,b, size) 生成[a,b)之间的随机整数...
  • np.random.permutation

    2021-10-28 14:11:17
    np.random.permutation np.random.permutation():随机排列序列。 例1:对0-5之间的序列进行随机排序 例2:对一个list进行随机排序 多维度的咋回事? 来看一个例子: a矩阵输出为: 现在看c矩阵,我运行了...
  • np.random的随机数函数(1)函数说明rand(d0,d1,..,dn)根据d0‐dn创建随机数数组,浮点数, [0,1),均匀分布randn(d0,d1,..,dn)根据d0‐dn创建随机数数组,标准正态分布randint(low[,high,shape])根据shape创建随机...
  • Snort 安装 配置 - ArchlinuxAbout Snort Snort是一套开放源代码(OpenSource and free)的网络入侵预防软件(NIPS)与网络入侵检测软件(NIDS).Snort使用了以侦测签名(signature ...PNG与iOS优化选项从App Store下载到的...
  • np.random.permutation(x)3. 区别 将数组打乱随机排列 两种方法: np.random.shuffle(x):在原数组上进行,改变自身序列,无返回值。 np.random.permutation(x):不在原数组上进行,返回新的数组,不改变自身数组。...
  • import numpy as np #创建一个数组 X = np.array ([[0, 1], [2, 3], [4, 5], [6, 7], [8, 9]]) #输出所有元素 print(X[:]) #[[0 1] [2 3] [4 5] [6 7] [8 9]] #输出第二行的元素 print(X[1]) #[2 3] #输出第二行 第...
  • 如有错误,恳请指出。 文章目录1. 随机抽样2. 随机排序3. 随机分布4....平时都会使用到随机模块,一般是...np.random.randn(3,3) # 从标准正太分布中返回样本 np.random.rand(3,3) # 从0-1均匀分布分布中返回样本 np.ra.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,061
精华内容 3,224
关键字:

np.random.permutation