Fix const in phi3 qwen and minicpm (#3072)

Fix const cast in phi3 qwen and minicpm

Author: sgonorov

src/cpp/src/image_generation/models/autoencoder_kl.cpp

@@ -32,7 +32,7 @@ class DiagonalGaussianDistribution {
         OPENVINO_ASSERT(shape[0] == 1, "Batch size must be 1");
         shape[1] /= 2;
 
-        m_mean = ov::Tensor(parameters.get_element_type(), shape, const_cast<void*>(parameters.data()));
+        m_mean = ov::Tensor(parameters.get_element_type(), shape, parameters.data());
         m_std = ov::Tensor(m_mean.get_element_type(), shape);
         ov::Tensor logvar(parameters.get_element_type(), shape, m_mean.data<float>() + m_mean.get_size());
 

src/cpp/src/llm/pipeline_stateful.cpp

@@ -325,7 +325,7 @@ EncodedResults StatefulLLMPipeline::generate(
 
     // Tail of previous output in chat mode is missing in KV cache.
     if (is_chat_conversation && m_chat_input_type == ov::genai::utils::GenerationChatInputsType::ENCODED_INPUTS) {
-        ov::Tensor new_chat_tokens = ov::Tensor{ov::element::i64, {1, m_tokenized_chat_history.size()}, const_cast<int64_t*>(m_tokenized_chat_history.data())};
+        ov::Tensor new_chat_tokens = ov::Tensor{ov::element::i64, {1, m_tokenized_chat_history.size()}, m_tokenized_chat_history.data()};
         ov::genai::align_kv_cache_and_history(new_chat_tokens, m_kv_cache_state);
 
         auto encoded_input = get_chat_encoded_input(new_chat_tokens, m_kv_cache_state);
@@ -414,7 +414,7 @@ EncodedResults StatefulLLMPipeline::generate(
             tokenized_chat_hist.reserve(state.size() + input_ids.get_size());
             std::copy(state.begin(), state.end(), std::back_inserter(tokenized_chat_hist));
             std::copy(input_ids.data<int64_t>(), input_ids.data<int64_t>() + input_ids.get_size(), std::back_inserter(tokenized_chat_hist));
-            sequence_group = std::make_shared<SequenceGroup>(request_id,  ov::Tensor(ov::element::i64, {1, tokenized_chat_hist.size()}, const_cast<int64_t*>(tokenized_chat_hist.data())), config, block_size);
+            sequence_group = std::make_shared<SequenceGroup>(request_id,  ov::Tensor(ov::element::i64, {1, tokenized_chat_hist.size()}, tokenized_chat_hist.data()), config, block_size);
         } else {
             size_t seq_len = input_ids.get_shape().at(1);
             size_t batch_offset = request_id * seq_len;

src/cpp/src/llm/pipeline_static.cpp

@@ -336,7 +336,7 @@ EncodedResults StatefulLLMPipeline::generate(
         ++position_ids_data;
         // However, attention_mask changes its shape on each iteration, it should be re-set explicitly
         attention_mask_data.push_back(1);
-        m_request.set_tensor("attention_mask", ov::Tensor(ov::element::i64, ov::Shape{1,attention_mask_data.size()}, const_cast<int64_t*>(attention_mask_data.data())));
+        m_request.set_tensor("attention_mask", ov::Tensor(ov::element::i64, ov::Shape{1,attention_mask_data.size()}, attention_mask_data.data()));
 
         m_request.infer();
 

src/cpp/src/lm_encoding.cpp

@@ -259,7 +259,7 @@ ov::genai::utils::GenerationFinishInfo get_lm_encoded_results(
             }
         }
 
-        m_llm.set_tensor("beam_idx", ov::Tensor{ov::element::i32, {total_num_tokens}, const_cast<int32_t*>(next_beams.data())});
+        m_llm.set_tensor("beam_idx", ov::Tensor{ov::element::i32, {total_num_tokens}, next_beams.data()});
 
         const auto infer_start = std::chrono::steady_clock::now();
         m_llm.start_async();

src/cpp/src/sequence_group.hpp

@@ -353,8 +353,9 @@ class SequenceGroup  : public std::enable_shared_from_this<SequenceGroup> {
     using Ptr = std::shared_ptr<SequenceGroup>;
     using CPtr = std::shared_ptr<const SequenceGroup>;
 
+    // const_cast is safe as ov::Tensor only views the data and doesn't modify it.
     SequenceGroup(uint64_t request_id, const TokenIds& input_ids, const ov::genai::GenerationConfig& sampling_params, std::size_t block_size)
-        : SequenceGroup(request_id, ov::Tensor(ov::element::i64, ov::Shape{input_ids.size()}, (void *)input_ids.data()), sampling_params, block_size, std::nullopt) {
+        : SequenceGroup(request_id, ov::Tensor(ov::element::i64, ov::Shape{input_ids.size()}, const_cast<int64_t*>(input_ids.data())), sampling_params, block_size, std::nullopt) {
     }
 
     SequenceGroup(uint64_t request_id,

src/cpp/src/speculative_decoding/speculative_decoding_stateful.cpp

@@ -191,7 +191,7 @@ int64_t LLMInferWrapper::infer_next(int64_t token, bool append_perf_stat) {
     ++m_new_position_id;
     // However, attention_mask changes its shape on each iteration, it should be re-set explicitly
     m_new_atten_mask_data.push_back(1);
-    m_request.set_tensor("attention_mask", ov::Tensor(ov::element::i64, ov::Shape{1,m_new_atten_mask_data.size()}, const_cast<int64_t*>(m_new_atten_mask_data.data())));
+    m_request.set_tensor("attention_mask", ov::Tensor(ov::element::i64, ov::Shape{1,m_new_atten_mask_data.size()}, m_new_atten_mask_data.data()));
 
     const auto infer_start = std::chrono::steady_clock::now();
     m_request.infer();

src/cpp/src/speech_generation/speecht5_tts_model.cpp

@@ -155,8 +155,8 @@ Text2SpeechDecodedResults SpeechT5TTSImpl::generate(const std::vector<std::strin
         // prepare inputs for decoder
         std::vector<float> zeros(bsz * 1 * m_num_mel_bins, 0.0f);
         std::vector<float> empty_spectrogram;
-        ov::Tensor inputs_embeds(ov::element::f32, ov::Shape{bsz, 1, m_num_mel_bins}, const_cast<float*>(zeros.data()));
-        ov::Tensor spectrogram(ov::element::f32, ov::Shape{0, bsz, 2, m_num_mel_bins}, const_cast<float*>(empty_spectrogram.data()));
+        ov::Tensor inputs_embeds(ov::element::f32, ov::Shape{bsz, 1, m_num_mel_bins}, zeros.data());
+        ov::Tensor spectrogram(ov::element::f32, ov::Shape{0, bsz, 2, m_num_mel_bins}, empty_spectrogram.data());
 
         int64_t iter = 0;
         // decoder loop

src/cpp/src/visual_language/minicpm/classes.cpp

@@ -455,7 +455,12 @@ ResampledImage VisionEncoderMiniCPM::resample_encoded_image(const EncodedImage&
             for (size_t ja = 0; ja < slices_shape.at(1); ++ja) {
                 size_t d2 = slices_shape.at(2);
                 size_t d3 = slices_shape.at(3);
-                ov::Tensor encoded_view{ov::element::f32, {1, d2, d3}, slices.data<float>() + (i * slices_shape.at(1) + ja) * d2 * d3};
+                // const_cast is safe as ov::Tensor only views the data and doesn't modify it.
+                ov::Tensor encoded_view{
+                    ov::element::f32, 
+                    {1, d2, d3}, 
+                    const_cast<float*>(slices.data<float>()) + (i * slices_shape.at(1) + ja) * d2 * d3
+                };
                 vision_embeds[ja] = resample(encoded_view, target_size, pad_to_max);
             }
             vision_embed_tensors[i] = vision_embeds;

src/cpp/src/visual_language/phi3_vision/classes.cpp

@@ -661,11 +661,12 @@ std::vector<std::variant<ov::Tensor, size_t>> drop_image_placeholders(const ov::
             text_start = offset;
             chunks.push_back(size_t(-(last_token + 1)));
         } else if (last_token >= 0 && next_token < 0) {
+            // const_cast is safe as ov::Tensor only views the data and doesn't modify it.
             chunks.emplace_back(
                 std::in_place_type<ov::Tensor>,
                 ov::element::i64,
                 ov::Shape{1, offset - text_start},
-                tokens.data<int64_t>() + text_start
+                const_cast<int64_t*>(tokens.data<int64_t>()) + text_start
             );
         } else if (last_token < 0 && next_token < 0 && last_token != next_token) {
             chunks.push_back(size_t(-(last_token + 1)));
@@ -675,11 +676,12 @@ std::vector<std::variant<ov::Tensor, size_t>> drop_image_placeholders(const ov::
     // Add the last chunk
     size_t full_length = tokens.get_shape().at(1);
     if (last_token >= 0) {
+        // const_cast is safe as ov::Tensor only views the data and doesn't modify it.
         chunks.emplace_back(
             std::in_place_type<ov::Tensor>,
             ov::element::i64,
             ov::Shape{1, full_length - text_start},
-            tokens.data<int64_t>() + text_start
+            const_cast<int64_t*>(tokens.data<int64_t>()) + text_start
         );
     } else {
         chunks.push_back(size_t(-(last_token + 1)));

src/cpp/src/visual_language/phi4mm/classes.cpp

@@ -728,6 +728,7 @@ EncodedImage VisionEncoderPhi4MM::encode(const ov::Tensor& image, const ov::AnyM
     {
         ov::Tensor height{ov::element::i32, {}};
         ov::Tensor width{ov::element::i32, {}};
+        // const_cast is safe as ov::Tensor only views the data and doesn't modify it.
         ov::Tensor sub_GN{ov::element::f32, {1, 1, 1, m_vlm_config.sub_GN.size()}, const_cast<float*>(m_vlm_config.sub_GN.data())};
         ov::Tensor glb_GN{ov::element::f32, {1, 1, m_vlm_config.glb_GN.size()}, const_cast<float*>(m_vlm_config.glb_GN.data())};
         height.data<int32_t>()[0] = image_height;