随机生成pytorch算子测试序列且保证算子参数合法

2024-05-29 18:52

本文主要是介绍随机生成pytorch算子测试序列且保证算子参数合法,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

随机生成pytorch算子测试序列且保证算子参数合法

  • 代码
  • 输出

背景:

1.一些对维度进行操作的算子的单算子测试,结果正常,但多个算子组合在一起,结果就不对。是否能给一个算子列表,随机生成它们的组合呢

功能描述:

1.此程序用于在 CUDA 环境中生成随机张量并对其施加一系列随机选择的操作

2.程序首先随机生成张量的形状和内容,然后随机选择一个操作(如 reshapetransposematmul 等),并生成适当的参数以执行该操作

3.最终输出变换后的张量并打印相关操作信息

4.整个过程在100次不同的种子下每次进行10次操作,以保证操作的多样性和结果的随机性

代码

import torch
import random
from functools import reduce
from operator import mul
import numpy as npmax_size = 4096  # 每个维度的最大大小
max_tensor_elements = 1*4096*4096  # 张量中元素的总数限制min_dim_size = 1  # 最小维度大小
max_dim_size = max_size  # 扩大这个范围可以更快生成符合要求的大小def generate_random_shape(dim, max_attempts=10):for _ in range(max_attempts):shape = [random.randint(min_dim_size, max_dim_size) for _ in range(dim)]if reduce(mul, shape, 1) <= max_tensor_elements:return tuple(shape)# 兜底策略,防止尝试次数用尽:再遍历生成的随机形状,逐个将维度缩小直到符合限制shape = [random.randint(1, max_size) for _ in range(dim)]current_elements = reduce(mul, shape, 1)while current_elements > max_tensor_elements:for i in range(len(shape)):if shape[i] > 1:shape[i] //= 2current_elements = reduce(mul, shape, 1)if current_elements <= max_tensor_elements:breakreturn tuple(shape)def generate_random_input(shape):return torch.randn(shape).to("cuda").half()def generate_random_operator(input_shape):operators = ['unsqueeze', 'repeat', 'permute', 'transpose', 'reshape', 'expand', 'contiguous', 'matmul', 'mul', 'concat',"view"]return random.choice(operators)def generate_random_reshape(input_shape):# 计算输入张量的总元素数total_elements = np.prod(input_shape)divisors = []# 找到 total_elements 的所有约数for i in range(1, int(np.sqrt(total_elements)) + 1):if total_elements % i == 0:divisors.append(i)if i != total_elements // i:divisors.append(total_elements // i)dimensions = []remaining_elements = total_elements# 随机选择新的维度并且保证元素数量不变while remaining_elements > 1 and len(dimensions) < len(input_shape):divisor = np.random.choice(divisors)dimensions.append(divisor)remaining_elements //= divisordivisors = [d for d in divisors if remaining_elements % d == 0]if remaining_elements > 1:dimensions.append(remaining_elements)    np.random.shuffle(dimensions)    return tuple(dimensions)def generate_reshape_params(tensor):return generate_random_reshape(tensor.shape)def random_transpose_params(tensor):return random.sample(range(tensor.dim()), 2)def generate_repeat_params(input_shape):while True:repeats = [random.randint(1, 4) for _ in input_shape]if reduce(mul, [dim * repeat for dim, repeat in zip(input_shape, repeats)], 1) <= max_tensor_elements:return tuple(repeats)def generate_expand_params(input_shape):expanded_shape = []while True:expanded_shape = [random.randint(min(2,dim), dim*2) if dim == 1 else dim for dim in input_shape]if reduce(mul, expanded_shape, 1) <= max_tensor_elements:breakreturn expanded_shapedef generate_random_operator_parameters(input_shape, operator, input_tensor):if operator == 'unsqueeze':return (random.randint(0, len(input_shape) - 1),)if operator == 'repeat':return generate_repeat_params(input_shape)if operator == 'permute':return random.sample(range(len(input_shape)), len(input_shape))if operator == 'transpose':return random_transpose_params(input_tensor)if operator in ['reshape',"view"]:return generate_reshape_params(input_tensor)if operator == 'expand':return generate_expand_params(input_shape)if operator == 'matmul':if input_tensor.dim() == 1:return ()return (input_tensor.size(-1), random.randint(1, max_size))if operator in ['contiguous','mul']:return ()if operator == 'concat':return (random.randint(0, len(input_shape) - 1),)def execute_operator(input_tensor, operator, operator_parameters):if operator == 'unsqueeze':return input_tensor.unsqueeze(*operator_parameters)if operator == 'repeat':return input_tensor.repeat(operator_parameters)if operator == 'permute':return input_tensor.permute(operator_parameters)if operator == 'transpose':return input_tensor.transpose(*operator_parameters)if operator == 'reshape':return input_tensor.reshape(operator_parameters)if operator == 'view':return input_tensor.view(operator_parameters)    if operator == 'expand':return input_tensor.expand(operator_parameters)if operator == 'contiguous':return input_tensor.contiguous()if operator == 'matmul':if input_tensor.dim() ==1:return input_tensorother = torch.randn(*operator_parameters).to(input_tensor.device).type_as(input_tensor)return torch.matmul(input_tensor, other)if operator == 'mul':return input_tensor * input_tensorif operator == 'concat':return torch.cat((input_tensor, input_tensor), dim=operator_parameters[0])def main():for seed in range(2):random.seed(seed)np.random.seed(seed)torch.random.manual_seed(seed)for i in range(10):input_shape = generate_random_shape(random.randint(2, 5))input_tensor = generate_random_input(input_shape)operator = generate_random_operator(input_shape)operator_parameters = generate_random_operator_parameters(input_shape, operator, input_tensor)output_tensor = execute_operator(input_tensor, operator, operator_parameters)print(f"seed:{seed:03d} seq:{i:02d} {operator:<10} input:{str(input_shape):<32} param:{str(operator_parameters):<32} output:{str(output_tensor.shape):<32}")print(output_tensor.cpu().numpy().reshape(-1)[:8])torch.cuda.empty_cache()
if __name__ == '__main__':main()

输出

seed:000 seq:00 repeat     input:(7, 42, 26, 36, 56)              param:(1, 1, 1, 1, 1)                  output:torch.Size([7, 42, 26, 36, 56])
seed:000 seq:01 view       input:(248, 227, 276)                  param:(92, 908, 186)                   output:torch.Size([92, 908, 186])
seed:000 seq:02 view       input:(18, 21, 51, 32, 17)             param:(17, 4536, 136)                  output:torch.Size([17, 4536, 136])
seed:000 seq:03 reshape    input:(2548, 3565)                     param:(644, 65, 217)                   output:torch.Size([644, 65, 217])
seed:000 seq:04 reshape    input:(46, 42, 14, 57, 7)              param:(28, 266, 3, 483)                output:torch.Size([28, 266, 3, 483])
seed:000 seq:05 contiguous input:(222, 100, 597)                  param:()                               output:torch.Size([222, 100, 597])
seed:000 seq:06 view       input:(15, 27, 56, 8, 59)              param:(3, 3, 20160, 1, 59)             output:torch.Size([3, 3, 20160, 1, 59])
seed:000 seq:07 view       input:(1461, 1161)                     param:(188469, 9)                      output:torch.Size([188469, 9])
seed:000 seq:08 reshape    input:(19, 29, 19, 17, 54)             param:(31407, 1, 3, 17, 6, 1)          output:torch.Size([31407, 1, 3, 17, 6, 1])
seed:000 seq:09 transpose  input:(12, 126, 46, 157)               param:[2, 3]                           output:torch.Size([12, 126, 157, 46])
[-0.581   0.568   1.187   2.46   -0.1392 -0.3362  0.2076 -0.662 ]
seed:001 seq:00 view       input:(119, 354, 236)                  param:(4, 1, 17, 146202)               output:torch.Size([4, 1, 17, 146202])
seed:001 seq:01 reshape    input:(60, 961, 178)                   param:(3, 3421160)                     output:torch.Size([3, 3421160])
seed:001 seq:02 expand     input:(16, 10, 34, 37, 58)             param:[16, 10, 34, 37, 58]             output:torch.Size([16, 10, 34, 37, 58])
seed:001 seq:03 concat     input:(12, 44, 12, 26, 55)             param:(1,)                             output:torch.Size([12, 88, 12, 26, 55])
seed:001 seq:04 expand     input:(48, 9, 28, 20, 68)              param:[48, 9, 28, 20, 68]              output:torch.Size([48, 9, 28, 20, 68])
seed:001 seq:05 repeat     input:(16, 16, 162, 233)               param:(1, 1, 1, 1)                     output:torch.Size([16, 16, 162, 233])
seed:001 seq:06 expand     input:(25, 426, 19, 63)                param:[25, 426, 19, 63]                output:torch.Size([25, 426, 19, 63])
seed:001 seq:07 permute    input:(153, 153, 380)                  param:[2, 1, 0]                        output:torch.Size([380, 153, 153])
seed:001 seq:08 permute    input:(3091, 1445)                     param:[1, 0]                           output:torch.Size([1445, 3091])
seed:001 seq:09 mul        input:(142, 254, 388)                  param:()                               output:torch.Size([142, 254, 388])
[3.31   0.3372 0.2354 0.1373 0.594  2.326  0.7344 2.16  ]

这篇关于随机生成pytorch算子测试序列且保证算子参数合法的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!


原文地址:
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.chinasem.cn/article/1014355

相关文章

PyTorch中的词嵌入层(nn.Embedding)详解与实战应用示例

《PyTorch中的词嵌入层(nn.Embedding)详解与实战应用示例》词嵌入解决NLP维度灾难,捕捉语义关系,PyTorch的nn.Embedding模块提供灵活实现,支持参数配置、预训练及变长... 目录一、词嵌入(Word Embedding)简介为什么需要词嵌入?二、PyTorch中的nn.Em

Spring的RedisTemplate的json反序列泛型丢失问题解决

《Spring的RedisTemplate的json反序列泛型丢失问题解决》本文主要介绍了SpringRedisTemplate中使用JSON序列化时泛型信息丢失的问题及其提出三种解决方案,可以根据性... 目录背景解决方案方案一方案二方案三总结背景在使用RedisTemplate操作redis时我们针对

python生成随机唯一id的几种实现方法

《python生成随机唯一id的几种实现方法》在Python中生成随机唯一ID有多种方法,根据不同的需求场景可以选择最适合的方案,文中通过示例代码介绍的非常详细,需要的朋友们下面随着小编来一起学习学习... 目录方法 1:使用 UUID 模块(推荐)方法 2:使用 Secrets 模块(安全敏感场景)方法

Spring Boot spring-boot-maven-plugin 参数配置详解(最新推荐)

《SpringBootspring-boot-maven-plugin参数配置详解(最新推荐)》文章介绍了SpringBootMaven插件的5个核心目标(repackage、run、start... 目录一 spring-boot-maven-plugin 插件的5个Goals二 应用场景1 重新打包应用

Java内存分配与JVM参数详解(推荐)

《Java内存分配与JVM参数详解(推荐)》本文详解JVM内存结构与参数调整,涵盖堆分代、元空间、GC选择及优化策略,帮助开发者提升性能、避免内存泄漏,本文给大家介绍Java内存分配与JVM参数详解,... 目录引言JVM内存结构JVM参数概述堆内存分配年轻代与老年代调整堆内存大小调整年轻代与老年代比例元空

使用Python进行GRPC和Dubbo协议的高级测试

《使用Python进行GRPC和Dubbo协议的高级测试》GRPC(GoogleRemoteProcedureCall)是一种高性能、开源的远程过程调用(RPC)框架,Dubbo是一种高性能的分布式服... 目录01 GRPC测试安装gRPC编写.proto文件实现服务02 Dubbo测试1. 安装Dubb

浅析如何保证MySQL与Redis数据一致性

《浅析如何保证MySQL与Redis数据一致性》在互联网应用中,MySQL作为持久化存储引擎,Redis作为高性能缓存层,两者的组合能有效提升系统性能,下面我们来看看如何保证两者的数据一致性吧... 目录一、数据不一致性的根源1.1 典型不一致场景1.2 关键矛盾点二、一致性保障策略2.1 基础策略:更新数

Python的端到端测试框架SeleniumBase使用解读

《Python的端到端测试框架SeleniumBase使用解读》:本文主要介绍Python的端到端测试框架SeleniumBase使用,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全... 目录SeleniumBase详细介绍及用法指南什么是 SeleniumBase?SeleniumBase

Java中JSON格式反序列化为Map且保证存取顺序一致的问题

《Java中JSON格式反序列化为Map且保证存取顺序一致的问题》:本文主要介绍Java中JSON格式反序列化为Map且保证存取顺序一致的问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未... 目录背景问题解决方法总结背景做项目涉及两个微服务之间传数据时,需要提供方将Map类型的数据序列化为co

Python实现自动化Word文档样式复制与内容生成

《Python实现自动化Word文档样式复制与内容生成》在办公自动化领域,高效处理Word文档的样式和内容复制是一个常见需求,本文将展示如何利用Python的python-docx库实现... 目录一、为什么需要自动化 Word 文档处理二、核心功能实现:样式与表格的深度复制1. 表格复制(含样式与内容)2