Python 数据帧：复线性插值

我有一个包含4个部分的数据框架

第1节：产品详情

第2节：基于一系列模拟的6个潜在产品价值

第3节：模拟输入参数的上限和下限

第4节：输入参数的随机生成值

---

第2节通过在上限和下限之间的相等间隔对产品进行定价来生成

我需要取第4节中的值并计算出相应的产品值。以下是此数据帧的可能设置：

table2 = pd.DataFrame({
        'Product Type': ['A', 'B', 'C', 'D'],
        'State_1_Value': [10, 11, 12, 13],
    'State_2_Value': [20, 21, 22, 23],
    'State_3_Value': [30, 31, 32, 33],
    'State_4_Value': [40, 41, 42, 43],
    'State_5_Value': [50, 51, 52, 53],
    'State_6_Value': [60, 61, 62, 63],
    'Lower_Bound': [-1, 1, .5, 5],
    'Upper_Bound': [1, 2, .625, 15],
    'sim_1': [0, 0, .61, 7],
    'sim_2': [1, 1.5, .7, 9],
    })

>>> table2
   Lower_Bound Product Type  State_1_Value  State_2_Value  State_3_Value  \
0         -1.0            A             10             20             30   
1          1.0            B             11             21             31   
2          0.5            C             12             22             32   
3          5.0            D             13             23             33   

   State_4_Value  State_5_Value  State_6_Value  Upper_Bound  sim_1  sim_2  
0             40             50             60        1.000    0.0    1.0  
1             41             51             61        2.000    0.0    1.5  
2             42             52             62        0.625    0.61    0.7  
3             43             53             63       15.000    7.0    9.0  

我将通过几个例子来说明我的问题

产品A-模拟2 这里的输入是1.0。这等于此产品的上限。因此，模拟值相当于状态_6值-60

产品B-模拟2 这里的输入是1.5。LB到UB的范围是（1,2），因此6个状态是{1,1.2,1.4,1.6,1.8,2}。1.5正好处于状态31的状态STATE3中，状态4的值为41。因此，模拟值为36

产品C-sim_1 这里的输入是.61。LB到UB的范围是（.5、.625），因此6个状态是{.5、.525、.55、.575、.6、.625}。61介于状态5和状态6之间。具体来说，它将落下的桶是5*（.61-.5）/（.625-.5）+1=5.4（它乘以5，因为这是间隔的数量-你可以用其他方法计算它，得到相同的结果）。然后，为了计算该值，我们使用该桶对状态5和状态6的值进行称重：（62-52）*（5.4-5）+52=56

产品B-sim_1 这里的输入是0，低于1的下限。因此，我们需要外推该值。我们使用与上面相同的公式，我们只使用状态1和状态2的值进行外推。铲斗应为5*（0-1）/（2-1）+1=-4。在11和21处使用的两个值，因此该值为（21-11）*（-4-1）+11=-39

我还简化了问题，尝试将解决方案可视化，我的最终代码需要在500个值和10000个模拟上运行，数据帧将有大约200行

以下是我用于插值的公式，尽管我没有特别说明

铲斗=N*（sim_值-LB）/（UB-LB）+1 其中N是间隔数

然后nLower是bucket正下方的状态值，nHigher是bucket正上方的状态值。如果铲斗位于UB/LB之外，则强制nLower和nHigher为前两个或后两个值

最终功率值=（nHigher nLower）*（Bucket1-功率值）+nLower的数量

---

总而言之，我的问题是如何根据提供的输入数据组合生成最终结果。对我来说，最具挑战性的部分是如何将桶号连接到nLower和nHigher值。

我能够使用以下代码生成结果。我不确定大型数据帧的内存含义，所以仍然对更好的答案或改进感兴趣

编辑：在完整的数据集上运行这段代码，141行，500次间隔，10000次模拟，花费了略多于1.5小时。所以并不像我想象的那样毫无用处，但在这段时间里，也许有一种更聪明的方法可以做到这一点

for i in range(1,3):
    table2['Bucket%s'%i] = 5 * (table2['sim_%s'%i] - table2['Lower_Bound']) / (table2['Upper_Bound'] - table2['Lower_Bound']) + 1
    table2['lv'] = table2['Bucket%s'%i].map(int)
    table2['hv'] = table2['Bucket%s'%i].map(int) + 1
    table2.ix[table2['lv'] < 1 , 'lv'] = 1
    table2.ix[table2['lv'] > 5 , 'lv'] = 5
    table2.ix[table2['hv'] > 6 , 'hv'] = 6
    table2.ix[table2['hv'] < 2 , 'hv'] = 2
    table2['nLower'] = table2.apply(lambda row: row['State_%s_Value'%row['lv']],axis=1)
    table2['nHigher'] = table2.apply(lambda row: row['State_%s_Value'%row['hv']],axis=1)
    table2['Final_value_%s'%i] = (table2['nHigher'] - table2['nLower'])*(table2['Bucket%s'%i]-table2['lv']) + table2['nLower']

---

我能够使用以下代码生成结果。我不确定大型数据帧的内存含义，所以仍然对更好的答案或改进感兴趣

编辑：在完整的数据集上运行这段代码，141行，500次间隔，10000次模拟，花费了略多于1.5小时。所以并不像我想象的那样毫无用处，但在这段时间里，也许有一种更聪明的方法可以做到这一点

for i in range(1,3):
    table2['Bucket%s'%i] = 5 * (table2['sim_%s'%i] - table2['Lower_Bound']) / (table2['Upper_Bound'] - table2['Lower_Bound']) + 1
    table2['lv'] = table2['Bucket%s'%i].map(int)
    table2['hv'] = table2['Bucket%s'%i].map(int) + 1
    table2.ix[table2['lv'] < 1 , 'lv'] = 1
    table2.ix[table2['lv'] > 5 , 'lv'] = 5
    table2.ix[table2['hv'] > 6 , 'hv'] = 6
    table2.ix[table2['hv'] < 2 , 'hv'] = 2
    table2['nLower'] = table2.apply(lambda row: row['State_%s_Value'%row['lv']],axis=1)
    table2['nHigher'] = table2.apply(lambda row: row['State_%s_Value'%row['hv']],axis=1)
    table2['Final_value_%s'%i] = (table2['nHigher'] - table2['nLower'])*(table2['Bucket%s'%i]-table2['lv']) + table2['nLower']

---

我在这里发布了一个没有循环的高级解决方案：

df=pd.DataFrame({
“产品类型”：[“A”、“B”、“C”、“D”]，
“状态值”：[10,11,12,13]，
“状态2值”：[20,21,22,23]，
“状态3值”：[30,31,32,33]，
“状态4值”：[40,41,42,43]，
“状态5值”：[50,51,52,53]，
“状态6值”：[60,61,62,63]，
‘下限’：[-1,1,5,5]，
“上界”：[1,2,625,15]，
“模拟1”：[0,0,61,7]，
“模拟2”：[1,1.5,7,9]，
})
bucket=df.ix[：，-2:].sub（df['Lower_Bound'，axis=0）.div（df['Upper_Bound'].sub（df['Lower_Bound'，axis=0），axis=0）*5+1
低=桶。应用映射（int）
高=桶。应用映射（int）+1
低=低。应用映射（λx:1，如果x<1，则为其他x）
低=低。应用映射（λx:5，如果x>5，则为其他x）
高=高。应用映射（λx:6，如果x>6，则为其他x）
高=高。应用映射（λx:2，如果x<2，则为其他x）
low_value=pd.DataFrame（df.filter（regex=“State | Type”）.value[np.arange（low.shape[0]）[：，None]，low]）
high_value=pd.DataFrame（df.filter（regex=“State | Type”）.value[np.arange（high.shape[0]）[：，None]，high]）
df1=（高_值-低_值）.mul（（桶-低）.values）+低_值
df1['Product Type']=df['Product Type']

我在这里发布了一个没有循环的高级解决方案：

df=pd.DataFrame({
“产品类型”：[“A”、“B”、“C”、“D”]，
“状态值”：[10,11,12,13]，
“状态2值”：[20,21,22,23]，
“状态3值”：[30,31,32,33]，
“状态4值”：[40,41,42,43]，
“状态5值”：[50,51,52,53]，
“状态6值”：[60,61,62,63]，
‘下限’：[-1,1,5,5]，
“上界”：[1,2,625,15]，
“模拟1”：[0,0,61,7]，
“模拟2”：[1,1.5,7,9]，
})
bucket=df.ix[：，-2:].sub（df['Lower_Bound'，axis=0）.div（df['Upper_Bound'].sub（df['Lower_Bound'，axis=0），axis=0）*5+1
低=桶。应用映射（int）
高=桶。应用映射（int）+1
低=低。应用映射（λx:1，如果x<1，则为其他x）
低=低。应用映射（λx:5，如果x>5，则为其他x）
高=高。应用映射（λx:6，如果x>6，则为其他x）
高=高。应用映射（λx:2，如果x<2，则为其他x）
低_值=局部数据帧（df.filter(
df= pd.DataFrame({
            'Product Type': ['A', 'B', 'C', 'D'],
            'State_1_Value': [10, 11, 12, 13],
        'State_2_Value': [20, 21, 22, 23],
        'State_3_Value': [30, 31, 32, 33],
        'State_4_Value': [40, 41, 42, 43],
        'State_5_Value': [50, 51, 52, 53],
        'State_6_Value': [60, 61, 62, 63],
        'Lower_Bound': [-1, 1, .5, 5],
        'Upper_Bound': [1, 2, .625, 15],
        'sim_1': [0, 0, .61, 7],
        'sim_2': [1, 1.5, .7, 9],
        })


buckets = df.ix[:,-2:].sub(df['Lower_Bound'],axis=0).div(df['Upper_Bound'].sub(df['Lower_Bound'],axis=0),axis=0) * 5 + 1
low = buckets.applymap(int)
high = buckets.applymap(int) + 1
low = low.applymap(lambda x: 1 if x < 1 else x)
low = low.applymap(lambda x: 5 if x > 5 else x)
high = high.applymap(lambda x: 6 if x > 6 else x)
high = high.applymap(lambda x: 2 if x < 2 else x)
low_value = pd.DataFrame(df.filter(regex="State|Type").values[np.arange(low.shape[0])[:,None], low])
high_value = pd.DataFrame(df.filter(regex="State|Type").values[np.arange(high.shape[0])[:,None], high])
df1 = (high_value - low_value).mul((buckets - low).values) + low_value
df1['Product Type'] = df['Product Type']