Const-related fixes on tesor creation (#3026)

Fixes const-related casting issues in tests and code.

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, parameters.data());
+        m_mean = ov::Tensor(parameters.get_element_type(), shape, const_cast<void*>(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()}, m_tokenized_chat_history.data()};
+        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::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()}, 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()}, const_cast<int64_t*>(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()}, (void*)&attention_mask_data[0]));
+        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.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}, next_beams.data()});
+        m_llm.set_tensor("beam_idx", ov::Tensor{ov::element::i32, {total_num_tokens}, const_cast<int32_t*>(next_beams.data())});
 
         const auto infer_start = std::chrono::steady_clock::now();
         m_llm.start_async();

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()}, (void*)&m_new_atten_mask_data[0]));
+    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())));
 
     const auto infer_start = std::chrono::steady_clock::now();
     m_request.infer();

src/cpp/src/speech_generation/speecht5_tts_model.cpp

@@ -154,8 +154,9 @@ Text2SpeechDecodedResults SpeechT5TTSImpl::generate(const std::vector<std::strin
 
         // prepare inputs for decoder
         std::vector<float> zeros(bsz * 1 * m_num_mel_bins, 0.0f);
-        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}, std::vector<float>{}.data());
+        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()));
 
         int64_t iter = 0;
         // decoder loop

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

@@ -728,8 +728,8 @@ EncodedImage VisionEncoderPhi4MM::encode(const ov::Tensor& image, const ov::AnyM
     {
         ov::Tensor height{ov::element::i32, {}};
         ov::Tensor width{ov::element::i32, {}};
-        ov::Tensor sub_GN{ov::element::f32, {1, 1, 1, m_vlm_config.sub_GN.size()}, m_vlm_config.sub_GN.data()};
-        ov::Tensor glb_GN{ov::element::f32, {1, 1, m_vlm_config.glb_GN.size()}, m_vlm_config.glb_GN.data()};
+        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;
         width.data<int32_t>()[0] = image_width;
         CircularBufferQueueElementGuard<ov::InferRequest> lock{m_separator_inserters.get()};

src/cpp/src/visual_language/qwen2vl/classes.cpp

@@ -807,7 +807,7 @@ void VisionEncoderQwen2VL::encode_with_imagepreprocess_ov(const std::vector<ov::
     const float VIDEO_BRANCH_CONDITION = 0.f;
     const float IMAGE_BRANCH_CONDITION = 1.f;
     std::vector<float> cond_img_vid_data{images.size() == 2u ? VIDEO_BRANCH_CONDITION : IMAGE_BRANCH_CONDITION};
-    ov::Tensor cond_img_vid(ov::element::f32, ov::Shape{1}, cond_img_vid_data.data());
+    ov::Tensor cond_img_vid(ov::element::f32, ov::Shape{1}, const_cast<float*>(cond_img_vid_data.data()));
     ov::Tensor input_image_1(ov::element::u8, image_shape, images[0].data<uint8_t>());
     ov::Tensor input_image_2(ov::element::u8,
                              image_shape,

src/cpp/src/whisper/whisper.cpp

@@ -77,7 +77,7 @@ std::pair<ov::genai::EncodedResults, bool> decode(std::shared_ptr<ov::genai::Whi
     ov::Tensor beam_idx = decoder->create_host_tensor(ov::element::i32, {batch_size});
     std::fill_n(beam_idx.data<int32_t>(), batch_size, 0);
 
-    const ov::Tensor input_ids_tensor{ov::element::i64, {1, input_ids.size()}, (void*)input_ids.data()};
+    const ov::Tensor input_ids_tensor{ov::element::i64, {1, input_ids.size()}, const_cast<int64_t*>(input_ids.data())};
 
     const auto infer_start = std::chrono::steady_clock::now();
     decoder->start_async(encoder_hidden_state, input_ids_tensor, beam_idx);
@@ -202,7 +202,7 @@ ov::Tensor encode(ov::InferRequest& request,
                     ". Actual size: ",
                     mel_data.size(),
                     ".");
-    ov::Tensor input_tensor(ov::element::f32, {1, feature_size, nb_max_frames}, mel_data.data());
+    ov::Tensor input_tensor(ov::element::f32, {1, feature_size, nb_max_frames}, const_cast<float*>(mel_data.data()));
 
     request.set_tensor("input_features", input_tensor);
 

tests/cpp/block_manager.cpp

@@ -15,7 +15,7 @@ TEST(TestBlockManager, general_test) {
     ov::genai::SequenceGroup::Ptr sequence_group = std::make_shared<ov::genai::SequenceGroup>(
         0,
         ov::Tensor(ov::element::i64, {
-        prompt_ids.size()}, prompt_ids.data()),
+        prompt_ids.size()}, const_cast<int64_t*>(prompt_ids.data())),
         ov::genai::beam_search(),
         4);
     auto sequence = sequence_group->get_not_finished_sequences()[0];
@@ -44,11 +44,11 @@ TEST(TestBlockManager, general_test) {
 TEST(TestBlockManager, required_blocks_count) {
     ov::genai::BlockManager bm = ov::genai::BlockManager(8, false, 4, 3);
 
-    std::vector<uint64_t> tokens = {0,1,2,3,4};
+    std::vector<int64_t> tokens = {0,1,2,3,4};
     ov::genai::SequenceGroup::Ptr sequence_group = std::make_shared<ov::genai::SequenceGroup>(
         0,
         ov::Tensor(ov::element::i64, {
-        tokens.size()}, tokens.data()),
+        tokens.size()}, const_cast<int64_t*>(tokens.data())),
         ov::genai::beam_search(),
         4);
     sequence_group->schedule_tokens(5);
@@ -94,11 +94,11 @@ TEST(TestBlockManager, CanFreeBlocksFromSequence) {
     const size_t BLOCK_SIZE = 2;
     ov::genai::BlockManager bm = ov::genai::BlockManager(8, false, BLOCK_SIZE, 3);
 
-    std::vector<uint64_t> tokens = {0,1,2,3,4};
+    std::vector<int64_t> tokens = {0,1,2,3,4};
     ov::genai::SequenceGroup::Ptr sequence_group = std::make_shared<ov::genai::SequenceGroup>(
             0,
             ov::Tensor(ov::element::i64, {
-                    tokens.size()}, tokens.data()),
+                    tokens.size()}, const_cast<int64_t*>(tokens.data())),
             ov::genai::beam_search(),
             BLOCK_SIZE);
     sequence_group->schedule_tokens(5);