[GPU] Minor fix for dynamic model (#18715)

Signed-off-by: Andrew Park <andrew.park@intel.com>

src/plugins/intel_gpu/src/graph/impls/ocl/activation.cpp

@@ -53,10 +53,11 @@ struct activation_impl : typed_primitive_impl_ocl<activation> {
             const auto& slope_layout = impl_param.input_layouts[1];
             const auto& output_layout = impl_param.get_output_layout();
 
-            const auto params_num = kernel_selector::GetActivationAdditionalParamsNumber(params.activations[0].function);
-
-            OPENVINO_ASSERT(slope_layout.count() >= static_cast<size_t>(output_layout.feature() * params_num), "[GPU] Invalid slope size in ", primitive->id);
-
+            if (!impl_param.is_dynamic()) {
+                const auto params_num = kernel_selector::GetActivationAdditionalParamsNumber(params.activations[0].function);
+                OPENVINO_ASSERT(slope_layout.count() >= static_cast<size_t>(output_layout.feature() * params_num),
+                                "[GPU] Invalid slope size in ", primitive->id);
+            }
             params.inputActivationParams.push_back(convert_data_tensor(slope_layout));
         }
 

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

@@ -1676,6 +1676,78 @@ TEST(activation_f32_fw_gpu, b_fs_yx_fsv16_prelu) {
     }
 }
 
+TEST(activation_f32_fw_gpu, bfyx_prelu_dyn) {
+    constexpr int b = 1;
+    constexpr int f = 17;
+    constexpr int x = 2;
+    constexpr int y = 2;
+
+    tests::random_generator rg(GET_SUITE_NAME);
+    auto& eng = get_test_engine();
+
+    ov::PartialShape in_shape = { b, f, y, x };
+    auto in_lay = cldnn::layout(ov::PartialShape::dynamic(in_shape.size()), cldnn::data_types::f32, cldnn::format::bfyx);
+    auto params_lay = cldnn::layout(ov::PartialShape{ 1, f, 1, 1 }, cldnn::data_types::f32, cldnn::format::bfyx);
+
+    auto in_mem = eng.allocate_memory({ in_shape, cldnn::data_types::f32, cldnn::format::bfyx });
+    auto params_mem = eng.allocate_memory(params_lay);
+
+    auto in_data = rg.generate_random_4d<float>(b, f, y, x, -1, 1);
+    auto params_data = rg.generate_random_1d<float>(f, -1, 1);
+
+    set_values(params_mem, params_data);
+
+    auto topo = cldnn::topology(
+        cldnn::input_layout("in", in_lay),
+        cldnn::data("actv_params", params_mem),
+        cldnn::activation("actv", input_info("in"), "actv_params", cldnn::activation_func::relu_negative_slope)
+    );
+
+    ExecutionConfig config = get_test_default_config(eng);
+    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+    cldnn::network net(eng, topo, config);
+
+    set_values(in_mem, flatten_4d(format::bfyx, in_data));
+    net.set_input_data("in", in_mem);
+
+    auto inst = net.get_primitive("actv");
+    auto impl = inst->get_impl();
+    ASSERT_TRUE(impl != nullptr);
+    ASSERT_TRUE(impl->is_dynamic());
+
+    auto outputs = net.execute();
+    ASSERT_EQ(outputs.size(), size_t(1));
+    ASSERT_EQ(outputs.begin()->first, "actv");
+
+    auto out_mem = outputs.at("actv").get_memory();
+    auto out_layout = out_mem->get_layout();
+
+    int b_size = out_layout.batch();
+    int f_size = out_layout.feature();
+    int y_size = out_layout.spatial(1);
+    int x_size = out_layout.spatial(0);
+
+    ASSERT_EQ(out_layout.format, format::bfyx);
+    ASSERT_EQ(b_size, b);
+    ASSERT_EQ(f_size, f);
+    ASSERT_EQ(y_size, y);
+    ASSERT_EQ(x_size, x);
+
+    std::vector<float> expected = flatten_4d(format::bfyx, in_data);
+    for (size_t i = 0; i < expected.size(); ++i) {
+        if (expected[i] < 0.f) {
+            expected[i] = expected[i] * params_data[i / (x * y) % f];
+        }
+    }
+
+    cldnn::mem_lock<float> out_ptr(out_mem, get_test_stream());
+    ASSERT_EQ(expected.size(), out_ptr.size());
+
+    for (size_t i = 0; i < expected.size(); ++i) {
+        ASSERT_EQ(expected[i], out_ptr[i]) << "at i=" << i;
+    }
+}
+
 using activation_random_test_params = std::tuple<data_types,
                                                  format::type,                  // input_format
                                                  tensor,                        // input_size