main.cpp 14.1 KB
Newer Older
Paul's avatar
Paul committed
1
2
#include "argument_parser.hpp"
#include "command.hpp"
Paul's avatar
Paul committed
3
#include "verify.hpp"
Paul's avatar
Paul committed
4
#include "perf.hpp"
5
#include "models.hpp"
Paul's avatar
Paul committed
6

Paul's avatar
Paul committed
7
8
9
#include <migraphx/tf.hpp>
#include <migraphx/onnx.hpp>
#include <migraphx/stringutils.hpp>
10
11
#include <migraphx/load_save.hpp>
#include <migraphx/json.hpp>
Paul's avatar
Paul committed
12

13
14
15
#include <migraphx/dead_code_elimination.hpp>
#include <migraphx/eliminate_identity.hpp>
#include <migraphx/eliminate_pad.hpp>
16
17
#include <migraphx/generate.hpp>
#include <migraphx/pass_manager.hpp>
18
#include <migraphx/propagate_constant.hpp>
19
#include <migraphx/quantization.hpp>
20
#include <migraphx/register_op.hpp>
21
#include <migraphx/rewrite_batchnorm.hpp>
22
23
#include <migraphx/simplify_algebra.hpp>
#include <migraphx/simplify_reshapes.hpp>
24
#include <migraphx/register_target.hpp>
25

26
27
#include <fstream>

Paul's avatar
Paul committed
28
29
30
31
32
33
namespace migraphx {
namespace driver {
inline namespace MIGRAPHX_INLINE_NS {

struct loader
{
34
    std::string model;
Paul's avatar
Paul committed
35
    std::string file;
Paul's avatar
Paul committed
36
    std::string file_type;
37
38
39
40
41
    unsigned batch              = 1;
    bool is_nhwc                = true;
    unsigned trim               = 0;
    bool optimize               = false;
    bool skip_unknown_operators = false;
42
43
44
    bool brief                  = false;
    std::string output_type;
    std::string output;
Paul's avatar
Paul committed
45
46
47

    void parse(argument_parser& ap)
    {
Paul's avatar
Paul committed
48
        ap(file, {}, ap.metavar("<input file>"));
49
        ap(model, {"--model"}, ap.help("Load model"), ap.type("resnet50|inceptionv3|alexnet"));
Paul's avatar
Paul committed
50
51
        ap(file_type, {"--onnx"}, ap.help("Load as onnx"), ap.set_value("onnx"));
        ap(file_type, {"--tf"}, ap.help("Load as tensorflow"), ap.set_value("tf"));
52
53
        ap(file_type, {"--migraphx"}, ap.help("Load as MIGraphX"), ap.set_value("migraphx"));
        ap(file_type, {"--migraphx-json"}, ap.help("Load as MIGraphX JSON"), ap.set_value("json"));
54
        ap(batch, {"--batch"}, ap.help("Set batch size for model"));
Paul's avatar
Paul committed
55
        ap(is_nhwc, {"--nhwc"}, ap.help("Treat tensorflow format as nhwc"), ap.set_value(true));
56
57
58
59
        ap(skip_unknown_operators,
           {"--skip-unknown-operators"},
           ap.help("Skip unknown operators when parsing and continue to parse."),
           ap.set_value(true));
Paul's avatar
Paul committed
60
        ap(is_nhwc, {"--nchw"}, ap.help("Treat tensorflow format as nchw"), ap.set_value(false));
Paul's avatar
Paul committed
61
        ap(trim, {"--trim", "-t"}, ap.help("Trim instructions from the end"));
62
        ap(optimize, {"--optimize", "-O"}, ap.help("Optimize when reading"), ap.set_value(true));
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
        ap(output_type,
           {"--graphviz", "-g"},
           ap.help("Print out a graphviz representation."),
           ap.set_value("graphviz"));
        ap(brief, {"--brief"}, ap.help("Make the output brief."), ap.set_value(true));
        ap(output_type,
           {"--cpp"},
           ap.help("Print out the program as cpp program."),
           ap.set_value("cpp"));
        ap(output_type, {"--json"}, ap.help("Print out program as json."), ap.set_value("json"));
        ap(output_type,
           {"--text"},
           ap.help("Print out program in text format."),
           ap.set_value("text"));
        ap(output_type,
           {"--binary"},
           ap.help("Print out program in binary format."),
           ap.set_value("binary"));
        ap(output, {"--output", "-o"}, ap.help("Output to file."));
Paul's avatar
Paul committed
82
83
    }

Paul's avatar
Paul committed
84
    program load()
Paul's avatar
Paul committed
85
86
    {
        program p;
87
        if(model.empty())
Paul's avatar
Paul committed
88
        {
89
90
91
92
93
94
            if(file_type.empty())
            {
                if(ends_with(file, ".onnx"))
                    file_type = "onnx";
                else if(ends_with(file, ".pb"))
                    file_type = "tf";
95
96
97
98
                else if(ends_with(file, ".json"))
                    file_type = "json";
                else
                    file_type = "migraphx";
99
100
101
            }
            std::cout << "Reading: " << file << std::endl;
            if(file_type == "onnx")
102
103
104
105
106
107
108
            {
                onnx_options options;
                options.default_dim_value      = batch;
                options.skip_unknown_operators = skip_unknown_operators;
                options.print_program_on_error = true;
                p                              = parse_onnx(file, options);
            }
109
            else if(file_type == "tf")
110
            {
111
                p = parse_tf(file, tf_options{is_nhwc, batch});
112
            }
113
114
115
116
117
118
119
120
121
122
            else if(file_type == "json")
            {
                file_options options;
                options.format = "json";
                p              = migraphx::load(file, options);
            }
            else if(file_type == "migraphx")
            {
                p = migraphx::load(file);
            }
123
124
125
126
127
128
129
130
131
132
133
        }
        else
        {
            if(model == "resnet50")
                p = resnet50(batch);
            else if(model == "inceptionv3")
                p = inceptionv3(batch);
            else if(model == "alexnet")
                p = alexnet(batch);
            else
                MIGRAPHX_THROW("Unknown model: " + model);
Paul's avatar
Paul committed
134
        }
Paul's avatar
Paul committed
135
        if(trim > 0)
Paul's avatar
Paul committed
136
        {
Paul's avatar
Paul committed
137
            auto last = std::prev(p.end(), trim);
Paul's avatar
Paul committed
138
139
            p.remove_instructions(last, p.end());
        }
Paul's avatar
Paul committed
140
141
142
        if(optimize)
            migraphx::run_passes(p,
                                 {
143
                                     migraphx::rewrite_batchnorm{},
Paul's avatar
Paul committed
144
145
146
147
148
149
150
151
152
153
154
                                     migraphx::eliminate_identity{},
                                     migraphx::dead_code_elimination{},
                                     migraphx::simplify_algebra{},
                                     migraphx::dead_code_elimination{},
                                     migraphx::simplify_reshapes{},
                                     migraphx::dead_code_elimination{},
                                     migraphx::propagate_constant{},
                                     migraphx::dead_code_elimination{},
                                     migraphx::eliminate_pad{},
                                     migraphx::dead_code_elimination{},
                                 });
Paul's avatar
Paul committed
155
156
        return p;
    }
157
158
159
160
161
162

    static void write(std::ostream& os, const std::vector<char>& buffer)
    {
        os.write(buffer.data(), buffer.size());
    }

163
    void save(const program& p) const
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
    {
        auto* os = &std::cout;
        std::ofstream fs;
        if(not output.empty())
        {
            fs.open(output);
            os = &fs;
        }

        std::string type = output_type;
        if(type.empty())
        {
            if(output.empty())
                type = "text";
            else
                type = "binary";
        }

        if(type == "cpp")
            p.print_cpp(*os);
        else if(type == "graphviz")
            p.print_graph(*os, brief);
        else if(type == "text")
            *os << p << std::endl;
        else if(type == "json")
            *os << to_json_string(p.to_value()) << std::endl;
        else if(type == "binary")
            write(*os, save_buffer(p));
    }
Paul's avatar
Paul committed
193
194
};

195
196
197
198
199
200
201
202
203
204
struct program_params
{
    std::vector<std::string> fill0{};
    std::vector<std::string> fill1{};
    void parse(argument_parser& ap)
    {
        ap(fill0, {"--fill0"}, ap.help("Fill parameter with 0s"), ap.append());
        ap(fill1, {"--fill1"}, ap.help("Fill parameter with 1s"), ap.append());
    }

205
    auto generate(const program& p, const target& t, bool offload)
206
207
208
209
210
211
    {
        program::parameter_map m;
        for(auto&& s : fill0)
            m[s] = fill_argument(p.get_parameter_shape(s), 0);
        for(auto&& s : fill1)
            m[s] = fill_argument(p.get_parameter_shape(s), 1);
212
        fill_param_map(m, p, t, offload);
213
214
215
216
        return m;
    }
};

217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
struct compiler_target
{
#ifdef HAVE_GPU
    std::string target_name = "gpu";
#else
    std::string target_name = "cpu";
#endif

    void parse(argument_parser& ap)
    {
        ap(target_name, {"--gpu"}, ap.help("Compile on the gpu"), ap.set_value("gpu"));
        ap(target_name, {"--cpu"}, ap.help("Compile on the cpu"), ap.set_value("cpu"));
        ap(target_name,
           {"--ref"},
           ap.help("Compile on the reference implementation"),
           ap.set_value("ref"));
    }

    target get_target() const { return make_target(target_name); }
};

Paul's avatar
Paul committed
238
239
struct compiler
{
240
241
    static const int q_fp16 = 1;
    static const int q_int8 = 2;
Paul's avatar
Paul committed
242
    loader l;
243
    program_params parameters;
244
    compiler_target ct;
245
    bool offload_copy = false;
kahmed10's avatar
kahmed10 committed
246
    bool fast_math    = true;
247
    int quantize      = 0;
248

kahmed10's avatar
kahmed10 committed
249
    std::vector<std::string> fill0;
Paul's avatar
Paul committed
250
    std::vector<std::string> fill1;
Paul's avatar
Paul committed
251
252
    void parse(argument_parser& ap)
    {
Paul's avatar
Paul committed
253
        l.parse(ap);
254
        parameters.parse(ap);
255
        ct.parse(ap);
256
257
258
        ap(offload_copy,
           {"--enable-offload-copy"},
           ap.help("Enable implicit offload copying"),
259
           ap.set_value(true));
kahmed10's avatar
kahmed10 committed
260
261
262
263
        ap(fast_math,
           {"--disable-fast-math"},
           ap.help("Disable fast math optimization"),
           ap.set_value(false));
264
265
        ap(quantize, {"--fp16"}, ap.help("Quantize for fp16"), ap.set_value(q_fp16));
        ap(quantize, {"--int8"}, ap.help("Quantize for int8"), ap.set_value(q_int8));
Paul's avatar
Paul committed
266
267
    }

268
    auto params(const program& p) { return parameters.generate(p, ct.get_target(), offload_copy); }
269
270
271
272

    program compile()
    {
        auto p = l.load();
273
274
275
        // Dont compile if its already been compiled
        if(p.is_compiled())
            return p;
276
        auto t = ct.get_target();
277
278
279
280
281
282
        if(quantize == q_fp16)
        {
            quantize_fp16(p);
        }
        else if(quantize == q_int8)
        {
283
            quantize_int8(p, t, {params(p)});
284
        }
285
286
        compile_options options;
        options.offload_copy = offload_copy;
kahmed10's avatar
kahmed10 committed
287
        options.fast_math    = fast_math;
288
        p.compile(t, options);
289
        l.save(p);
290
291
        return p;
    }
Paul's avatar
Paul committed
292
293
};

Paul's avatar
Paul committed
294
295
296
struct read : command<read>
{
    loader l;
297
    void parse(argument_parser& ap) { l.parse(ap); }
Paul's avatar
Paul committed
298
299
300
301

    void run()
    {
        auto p = l.load();
302
        l.save(p);
Paul's avatar
Paul committed
303
304
305
    }
};

Paul's avatar
Paul committed
306
307
308
309
310
311
312
313
struct params : command<params>
{
    loader l;
    void parse(argument_parser& ap) { l.parse(ap); }

    void run()
    {
        auto p = l.load();
Paul's avatar
Paul committed
314
        for(auto&& param : p.get_parameter_shapes())
Paul's avatar
Paul committed
315
316
317
318
            std::cout << param.first << ": " << param.second << std::endl;
    }
};

Paul's avatar
Paul committed
319
320
321
struct verify : command<verify>
{
    loader l;
322
    program_params parameters;
323
    compiler_target ct;
Paul's avatar
Paul committed
324
    double tolerance     = 80;
Paul's avatar
Paul committed
325
    bool per_instruction = false;
Paul's avatar
Paul committed
326
    bool reduce          = false;
327
    bool offload_copy    = false;
kahmed10's avatar
kahmed10 committed
328
    bool fast_math       = true;
Paul's avatar
Paul committed
329
330
    void parse(argument_parser& ap)
    {
Paul's avatar
Paul committed
331
        l.parse(ap);
332
        parameters.parse(ap);
333
        ct.parse(ap);
334
335
336
337
        ap(offload_copy,
           {"--enable-offload-copy"},
           ap.help("Enable implicit offload copying"),
           ap.set_value(true));
kahmed10's avatar
kahmed10 committed
338
339
340
341
        ap(fast_math,
           {"--disable-fast-math"},
           ap.help("Disable fast math optimization"),
           ap.set_value(false));
Paul's avatar
Paul committed
342
343
        ap(tolerance, {"--tolerance"}, ap.help("Tolerance for errors"));
        ap(per_instruction,
Paul's avatar
Paul committed
344
345
346
347
           {"-i", "--per-instruction"},
           ap.help("Verify each instruction"),
           ap.set_value(true));
        ap(reduce, {"-r", "--reduce"}, ap.help("Reduce program and verify"), ap.set_value(true));
Paul's avatar
Paul committed
348
349
350
351
352
    }

    void run()
    {
        auto p = l.load();
353
        l.save(p);
Paul's avatar
Paul committed
354
355
        std::cout << p << std::endl;

356
357
        compile_options options;
        options.offload_copy = offload_copy;
kahmed10's avatar
kahmed10 committed
358
        options.fast_math    = fast_math;
359
360
        auto t               = ct.get_target();
        auto m               = parameters.generate(p, t, true);
361

Paul's avatar
Paul committed
362
363
        if(per_instruction)
        {
364
            verify_instructions(p, t, options, tolerance);
Paul's avatar
Paul committed
365
366
367
        }
        else if(reduce)
        {
368
            verify_reduced_program(p, t, options, m, tolerance);
Paul's avatar
Paul committed
369
370
371
        }
        else
        {
372
            verify_program(l.file, p, t, options, m, tolerance);
Paul's avatar
Paul committed
373
374
375
376
        }
    }
};

Paul's avatar
Paul committed
377
378
379
struct compile : command<compile>
{
    compiler c;
Paul's avatar
Paul committed
380
    void parse(argument_parser& ap) { c.parse(ap); }
Paul's avatar
Paul committed
381
382
383
384

    void run()
    {
        std::cout << "Compiling ... " << std::endl;
385
        c.compile();
Paul's avatar
Paul committed
386
387
388
389
390
391
    }
};

struct run_cmd : command<run_cmd>
{
    compiler c;
Paul's avatar
Paul committed
392
    void parse(argument_parser& ap) { c.parse(ap); }
Paul's avatar
Paul committed
393
394
395
396
397
398
399

    void run()
    {
        std::cout << "Compiling ... " << std::endl;
        auto p = c.compile();
        std::cout << "Allocating params ... " << std::endl;
        auto m = c.params(p);
Paul's avatar
Paul committed
400
        p.eval(m);
Paul's avatar
Paul committed
401
402
403
404
        std::cout << p << std::endl;
    }
};

Paul's avatar
Paul committed
405
406
407
408
struct perf : command<perf>
{
    compiler c;
    unsigned n = 100;
Paul's avatar
Paul committed
409
410
    void parse(argument_parser& ap)
    {
Paul's avatar
Paul committed
411
412
413
414
415
416
417
418
419
420
421
422
423
        c.parse(ap);
        ap(n, {"--iterations", "-n"}, ap.help("Number of iterations to run for perf report"));
    }

    void run()
    {
        std::cout << "Compiling ... " << std::endl;
        auto p = c.compile();
        std::cout << "Allocating params ... " << std::endl;
        auto m = c.params(p);
        std::cout << "Running performance report ... " << std::endl;
        p.perf_report(std::cout, n, m);
    }
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
};

struct op : command<op>
{
    bool show_ops = false;
    void parse(argument_parser& ap)
    {
        ap(show_ops,
           {"--list", "-l"},
           ap.help("List all the operators of MIGraphX"),
           ap.set_value(true));
    }
    void run() const
    {
        if(show_ops)
        {
            for(const auto& name : get_operators())
                std::cout << name << std::endl;
        }
    }
Paul's avatar
Paul committed
444
445
};

Paul's avatar
Paul committed
446
447
448
449
450
struct main_command
{
    static std::string get_command_help()
    {
        std::string result = "Commands:\n";
Paul's avatar
Paul committed
451
452
453
454
        return std::accumulate(get_commands().begin(),
                               get_commands().end(),
                               result,
                               [](auto r, auto&& p) { return r + "    " + p.first + "\n"; });
Paul's avatar
Paul committed
455
    }
Paul's avatar
Paul committed
456
    void parse(argument_parser& ap)
Paul's avatar
Paul committed
457
    {
Paul's avatar
Paul committed
458
        ap(nullptr, {"-h", "--help"}, ap.help("Show help"), ap.show_help(get_command_help()));
Paul's avatar
Paul committed
459
460
461
462
463
    }

    void run() {}
};

Paul's avatar
Paul committed
464
465
466
467
} // namespace MIGRAPHX_INLINE_NS
} // namespace driver
} // namespace migraphx

Paul's avatar
Paul committed
468
using namespace migraphx::driver; // NOLINT
Paul's avatar
Paul committed
469
470
int main(int argc, const char* argv[])
{
Paul's avatar
Paul committed
471
    std::vector<std::string> args(argv + 1, argv + argc);
Paul's avatar
Paul committed
472
    if(args.empty())
Paul's avatar
Paul committed
473
        return 0;
Paul's avatar
Paul committed
474
    auto&& m = get_commands();
Paul's avatar
Paul committed
475
    auto cmd = args.front();
Paul's avatar
Paul committed
476
    if(m.count(cmd) > 0)
Paul's avatar
Paul committed
477
    {
Paul's avatar
Paul committed
478
        m.at(cmd)({args.begin() + 1, args.end()});
Paul's avatar
Paul committed
479
    }
Paul's avatar
Paul committed
480
    else
Paul's avatar
Paul committed
481
    {
Paul's avatar
Paul committed
482
        run_command<main_command>(args);
Paul's avatar
Paul committed
483
484
485
    }
    return 0;
}