py.rst 7.5 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
.. py:module:: migraphx

Python Reference
================

shape
-----

.. py:class:: shape(type, lens, strides=None)

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

.. py:method:: type()

15
    An integer that represents the type.
16
17
18
19
20

    :rtype: int

.. py:method:: lens()

21
    A list of the lengths of the shape.
22
23
24
25
26

    :rtype: list[int]

.. py:method:: strides()

27
    A list of the strides of the shape.
28
29
30
31
32

    :rtype: list[int]

.. py:method:: elements()

33
    The number of elements in the shape.
34
35
36
37
38

    :rtype: int

.. py:method:: bytes()

39
    The number of bytes the shape uses.
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

    :rtype: int

.. py:method:: type_size()

    The number of bytes one element uses

    :rtype: int

.. py:method:: packed()

    Returns true if the shape is packed.

    :rtype: bool

.. py:method:: transposed()

    Returns true if the shape is transposed.

    :rtype: bool

.. py:method:: broadcasted()

    Returns true if the shape is broadcasted.

    :rtype: bool

.. py:method:: standard()

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

    :rtype: bool

.. py:method:: scalar()

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

    :rtype: bool


argument
--------

.. py:class:: argument(data)

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

.. py:method:: get_shape()

    Returns the shape of the argument.

    :rtype: shape

.. py:method:: tolist()

    Convert the elements of the argument to a python list.

    :rtype: list


.. py:function:: generate_argument(s, seed=0)

    Generate an argument with random data.

    :param shape s: Shape of argument to generate.
105
    :param int seed: The seed used for random number generation.
106
107
108

    :rtype: argument

109
.. py:function:: fill_argument(s, value)
110

111
    Fill argument of shape s with value.
112

113
114
    :param shape s: Shape of argument to fill.
    :param int value: Value to fill in the argument.
115

116
    :rtype argument
117
118

target
119
------
120
121
122

.. py:class:: target()

123
    This represents the compilation target.
124
125
126
127
128

.. py:function:: get_target(name)

    Constructs the target.

129
    :param str name: The name of the target to construct. This can either be 'gpu' or 'ref'.
130
131
132
133

    :rtype: target


134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
module
------
.. py:method:: print()

    Prints the contents of the module as list of instructions.

.. py:method:: add_instruction(op, args, mod_args=[])
    
    Adds instruction into the module.

    :param operation op: 'migraphx.op' to be added as instruction.
    :param list[instruction] args: list of inputs to the op.
    :param list[module] mod_args: optional list of module arguments to the operator.
    :rtype instruction

.. py:method:: add_parameter(name, shape)
    
    Adds a parameter to the module with provided name and shape.

    :param str name: name of the parameter.
    :param shape shape: shape of the parameter.
    :rtype instruction

.. py:method:: add_return(args)

    Adds a return instruction into the module.

    :param list[instruction] args: instruction arguments which need to be returned from the module.
    :rtype instruction


165
166
167
168
169
program
-------

.. py:class:: program()

170
    Represents the computation graph to be compiled and run.
171
172
173

.. py:method:: clone()

174
    Make a copy of the program.
175
176
177

    :rtype: program

178
179
180
181
182
183
.. py:method:: get_parameter_names()
 
    Get all the input arguments' or parameters' names to the program as a list.

    :rtype list[str]

184
185
186
187
188
189
.. py:method:: get_parameter_shapes()

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

    :rtype: dict[str, shape]

190
.. py:method:: get_output_shapes()
191

192
    Get the shapes of the final outputs of the program.
193

194
    :rtype: list[shape]
195

kahmed10's avatar
kahmed10 committed
196
.. py:method:: compile(t, offload_copy=True, fast_math=True)
197
198
199
200
201

    Compiles the program for the target and optimizes it.

    :param target t: This is the target to compile the program for.
    :param bool offload_copy: 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.
kahmed10's avatar
kahmed10 committed
202
    :param bool fast_math: Optimize math functions to use faster approximate versions. There may be slight accuracy degredation when enabled.
203

204
205
206
207
208
209
210
211
212
213
214
215
216
.. py:method:: get_main_module()
    
    Get main module of the program.

    :rtype module

.. py:method:: create_module(name)
    
    Create and add a module of provided name into the program.

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

217
218
219
220
221
222
223
224
.. py:method:: run(params)

    Run the program.

    :param params: This is a map of the input parameters which will be used when running the program.
    :type params: dict[str, argument]

    :return: The result of the last instruction.
225
226
227
228
229
    :rtype: list[argument]

.. py:method:: sort()

    Sort the modules of the program such that instructions appear in topologically sorted order.
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251

.. py:function:: quantize_fp16(prog, ins_names=["all"])

    Quantize the program to use fp16.

    :param program prog: Program to quantize.
    :param ins_names: List of instructions to quantize.
    :type ins_names: list[str]


.. py:function:: quantize_int8(prog, t, calibration=[], ins_names=["dot", "convolution"])

    Quantize the program to use int8.

    :param program prog: Program to quantize.
    :param target t: Target that will be used to run the calibration data.
    :param calibration: Calibration data used to decide the parameters to the int8 optimization.
    :type calibration: list[dict[str, argument]]
    :param ins_names: List of instructions to quantize.
    :type ins_names: list[str]


252
253
254
255
256
257
258
259
260
261
262
263
op
--
.. py::class:: op(name, kwargs)

    Construct an operation with name and arguments.
    
    :param str name : name of the operation, must be supported by MIGraphX.
    :param dict[str, any] kwargs: arguments to the operation.
    :rtype operation



264
265
266
parse_onnx
----------

267
.. py:function:: parse_onnx(filename, default_dim_value=1, map_input_dims={}, skip_unknown_operators=false, print_program_on_error=false, max_loop_iterations=10)
268
269
270
271

    Load and parse an onnx file.

    :param str filename: Path to file.
272
273
274
275
    :param str default_dim_value: default batch size to use (if not specified in onnx file).
    :param str map_input_dims: Explicitly specify the dims of an input.
    :param str skip_unknown_operators: Continue parsing onnx file if an unknown operator is found.
    :param str print_program_on_error: Print program if an error occurs.
276
    :param int max_loop_iterations: Maximum iteration number for the loop operator.
277
278
279
    :rtype: program

parse_tf
280
--------
281

282
.. py:function:: parse_tf(filename, is_nhwc=True, batch_size=1, map_input_dims=dict(), output_names=[])
283
284
285
286
287
288

    Load and parse an tensorflow protobuf file file.

    :param str filename: Path to file.
    :param bool is_nhwc: Use nhwc as default format.
    :param str batch_size: default batch size to use (if not specified in protobuf).
289
290
    :param dict[str, list[int]] map_input_dims: Optional arg to explictly specify dimensions of the inputs.
    :param list[str] output_names:  Optional argument specify names of the output nodes.
291
292
    :rtype: program

293
294
295
296
297
load
----

.. py:function:: load(filename, format='msgpack')

298
    Load a MIGraphX program.
299
300
301
302
303
304
305
306
307
308
309

    :param str filename: Path to file.
    :param str format: Format of file. Valid options are msgpack or json.

    :rtype: program

save
----

.. py:function:: save(p, filename, format='msgpack')

310
    Save a MIGraphX program.
311
312
313
314
315

    :param program p: Program to save.
    :param str filename: Path to file.
    :param str format: Format of file. Valid options are msgpack or json.