Python Reference

Python Reference#

Applies to Linux

2023-06-14

9 min read time

shape#

class migraphx.shape(type, lens, strides=None)#

Describes the shape of a tensor. This includes size, layout, and data type/

migraphx.type()#

An integer that represents the type.

Return type:

int

migraphx.lens()#

A list of the lengths of the shape.

Return type:

list[int]

migraphx.strides()#

A list of the strides of the shape.

Return type:

list[int]

migraphx.elements()#

The number of elements in the shape.

Return type:

int

migraphx.bytes()#

The number of bytes the shape uses.

Return type:

int

migraphx.type_size()#

The number of bytes one element uses

Return type:

int

migraphx.packed()#

Returns true if the shape is packed.

Return type:

bool

migraphx.transposed()#

Returns true if the shape is transposed.

Return type:

bool

migraphx.broadcasted()#

Returns true if the shape is broadcasted.

Return type:

bool

migraphx.standard()#

Returns true if the shape is a standard shape. That is, the shape is both packed and not transposed.

Return type:

bool

migraphx.scalar()#

Returns true if all strides are equal to 0 (scalar tensor).

Return type:

bool

argument#

class migraphx.argument(data)#

Construct an argument from a python buffer. This can include numpy arrays.

migraphx.get_shape()#

Returns the shape of the argument.

Return type:

shape

migraphx.tolist()#

Convert the elements of the argument to a python list.

Return type:

list

migraphx.generate_argument(s, seed=0)#

Generate an argument with random data.

Parameters:

  • s (shape) – Shape of argument to generate.

  • seed (int) – The seed used for random number generation.

Return type:

argument

migraphx.fill_argument(s, value)#

Fill argument of shape s with value.

Parameters:

  • s (shape) – Shape of argument to fill.

  • value (int) – Value to fill in the argument.

:rtype argument

target#

class migraphx.target#

This represents the compilation target.

migraphx.get_target(name)#

Constructs the target.

Parameters:

name (str) – The name of the target to construct. This can either be ‘gpu’ or ‘ref’.

Return type:

target

module#

migraphx.print()#

Prints the contents of the module as list of instructions.

migraphx.add_instruction(op, args, mod_args=[])#

Adds instruction into the module.

Parameters:

  • op (operation) – ‘migraphx.op’ to be added as instruction.

  • args (list[instruction]) – list of inputs to the op.

  • mod_args (list[module]) – optional list of module arguments to the operator.

:rtype instruction

migraphx.add_literal(data)#

Adds constant or literal data of provided shape into the module from python buffer which includes numpy array.

Parameters:

data (py::buffer) – Python buffer or numpy array

:rtype instruction

migraphx.add_parameter(name, shape)#

Adds a parameter to the module with provided name and shape.

Parameters:

  • name (str) – name of the parameter.

  • shape (shape) – shape of the parameter.

:rtype instruction

migraphx.add_return(args)#

Adds a return instruction into the module.

Parameters:

args (list[instruction]) – instruction arguments which need to be returned from the module.

:rtype instruction

program#

class migraphx.program#

Represents the computation graph to be compiled and run.

migraphx.clone()#

Make a copy of the program.

Return type:

program

migraphx.get_parameter_names()#

Get all the input arguments’ or parameters’ names to the program as a list.

:rtype list[str]

migraphx.get_parameter_shapes()#

Get the shapes of all the input parameters in the program.

Return type:

dict[str, shape]

migraphx.get_output_shapes()#

Get the shapes of the final outputs of the program.

Return type:

list[shape]

migraphx.compile(t, offload_copy=True, fast_math=True)#

Compiles the program for the target and optimizes it.

Parameters:

  • t (target) – This is the target to compile the program for.

  • offload_copy (bool) – For targets with offloaded memory(such as the gpu), this will insert instructions during compilation to copy the input parameters to the offloaded memory and to copy the final result from the offloaded memory back to main memory.

  • fast_math (bool) – Optimize math functions to use faster approximate versions. There may be slight accuracy degredation when enabled.

migraphx.get_main_module()#

Get main module of the program.

:rtype module

migraphx.create_module(name)#

Create and add a module of provided name into the program.

:param str name : name of the new module. :rtype module

migraphx.run(params)#

Run the program.

Parameters:

params (dict[str, argument]) – This is a map of the input parameters which will be used when running the program.

Returns:

The result of the last instruction.

Return type:

list[argument]

migraphx.sort()#

Sort the modules of the program such that instructions appear in topologically sorted order.

migraphx.quantize_fp16(prog, ins_names=['all'])#

Quantize the program to use fp16.

Parameters:

  • prog (program) – Program to quantize.

  • ins_names (list[str]) – List of instructions to quantize.

migraphx.quantize_int8(prog, t, calibration=[], ins_names=['dot', 'convolution'])#

Quantize the program to use int8.

Parameters:

  • prog (program) – Program to quantize.

  • t (target) – Target that will be used to run the calibration data.

  • calibration (list[dict[str, argument]]) – Calibration data used to decide the parameters to the int8 optimization.

  • ins_names (list[str]) – List of instructions to quantize.

op#

parse_onnx#

migraphx.parse_onnx(filename, default_dim_value=1, map_input_dims={}, skip_unknown_operators=false, print_program_on_error=false, max_loop_iterations=10)#

Load and parse an onnx file.

Parameters:

  • filename (str) – Path to file.

  • default_dim_value (str) – default batch size to use (if not specified in onnx file).

  • map_input_dims (str) – Explicitly specify the dims of an input.

  • skip_unknown_operators (str) – Continue parsing onnx file if an unknown operator is found.

  • print_program_on_error (str) – Print program if an error occurs.

  • max_loop_iterations (int) – Maximum iteration number for the loop operator.

Return type:

program

parse_tf#

migraphx.parse_tf(filename, is_nhwc=True, batch_size=1, map_input_dims=dict(), output_names=[])#

Load and parse an tensorflow protobuf file file.

Parameters:

  • filename (str) – Path to file.

  • is_nhwc (bool) – Use nhwc as default format.

  • batch_size (str) – default batch size to use (if not specified in protobuf).

  • map_input_dims (dict[str, list[int]]) – Optional arg to explictly specify dimensions of the inputs.

  • output_names (list[str]) – Optional argument specify names of the output nodes.

Return type:

program

load#

migraphx.load(filename, format='msgpack')#

Load a MIGraphX program.

Parameters:

  • filename (str) – Path to file.

  • format (str) – Format of file. Valid options are msgpack or json.

Return type:

program

save#

migraphx.save(p, filename, format='msgpack')#

Save a MIGraphX program.

Parameters:

  • p (program) – Program to save.

  • filename (str) – Path to file.

  • format (str) – Format of file. Valid options are msgpack or json.

Contents