Update cast of tensor data pointer for const tensors (#1966)

### Description
- Update casting/getting data pointer from tensor when tensor can return
const pointer to data
- Use new version of OpenVINO YTokenizers which also contains similar
update

### Blocking
- openvinotoolkit/openvino#29594

Signed-off-by: Raasz, Pawel <pawel.raasz@intel.com>

Author: praasz

src/cpp/src/image_generation/flux_pipeline.hpp

@@ -22,7 +22,7 @@ ov::Tensor pack_latents(const ov::Tensor latents, size_t batch_size, size_t num_
 
     OPENVINO_ASSERT(latents.get_size() == permuted_latents.get_size(), "Incorrect target shape, tensors must have the same sizes");
 
-    float* src_data = latents.data<float>();
+    auto src_data = latents.data<float>();
     float* dst_data = permuted_latents.data<float>();
 
     // Permute to (0, 2, 4, 1, 3, 5)

src/cpp/src/image_generation/stable_diffusion_3_pipeline.hpp

@@ -51,7 +51,7 @@ ov::Tensor get_tensor_batch(const ov::Tensor input, size_t batch_id) {
     OPENVINO_ASSERT(target_shape.at(0) > batch_id, "Cannot get batch with id ", batch_id, ", total batch size is ", target_shape.at(0));
     target_shape[0] = 1;
 
-    void * target_data = input.data<float>() + batch_id * ov::shape_size(target_shape);
+    auto target_data = input.data<float>() + batch_id * ov::shape_size(target_shape);
     ov::Tensor target_tensor(input.get_element_type(), target_shape, target_data);
 
     return target_tensor;
@@ -377,7 +377,7 @@ class StableDiffusion3Pipeline : public DiffusionPipeline {
             ov::Tensor negative_pooled_prompt_2_embed_out = get_tensor_batch(text_encoder_2_output, 0);
             ov::Tensor negative_prompt_2_embed_out = get_tensor_batch(text_encoder_2_hidden_state, 0);
             ov::Tensor negative_t5_prompt_embed_out = get_tensor_batch(text_encoder_3_output, 0);
-            
+
             ov::Tensor negative_pooled_prompt_embed, negative_prompt_embed, negative_pooled_prompt_2_embed,
                 negative_prompt_2_embed, negative_t5_prompt_embed;
             if (generation_config.num_images_per_prompt == 1) {

src/cpp/src/llm_pipeline_static.cpp

@@ -23,7 +23,7 @@ void fill_tensor(ov::Tensor tensor, T fill_val, size_t offset = 0u) {
 }
 
 void copy_with_offset(const ov::Tensor& orig, const std::size_t offset, ov::Tensor& padded) {
-    int64_t* orig_data = orig.data<int64_t>();
+    auto orig_data = orig.data<int64_t>();
     int64_t* padded_data = padded.data<int64_t>();
     std::copy(orig_data, orig_data + orig.get_size(), padded_data + offset);
 }
@@ -56,8 +56,8 @@ void copy_columns_by_row_chunks(const ov::Tensor& src, ov::Tensor& dst) {
 
     const size_t chunk_byte_size = W * elem_size;
 
-    const auto* src_p  = static_cast<uint8_t*>(src.data());
-          auto* dst_p  = static_cast<uint8_t*>(dst.data());
+    const auto* src_p = static_cast<const uint8_t*>(src.data());
+    auto* dst_p = static_cast<uint8_t*>(dst.data());
 
     for (size_t i = 0; i < C*H; ++i) {
         const size_t src_offset = i * IS_H;

src/cpp/src/lm_encoding.cpp

@@ -27,7 +27,7 @@ void update_position_ids(ov::Tensor&& position_ids, const ov::Tensor&& attention
     position_ids.set_shape({batch_size, 1});
 
     for (size_t batch = 0; batch < batch_size; batch++) {
-        int64_t* mask_start = attention_mask.data<int64_t>() + batch * sequence_length;
+        auto mask_start = attention_mask.data<int64_t>() + batch * sequence_length;
         position_ids.data<int64_t>()[batch] = std::accumulate(mask_start, mask_start + sequence_length - 1, 0);
     }
 }

src/cpp/src/visual_language/llava/classes.cpp

@@ -40,7 +40,7 @@ clip_image_f32 preprocess_clip_image_llava(const clip_image_u8& image, const Pro
         for (int y = 0; y < crop_height; ++y) {
             for (int x = 0; x < crop_width; ++x) {
                 for (int c = 0; c < 3; ++c) {
-                    cropped_image.buf[(y * crop_width + x) * 3 + c] = 
+                    cropped_image.buf[(y * crop_width + x) * 3 + c] =
                         resized_image.buf[((start_y + y) * resized_image.nx + (start_x + x)) * 3 + c];
                 }
             }
@@ -146,18 +146,17 @@ ov::Tensor InputsEmbedderLLaVA::get_inputs_embeds(const std::string& prompt, con
     return merge_text_and_image_embeddings_llava(input_ids, text_embeds, image_embeds, image_token_id);
 }
 
-ov::Tensor InputsEmbedderLLaVA::merge_text_and_image_embeddings_llava(
-    const ov::Tensor& input_ids,
-    const ov::Tensor& text_embeds,
-    const std::vector<ov::Tensor>& image_embeds,
-    int64_t image_token_id) {
+ov::Tensor InputsEmbedderLLaVA::merge_text_and_image_embeddings_llava(const ov::Tensor& input_ids,
+                                                                      ov::Tensor& text_embeds,
+                                                                      const std::vector<ov::Tensor>& image_embeds,
+                                                                      int64_t image_token_id) {
     auto text_embeds_shape = text_embeds.get_shape();
     size_t text_embeds_seq_length = text_embeds_shape[1];
     size_t hidden_size = text_embeds_shape[2];
 
     const int64_t* input_ids_data = input_ids.data<const int64_t>();
     int token_offset = text_embeds_seq_length - 1;
-    float* text_embeds_data = text_embeds.data<float>();
+    auto text_embeds_data = text_embeds.data<float>();
     const float* text_embeds_end = text_embeds_data + text_embeds_seq_length * hidden_size;
 
     // Copy in reversed order because a tokenizer may truncate the input removing the preffix.
@@ -178,7 +177,7 @@ ov::Tensor InputsEmbedderLLaVA::merge_text_and_image_embeddings_llava(
         }
         size_t n_tokens = std::min(image_embed_it->get_shape().at(1), size_t(token_offset - changed_token_offset));
         size_t n_floats = n_tokens * hidden_size;
-        float* text_embeds_idx = text_embeds_data + (changed_token_offset + 1) * hidden_size;
+        auto text_embeds_idx = text_embeds_data + (changed_token_offset + 1) * hidden_size;
         OPENVINO_ASSERT(text_embeds_idx + n_floats <= text_embeds_end);
         std::copy_n(
             image_embed_it->data<const float>() + image_embed_it->get_size() - n_floats,
@@ -190,4 +189,4 @@ ov::Tensor InputsEmbedderLLaVA::merge_text_and_image_embeddings_llava(
     return text_embeds;
 }
 
-} // namespace ov::genai
+} // namespace ov::genai

src/cpp/src/visual_language/llava/classes.hpp

@@ -41,7 +41,7 @@ class InputsEmbedderLLaVA : public InputsEmbedder::IInputsEmbedder {
 protected:
     ov::Tensor merge_text_and_image_embeddings_llava(
         const ov::Tensor& input_ids,
-        const ov::Tensor& text_embeds,
+        ov::Tensor& text_embeds,
         const std::vector<ov::Tensor>& image_embeds,
         int64_t image_token_id);
 };

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

@@ -306,7 +306,7 @@ EncodedImage llava_image_embed_make_with_bytes_slice(clip_ctx& ctx_clip, const o
     ov::Tensor pixel_values{ov::element::f32, {n_images, channels, patch_size, max_size / patch_size}};
     size_t d3_all_pixel = pixel_values.get_shape().at(3);
     float* pixel_value_data = pixel_values.data<float>();
-    
+
     //image chw to 1*c*kernel*hw/kernel and padding zero
     clip_image_f32& resized_preprocessed = preprocessed.at(0).at(0);
     size_t img_h = resized_preprocessed.ny;
@@ -321,7 +321,7 @@ EncodedImage llava_image_embed_make_with_bytes_slice(clip_ctx& ctx_clip, const o
         for (size_t k_idx = 0; k_idx < patch_size; k_idx++) {
             std::copy(clip_value_data, clip_value_data + d3_clip_pixel, pixel_value_data);
             clip_value_data += d3_clip_pixel;
-            pixel_value_data += d3_all_pixel; 
+            pixel_value_data += d3_all_pixel;
         }
     }
 
@@ -334,7 +334,7 @@ EncodedImage llava_image_embed_make_with_bytes_slice(clip_ctx& ctx_clip, const o
                 img_w = elem.nx;
                 ov::Tensor clip_img{ov::element::f32, {1, channels, img_h, img_w}, elem.buf.data()};
                 ov::Tensor clip_pixel_values = preprocess_for_encoder(clip_img, patch_size);
-                
+
                 d3_clip_pixel = clip_pixel_values.get_shape().at(3);
                 clip_value_data = clip_pixel_values.data<float>();
                 pixel_value_data = pixel_values.data<float>() + batch_pixel * channels * patch_size * d3_all_pixel;
@@ -425,8 +425,8 @@ ov::Tensor concatenate_last_dim(const ov::Tensor& first, const ov::Tensor& secon
     OPENVINO_ASSERT(second.get_shape().at(1) == res_d_1);
     size_t res_d_2 = first.get_shape().at(2) + second.get_shape().at(2);
     ov::Tensor res{first.get_element_type(), {res_d_0, res_d_1, res_d_2}};
-    float* first_data = first.data<float>();
-    float* second_data = second.data<float>();
+    auto first_data = first.data<float>();
+    auto second_data = second.data<float>();
     float* res_data = res.data<float>();
     for (size_t i = 0; i < res_d_0; ++i) {
         for (size_t j = 0; j < res_d_1; ++j) {
@@ -461,8 +461,8 @@ ov::Tensor get_1d_sincos_pos_embed_from_grid_new(size_t embed_dim, const ov::Ten
     std::vector<size_t> out_shape = {H, W, embed_dim};
     ov::Tensor emb(ov::element::f32, out_shape);
 
-    float* pos_data = pos.data<float>();
-    float* emb_data = emb.data<float>();
+    auto pos_data = pos.data<float>();
+    auto emb_data = emb.data<float>();
 
     size_t counter = 0;
     for (size_t h = 0; h < H; ++h) {
@@ -481,7 +481,7 @@ ov::Tensor get_1d_sincos_pos_embed_from_grid_new(size_t embed_dim, const ov::Ten
 ov::Tensor get_2d_sincos_pos_embed_from_grid(size_t embed_dim, const ov::Tensor& grid) {
     OPENVINO_ASSERT(embed_dim % 2 == 0);
     ov::Shape grid_shape = grid.get_shape();
-    float* grid_data = grid.data<float>();
+    auto grid_data = grid.data<float>();
     ov::Shape plane_shape{grid_shape.at(1), grid_shape.at(2)};
     ov::Tensor emb_h = get_1d_sincos_pos_embed_from_grid_new(embed_dim / 2, ov::Tensor{
         ov::element::f32,
@@ -650,7 +650,7 @@ ov::Tensor InputsEmbedderMiniCPM::get_inputs_embeds(const std::string& prompt, c
     for (size_t image_id : images_sequence) {
         const EncodedImage& encoded_image = images.at(image_id - m_prev_image_id);
         const ov::Tensor& resampled_source = resample(encoded_image.resized_source, {encoded_image.resized_source_size});
-        float* emb = resampled_source.data<float>();
+        auto emb = resampled_source.data<float>();
         ids = std::find(ids, end, im_start_id);
         OPENVINO_ASSERT(end != ids);
         ++ids;
@@ -752,4 +752,4 @@ ov::Tensor InputsEmbedderMiniCPM::resample(const ov::Tensor& encoded_image, cons
     return resampler.get_output_tensor();  // [N, query_num, new_hidden_size]
 }
 
-} // namespace ov::genai
+} // namespace ov::genai

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

@@ -79,7 +79,7 @@ ov::Tensor padding_336(const ov::Tensor& unpadded) {
     ov::Tensor padded{ov::element::u8, {1, s1, tar, 3}};
     uint8_t* padded_data = padded.data<uint8_t>();
     std::fill_n(padded_data, padded.get_size(), 255);
-    uint8_t* unpadded_data = unpadded.data<uint8_t>();
+    auto unpadded_data = unpadded.data<uint8_t>();
     for (size_t row = 0; row < s1; ++row) {
         std::copy_n(unpadded_data + row * s2 * 3, s2 * 3, padded_data + row * tar * 3 + left_padding * 3);
     }
@@ -103,7 +103,7 @@ ov::Tensor HD_transform(const ov::Tensor& uint8, size_t num_crops) {
     size_t new_w = scale * INPUT_IMAGE_SIZE;
     size_t new_h = new_w / ratio;
     clip_image_u8 src{}, dst{};
-    uint8_t* uint8_data = uint8.data<uint8_t>();
+    auto uint8_data = uint8.data<uint8_t>();
     if (trans) {
         src = clip_image_u8{int(height), int(width), {uint8_data, uint8_data + uint8.get_size()}};
         bilinear_resize(src, dst, new_h, new_w);
@@ -115,7 +115,7 @@ ov::Tensor HD_transform(const ov::Tensor& uint8, size_t num_crops) {
 }
 
 ov::Tensor mean_scale(const ov::Tensor& uint8, const ProcessorConfig& config) {
-    uint8_t* uint_8_data = uint8.data<uint8_t>();
+    auto uint_8_data = uint8.data<uint8_t>();
     ov::Tensor float_normalized{ov::element::f32, uint8.get_shape()};
     float* float_data = float_normalized.data<float>();
     OPENVINO_ASSERT(0 == uint8.get_size() % 3, "RGB");
@@ -130,7 +130,7 @@ ov::Tensor mean_scale(const ov::Tensor& uint8, const ProcessorConfig& config) {
 ov::Tensor channels_first(const ov::Tensor& _1hw3) {
     ov::Shape shape = _1hw3.get_shape();
     ov::Tensor _13hw = ov::Tensor{ov::element::f32, {1, 3, shape.at(1), shape.at(2)}};
-    float* _1hw3_data = _1hw3.data<float>();
+    auto _1hw3_data = _1hw3.data<float>();
     float* _13hw_data = _13hw.data<float>();
     for (size_t plane = 0; plane < 3; ++plane) {
         for (size_t row = 0; row < shape.at(1); ++row) {
@@ -156,7 +156,7 @@ ov::Tensor slice_image(const ov::Tensor& image) {
     // Step 1: Define and populate the reshaped tensor in the correct shape order
     ov::Tensor reshaped{ov::element::f32, {N, num_h_slices, num_w_slices, C, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE}};
     float* reshaped_data = reshaped.data<float>();
-    float* image_data = image.data<float>();
+    auto image_data = image.data<float>();
 
     // Populate the reshaped tensor
     for (size_t n = 0; n < N; ++n) {
@@ -217,8 +217,8 @@ ov::Tensor concatenate_batch(const ov::Tensor& float_first, const ov::Tensor& fl
     OPENVINO_ASSERT(shape_first.at(3) == shape_second.at(3), "Width must be the same");
     ov::Tensor concatenated{ov::element::f32, {shape_first.at(0) + shape_second.at(0), shape_first.at(1), shape_first.at(2), shape_first.at(3)}};
     float* concatenated_data = concatenated.data<float>();
-    float* first_data = float_first.data<float>();
-    float* second_data = float_second.data<float>();
+    auto first_data = float_first.data<float>();
+    auto second_data = float_second.data<float>();
     std::copy(first_data, first_data + float_first.get_size(), concatenated_data);
     std::copy(second_data, second_data + float_second.get_size(), concatenated_data + float_first.get_size());
     return concatenated;
@@ -232,7 +232,7 @@ ov::Tensor pad_to_max_num_crops_tensor(const ov::Tensor& nchw, size_t max_crops)
     }
     ov::Tensor padded{ov::element::f32, {max_crops, shape[1], shape[2], shape[3]}};
     float* padded_data = padded.data<float>();
-    float* nchw_data = nchw.data<float>();
+    auto nchw_data = nchw.data<float>();
     std::copy_n(nchw_data, nchw.get_size(), padded_data);
     return padded;
 }