[OVC/convert_model]: Order of applying preprocessing and MOC transformations

[he-ub]

Hi,
I need some clarifications regarding the flow of OVC/convert_model & PostProcessing:
I see that convert_model() after conversion calls apply_preprocessing(), which instantiates a PrePostProcessing object and calls build (which applies some transformations), then calls moc_transformations (in moc_emit_ir())
But the comment in pre_post_process.cpp says that the transformations pipeline in PrePostProcessing::build was added because of the new order in OVC [Conversion -> MOC] -> Postprocessing -> nncf
But I think the order in my understanding is still [Conversion -> Postprocessing -> MOC] -> nncf at least that's how it is described in moc_emit_ir()

• Do we still need those transformations inside Postprocessing ? The comment is it still valid ?
• Did I misunderstand something here ?

Thank you for your help.

[Ganesh-403]

@he-ub I had a look at the conversion flow, and I think your confusion comes from the distinction between graph construction and graph normalization.

From what I can tell, the high-level sequence is still roughly:

Conversion
    ↓
apply_preprocessing()
    ↓
moc_transformations()
    ↓
serialization / NNCF (if used)

which matches what you're seeing in moc_emit_ir().

However, PrePostProcessing::build() is not just attaching preprocessing metadata—it actually modifies the ov::Model graph by inserting preprocessing/postprocessing operations (layout conversion, type conversion, resize, color conversion, etc.). The resulting graph is then passed through the standard OpenVINO transformation pipeline. The PrePostProcessing API documentation describes build() as producing a modified Model, rather than simply recording preprocessing configuration. :contentReference[oaicite:0]{index=0}

Because of that, I believe the comment:

[Conversion -> MOC] -> Postprocessing -> nncf

is referring to the logical design that motivated adding the transformation pipeline inside PrePostProcessing::build(), not necessarily the literal call order in today's implementation.

In other words:

• build() inserts the preprocessing subgraph.
• Some normalization passes are applied there so the inserted subgraph is already in a valid/expected form.
• moc_transformations() then runs the regular Model Optimizer/Common transformation pipeline over the entire graph, including the newly inserted preprocessing nodes.

So I don't think the transformations inside PrePostProcessing::build() are necessarily redundant—they appear to normalize the preprocessing subgraph before the broader MOC transformation pipeline runs.

That said, I couldn't find documentation explicitly describing why both transformation stages still exist, so I can't say whether the comment is outdated or whether the implementation intentionally retains this two-stage behavior.

One question for the maintainers:

• Is the comment in pre_post_process.cpp describing the original architectural intent, or should it be updated to reflect the current implementation order? In other words, are the transformations in PrePostProcessing::build() still required because they perform preprocessing-specific normalization that moc_transformations() intentionally does not cover?

If this solves your problem, feel free to mark it as the accepted answer so others can find it easily.