I believe that, right now, high performance parallel+numerical code is not a strong point of OCaml. Other functional language implementations do more aggressive unboxing (MLton comes to mind), or have production-ready parallel runtimes (GHC Haskell; OCaml currently has a GIL that requires you to do multiprocessing instead of multithreading, see netmulticore for shared-memory concurrency), and furthermore I expect any of those to be inferior, for high performance numerics, to writing Fortran or OpenMP C++ code.
Where you can hope to win by using OCaml is if a lot of the current application logic is in Python, because writing only C/C++ is too fragile/painful or because your developer base is not expert enough in those languages (common in scientific computing projects for example). OCaml can serve as a middle-ground whose performance is much closer to C++ while its conciseness and programming comfort is closer to Python in many respects. If you can use this to convert more of your program to a faster language, while retaining ease of development, it can be a big win.
You should have a look at the Owl library, that is building up as an interesting OCaml numeric programming library. My understanding is that Owl is not developed for pure performance for now (it was not optimized a lot), but is already competitive with NumPy/Julia for some applications – see the fairly early-stage performance reality check. Of course, whether you use Owl or not, the key to good numerics performance is to rely on high-performance code, so using a good BLAS library is essential – and brings parallelism.