matrixSolve ERROR in Savatsky Golay Filter

[XiHuang1999]

Dear Prof.,
I am having problems using geemap for Savatsky Golay Filter for ImageCollection.
I wrote gemap's function apply_sg_filter for Savatsky Golay Filter smoothing, and the returned result is traversed through the image via a for loop, and the image is uploaded to the asset via gemap.ee_export_image_to_asset. These processes are running successfully in the Jupyter Lab .
But in GEE task, some images (with different time in same year) don't run successfully, but some can be done successfully. The errors that cannot be run successfully is reported as follows:
“Error: matrixSolve cannot solve underdetermined system.(Error code: 3)”,

Following code are Python code using geemap to smoothing with SG filter function:

# SG filter function
def apply_sg_filter(collection, band_names, window_size, order, roi):
    # 自动计算起始日期
    start_date = ee.Date(collection.sort('system:time_start').first().get('system:time_start'))
    def prepare_image(img):
        dstamp = ee.Date(img.get('system:time_start'))
        ddiff = dstamp.difference(start_date, 'day')
        const_bands = ee.Image.constant([1, ddiff, ddiff.pow(2), ddiff.pow(3)]) \
                        .rename(['constant', 't', 't2', 't3']) \
                        .float()
        return img.select(band_names).addBands(const_bands) \
                  .set('date', dstamp)
    
    prepared_collection = collection.map(prepare_image)
    
    # 设置 SG 滤波参数
    half_window = (window_size - 1) // 2
    image_axis = 0
    band_axis = 1
    coeff_flattener = [['constant', 'x', 'x2', 'x3']]
    indep_selectors = ['constant', 't', 't2', 't3']
    
    def get_local_fit(i, band_name, geometry=roi):
        # 将选定的波段和独立变量转换为数组
        array = prepared_collection.select([band_name] + indep_selectors).toArray()  # 返回类型: Array
        # 提取当前图像及其窗口内的图像
        subarray = array.arraySlice(image_axis, ee.Number(i).int(), ee.Number(i).add(window_size).int())  # 返回类型: Array
        # 分离独立变量和响应变量
        predictors = subarray.arraySlice(band_axis, 1, order + 2)  # 独立变量，返回类型: Array
        response = subarray.arraySlice(band_axis, 0, 1)  # 响应变量，返回类型: Array
    
        # 输出维度信息
        predictors_shape = predictors.arrayLength(0)  # 获取行数
        predictors_band_count = predictors.arrayLength(1)  # 获取列数
        response_shape = response.arrayLength(0)  # 行数（应与 predictors 行数相同）
    
        # 检查 NaN 和无效值
        predictors_image = ee.Image(predictors)  # 将 Array 转换为 Image
        has_nan_predictors = predictors_image.updateMask(predictors_image.eq(float('nan'))).reduceRegion(
            reducer=ee.Reducer.anyNonZero(),
            geometry=geometry,  # 使用传入的 geometry
            scale=30  # 根据需要调整比例
        ).get('array')
    
        response_image = ee.Image(response)  # 将 Array 转换为 Image
        has_nan_response = response_image.updateMask(response_image.eq(float('nan'))).reduceRegion(
            reducer=ee.Reducer.anyNonZero(),
            geometry=geometry,  # 使用传入的 geometry
            scale=30  # 根据需要调整比例
        ).get('array')
    
        # 记录检查结果
        log_info = {
            'Predictors shape': predictors_shape,
            'Predictors band count': predictors_band_count,
            'Response shape': response_shape,
            'Has NaN in predictors': has_nan_predictors,
            'Has NaN in response': has_nan_response
        }
        
        # 使用 ee.Algorithms.Log 来输出调试信息
        for key, value in log_info.items():
            print(key + ': ' + str(value))
    
        # 通过线性代数计算拟合系数
        coeff = predictors.matrixSolve(response)  # 返回类型: Array
        # 返回扁平化的系数
        return coeff.arrayProject([0]).arrayFlatten(coeff_flattener)  # 返回类型: Array

    
    # 应用 SG 滤波
    collection_size = prepared_collection.size()
    run_length = ee.List.sequence(0, collection_size.subtract(window_size))
    
    def smooth_band(band_name):
        def apply_sg(i):
            ref = prepared_collection.toList(collection_size).get(ee.Number(i).add(half_window))
            return get_local_fit(i, band_name).multiply(ee.Image(ref).select(indep_selectors)) \
                               .reduce(ee.Reducer.sum()) \
                               .rename(band_name) \
                               .copyProperties(ee.Image(ref), ['system:time_start', 'system:index']) \
                               .set('date', ee.Date(ee.Image(ref).get('system:time_start')))
        
        return ee.ImageCollection(run_length.map(apply_sg))
    
    # 对每个波段应用 SG 滤波
    smoothed_collections = [smooth_band(band) for band in band_names]
    
    # 合并所有平滑后的波段
    smoothed_collection = ee.ImageCollection(smoothed_collections[0])
    for col in smoothed_collections[1:]:
        smoothed_collection = smoothed_collection.combine(ee.ImageCollection(col))
    
    # 应用掩膜到每个平滑后的影像
    masked_smoothed_collection = smoothed_collection.map(lambda image: image.clip(roi))
    
    return masked_smoothed_collection.sort('system:time_start') 

And the code of upload to asset are following:

images = collection.toList(collection.size())

size = 37
for i in range(size):
    image = ee.Image(images.get(i))
    
    outname = assetid+r'/'+out_dir.split(os.sep)[-1]+r"_Season"+str(i+1)
    # Export Data
    geemap.ee_export_image_to_asset(image,
                                    description=outname.split('/')[-1],
                                    assetId=outname, #projects/ee-xihuangrsvp/assets/QiangTang  r'projects/ee-igsnrr2024/assets/'+outname
                                    region=block_roi,
                                    crs='epsg:4326',
                                    scale=30)

I would be grateful if you could answer this. Thank you very much!

[giswqs]

This is probably just your algorithm issue. Try a smaller regions, short time span, or coarser resoultion to reduce the computation.