如何通过插值拉伸向量？多不同大小向量扩容至指定维度问询

Hey there! Let's walk through your questions clearly—resizing vectors (especially stretching to higher dimensions) is super common in fields like ML feature engineering, signal processing, and data preprocessing. Let's break this down:

1. How to Stretch a Vector to Increase Its Dimension via Interpolation? #

Interpolation works by inserting calculated values between existing vector elements to extend its length. The most straightforward and widely used method is linear interpolation, and for smoother results, you can use cubic spline interpolation.

Linear Interpolation Basics #

Say you have an original vector v of length n, and you want to stretch it to length m (where m > n):

• Calculate the mapping between new positions and original positions: For each index i in the new vector (0 ≤ i < m), the corresponding position in the original vector is x = i * (n-1)/(m-1)
• If x is an integer, just take v[x] directly
• If x is a decimal, compute a weighted average of the two nearest original elements:
  v_new[i] = v[floor(x)] * (1 - fractional_part(x)) + v[ceil(x)] * fractional_part(x)

Quick Example: Stretching [1, 3, 5] (length 3) to length 5:

• New index 0 → x=0 → value=1
• New index 1 → x=0.5 → (10.5)+(30.5)=2
• New index 2 → x=1 → value=3
• New index 3 → x=1.5 → (30.5)+(50.5)=4
• New index 4 → x=2 → value=5
  Result: [1,2,3,4,5]

2. Resizing Multiple Vectors of Different Sizes—Should I Use Interpolation? #

Short answer: Interpolation is the best choice if your vectors represent continuous data (like time-series signals, sensor readings, or image feature vectors). If your vectors are discrete (e.g., categorical labels, one-hot encoded data), interpolation doesn't make sense—you'd use methods like repeating elements, padding with a constant, or random sampling instead.

Your Specific Example: Resizing a 2244-length Vector to 3153 #

Let's use linear interpolation here (it's efficient and works for most use cases). Here's how to implement it, plus code:

Step-by-Step Logic

1. Original length n = 2244, target length m = 3153
2. Compute the scale factor: scale = (n-1)/(m-1) = 2243/3152 ≈ 0.7116
3. For each index i in the new vector:
   • Calculate the mapped position in the original vector: x = i * scale
   • Split x into integer part (x_int) and fractional part (x_frac)
   • If x_int is the last index of the original vector, just take that value
   • Otherwise, compute the weighted average of v[x_int] and v[x_int+1]

Python Code Implementation

import numpy as np

def linear_interpolate_vector(original_vec, target_length):
    n = len(original_vec)
    if n == target_length:
        return original_vec.copy()
    # Generate mapped positions from original to target
    mapped_positions = np.linspace(0, n-1, target_length)
    # Split into integer and fractional parts
    int_pos = mapped_positions.astype(int)
    frac_pos = mapped_positions - int_pos
    # Fix the last position to avoid index out-of-bounds
    int_pos[-1] = n - 2
    frac_pos[-1] = 1.0
    # Calculate interpolated values
    new_vec = original_vec[int_pos] * (1 - frac_pos) + original_vec[int_pos + 1] * frac_pos
    return new_vec

# Test with your example
original = np.random.rand(2244)  # Replace with your actual vector
expanded = linear_interpolate_vector(original, 3153)
print(len(expanded))  # Output: 3153

Alternative: Cubic Spline Interpolation (For Smoother Results)

If you need a smoother curve (e.g., for audio or image data), use cubic spline interpolation instead:

from scipy.interpolate import interp1d

def cubic_interpolate_vector(original_vec, target_length):
    original_indices = np.arange(len(original_vec))
    target_indices = np.linspace(0, len(original_vec)-1, target_length)
    interpolator = interp1d(original_indices, original_vec, kind='cubic')
    return interpolator(target_indices)

内容的提问来源于stack exchange，提问作者messier