[GPU] Canonicalize 3d shape for onednn conv/deconv post operations (#32391)

### Description of the issue(symptom, root-cause, how it was resolved)
- onednn 3d conv post-op mem_desc needs to be canonicalized to 4d when
conv output is blocked

#### The code and line that caused this issue (if it is not changed
directly)
 - src/plugins/intel_gpu/src/graph/program_node.cpp

#### Reproduction step and snapshot (if applicable. Do not attach for
customer model)
 - reproduction step and model are attached in the ticket.
 ```
// need to convert IR: embedding_model.onnx -> FP32 -> INT8
$ ovc embedding_model.onnx --output_model model_FP32/embedding_model.xml
--input "input[?,50,29]" --compress_to_fp16 False
$ python int8_quantization.py

// Run test
$ python openvino_script.py --device GPU.1 --model
ov_onnx_model/int8/model_INT8.xml --batch 1
```

#### Problematic graph
It doesn't rely on graph patterns.

#### Checklist
 - [ ] Is it a proper fix? (not a workaround)
 - [x] Did you include test case for this fix, if necessary?
 - [x] Did you review existing test that can be extended to cover this scenario? Which test did you review?
 -- No test for this issue.


### Tickets:
 - 174583

Author: sungeunk

src/plugins/intel_gpu/src/graph/program_node.cpp

@@ -1679,6 +1679,17 @@ void program_node::create_onednn_primitive_attributes(
             // ********************************* Common case with output range usage ********************************* //
             const auto& q_param = desc.get_typed_fuse_params<QuantizeFuseParams>();
             if (q_param->_per_tensor_output_range && q_param->_out_lo < q_param->_out_hi) {
+                auto generate_onednn_memory_desc = [this](const cldnn::layout& lay) -> dnnl::memory::desc {
+                    if (this->is_type<gemm>() || this->is_type<fully_connected>()) {
+                        return onednn::layout_to_memory_desc(lay, onednn::get_default_data_format(lay));
+                    } else {
+                        auto mem_flag = cldnn::format::is_blocked(this->get_output_layout().format) ?
+                            onednn::mem_flags::need_blocked : onednn::mem_flags::None;
+                        return onednn::layout_to_memory_desc(lay, dnnl::memory::format_tag::undef, mem_flag);
+                    }
+                };
+
+
                 // 1. pre-scale & pre-shift
                 {
                     if (q_param->_per_tensor_input_scale && q_param->_per_tensor_input_shift) {
@@ -1691,7 +1702,8 @@ void program_node::create_onednn_primitive_attributes(
                         } else {
                             auto in_scale = get_input_layout(dep_idx++);
                             resize_layout_for_fc(this, in_scale);
-                            dnnl::memory::desc in_scale_desc = onednn::layout_to_memory_desc(in_scale, onednn::get_default_data_format(in_scale));
+
+                            dnnl::memory::desc in_scale_desc = generate_onednn_memory_desc(in_scale);
                             post_ops.append_binary(dnnl::algorithm::binary_mul, in_scale_desc);
                             update_onednn_post_op_list(onednn_post_op_type::binary_mul, dep_idx - 1, onednn::get_default_data_format(in_scale), false,
                                                        in_scale_desc.get_dims(), in_scale_desc.get_data_type());
@@ -1704,7 +1716,8 @@ void program_node::create_onednn_primitive_attributes(
                             } else {
                                 auto in_shift = get_input_layout(dep_idx++);
                                 resize_layout_for_fc(this, in_shift);
-                                dnnl::memory::desc in_shift_desc = onednn::layout_to_memory_desc(in_shift, onednn::get_default_data_format(in_shift));
+
+                                dnnl::memory::desc in_shift_desc = generate_onednn_memory_desc(in_shift);
                                 post_ops.append_binary(dnnl::algorithm::binary_add, in_shift_desc);
                                 update_onednn_post_op_list(onednn_post_op_type::binary_add, dep_idx - 1, onednn::get_default_data_format(in_shift), false,
                                                            in_shift_desc.get_dims(), in_shift_desc.get_data_type());
@@ -1737,7 +1750,8 @@ void program_node::create_onednn_primitive_attributes(
                             } else {
                                 auto out_scale = get_input_layout(dep_idx++);
                                 resize_layout_for_fc(this, out_scale);
-                                dnnl::memory::desc out_scale_desc = onednn::layout_to_memory_desc(out_scale, onednn::get_default_data_format(out_scale));
+
+                                dnnl::memory::desc out_scale_desc = generate_onednn_memory_desc(out_scale);
                                 post_ops.append_binary(dnnl::algorithm::binary_mul, out_scale_desc);
                                 update_onednn_post_op_list(onednn_post_op_type::binary_mul, dep_idx - 1, onednn::get_default_data_format(out_scale), false,
                                                            out_scale_desc.get_dims(), out_scale_desc.get_data_type());

src/plugins/intel_gpu/tests/unit/test_cases/convolution_gpu_test.cpp

@@ -10040,6 +10040,58 @@ TEST(convolution_gpu_onednn, spatial_1d) {
     }
 }
 
+TEST(convolution_gpu_onednn, spatial_1d_quantize_post_ops_blocked_format) {
+    auto& engine = get_test_engine();
+    if (!engine.get_device_info().supports_immad)
+        return;
+
+    auto in_layout = layout{{ov::Dimension(), 29, 50}, data_types::f32, format::bfyx};
+
+    tests::random_generator rg(GET_SUITE_NAME);
+
+    layout input_mem_layout{ {1, 29, 50}, data_types::f32, format::bfyx };
+    auto input_mem_data = rg.generate_random_1d<float>(input_mem_layout.count(), -1, 1);
+    auto input_mem = engine.allocate_memory(input_mem_layout);
+    set_values(input_mem, input_mem_data);
+
+    layout weights_layout{ {64, 29, 3}, data_types::i8, format::bfyx };
+    auto weights_data = rg.generate_random_1d<int8_t>(weights_layout.count(), -125, 125);
+    auto weights_mem = engine.allocate_memory(weights_layout);
+    set_values(weights_mem, weights_data);
+
+    auto input_low   = engine.allocate_memory({ {1, 64, 1}, data_types::f32, format::bfyx });
+    auto input_high  = engine.allocate_memory({ {1, 64, 1}, data_types::f32, format::bfyx });
+    auto output_low  = engine.allocate_memory({ {1, 1, 1}, data_types::f32, format::bfyx });
+    auto output_high = engine.allocate_memory({ {1, 1, 1}, data_types::f32, format::bfyx });
+    set_values(input_low,  { 0.0f });
+    set_values(input_high, { 40.0f });
+    set_values(output_low,  { 0.0f });
+    set_values(output_high, { 255.0f });
+
+    topology t(input_layout("input", in_layout),
+        data("weights", weights_mem),
+        reorder("reorder_fsv32", input_info("input"), format::b_fs_yx_fsv32, data_types::u8),
+        convolution("conv", input_info("reorder_fsv32"), "weights", "", "", "", "",
+                            0, ov::Strides{1}, ov::Strides{1}, ov::CoordinateDiff{0}, ov::CoordinateDiff{0}, false, data_types::f32),
+        data("in_lo", input_low),
+        data("in_hi", input_high),
+        data("out_lo", output_low),
+        data("out_hi", output_high),
+        quantize("quantize", input_info("conv"), input_info("in_lo"), input_info("in_hi"),
+                 input_info("out_lo"), input_info("out_hi"), 255, data_types::u8),
+        reorder("reorder", input_info("quantize"), format::bfyx, data_types::f32 ));
+
+    ExecutionConfig config = get_test_default_config(engine);
+    ov::intel_gpu::ImplementationDesc conv_impl_test_blocked = { format::b_fs_yx_fsv32, "", impl_types::onednn };
+    config.set_property(ov::intel_gpu::force_implementations(ov::intel_gpu::ImplForcingMap{ { "conv", conv_impl_test_blocked } }));
+    config.set_property(ov::intel_gpu::optimize_data(true));
+    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+
+    network network_test_blocked(engine, t, config);
+    network_test_blocked.set_input_data("input", input_mem);
+    network_test_blocked.execute();
+}
+
 struct convolution_gpu_onednn_both_shapes : public ::testing::TestWithParam<bool> {
 };