मेरा प्राथमिक उद्देश्य एक ऐसी विशेषता है जो उच्च मूल्य की हाल की जानकारी पर विचार करती है।

तो, आइडिया एक नए आदिम परिवर्तन "वेटटाइम यूटिल" के माध्यम से एक वजन कारक की गणना करना है जिसे बाद में भारित मान प्राप्त करने के लिए परिवर्तन आदिम "मल्टीप्लीन्यूमेरिक" द्वारा उपयोग किया जा सकता है।

मैंने शुरुआती बिंदु के रूप में विल कोहरसेन के वॉकथ्रू वॉकथ्रू का इस्तेमाल किया डेटा और इकाई सेटअप के लिए।

जिससे मैं निम्नलिखित समस्या में भाग गया:

  1. फीचरटूल ने उस संयोजन को नहीं चुना है जिसे मैं हासिल करना चाहता हूं (नीचे देखें)
  2. ऐसा लगता है कि टाइप मिस मैच के कारण फीचरटूल ने संयोजन का चयन नहीं किया ?!
  3. मूल्य के प्रकार को बदलकर मैं भार कारक से गुणा करना चाहता था मैं सही संयोजन प्राप्त करने में कामयाब रहा लेकिन सही लक्ष्य के लिए नहीं
  4. लक्ष्य समान क्लाइंट के लिए, फीचरटूल ने उस संयोजन को नहीं चुना है जिसे मैं प्राप्त करने का इरादा रखता हूं। केवल जब मैं लक्ष्य समान ऋण का उपयोग करता हूं, जहां दिनांक और मूल्य के कॉलम होते हैं, तो फीचरटूल ने सही संयोजन का उपयोग किया

यहाँ "WeightTimeUntil" आदिम के लिए कोड है

def weight_time_until(array, time):
    diff = pd.DatetimeIndex(array) - time
    s = np.floor(diff.days/365/0.5)
    aWidth = 9
    a = math.log(0.1) / ( -(aWidth -1) )

    w = np.exp(-a*s) 

    return w


    WeightTimeUntil = make_trans_primitive(function=weight_time_until,
                                 input_types=[Datetime],
                                 return_type=Numeric,
                                 uses_calc_time=True,
                                 description="Calculates weight time until the cutoff time",
                                 name="weight_time_until")

यहाँ DFS निष्पादन कोड है:

features, feature_names = ft.dfs(entityset = es, target_entity = 'clients', 
                                 agg_primitives = ['sum'],
                                 trans_primitives = [WeightTimeUntil, MultiplyNumeric]) 

और यहाँ सुविधाओं की सूची:

 <Feature: income>,
 <Feature: credit_score>,
 <Feature: join_month>,
 <Feature: log_income>,
 <Feature: SUM(loans.loan_amount)>,
 <Feature: SUM(loans.rate)>,
 <Feature: SUM(payments.payment_amount)>,
 <Feature: WEIGHT_TIME_UNTIL(joined)>,
 <Feature: join_month * log_income>,
 <Feature: income * log_income>,
 <Feature: income * join_month>,
 <Feature: credit_score * join_month>,
 <Feature: credit_score * log_income>,
 <Feature: credit_score * income>,
 <Feature: SUM(loans.WEIGHT_TIME_UNTIL(loan_start))>,
 <Feature: SUM(loans.WEIGHT_TIME_UNTIL(loan_end))>,
 <Feature: SUM(loans.loan_amount * rate)>,
 <Feature: income * SUM(loans.loan_amount)>,
 <Feature: credit_score * SUM(loans.loan_amount)>,
 <Feature: log_income * SUM(payments.payment_amount)>,
 <Feature: log_income * WEIGHT_TIME_UNTIL(joined)>,
 <Feature: income * SUM(payments.payment_amount)>,
 <Feature: join_month * SUM(loans.rate)>,
 <Feature: income * SUM(loans.rate)>,
 <Feature: join_month * SUM(loans.loan_amount)>,
 <Feature: SUM(loans.rate) * SUM(payments.payment_amount)>,
 <Feature: credit_score * WEIGHT_TIME_UNTIL(joined)>,
 <Feature: SUM(loans.rate) * WEIGHT_TIME_UNTIL(joined)>,
 <Feature: income * WEIGHT_TIME_UNTIL(joined)>,
 <Feature: log_income * SUM(loans.loan_amount)>,
 <Feature: SUM(loans.loan_amount) * WEIGHT_TIME_UNTIL(joined)>,
 <Feature: SUM(loans.loan_amount) * SUM(payments.payment_amount)>,
 <Feature: credit_score * SUM(loans.rate)>,
 <Feature: log_income * SUM(loans.rate)>,
 <Feature: credit_score * SUM(payments.payment_amount)>,
 <Feature: SUM(payments.payment_amount) * WEIGHT_TIME_UNTIL(joined)>,
 <Feature: join_month * WEIGHT_TIME_UNTIL(joined)>,
 <Feature: SUM(loans.loan_amount) * SUM(loans.rate)>,
 <Feature: join_month * SUM(payments.payment_amount)>

मुझे कुछ इस तरह की उम्मीद थी:

SUM(loans.loan_amount * loans.WEIGHT_TIME_UNTIL(loan_start))>
1
Filip Floegel 28 जून 2019, 15:49

1 उत्तर

सबसे बढ़िया उत्तर

यहाँ समस्या यह है कि SUM(loans.loan_amount * loans.WEIGHT_TIME_UNTIL(loan_start))> एक गहराई 3 विशेषता है क्योंकि आप Sum, MultiplyNumeric, और WeightTimeUntil को ढेर कर रहे हैं। आप दस्तावेज़ में गहराई के बारे में यहां पढ़ सकते हैं।

आप अपने कॉल में अनुमत गहराई को इस तरह dfs तक बढ़ाकर इसे ठीक कर सकते हैं

features, feature_names = ft.dfs(entityset = es, target_entity = 'clients', 
                                 agg_primitives = ['sum'],
                                 max_depth=3,
                                 trans_primitives = [WeightTimeUntil, MultiplyNumeric]) 

इसे करने का वैकल्पिक तरीका है, अपनी सुविधा को एक बीज विशेषता के रूप में प्रदान करना, जिसे अधिकतम गहराई में नहीं गिना जाता है। आप इसे इस तरह कर सकते हैं

seed_features=[ft.Feature(es["loans"]["loan_start"], primitive=WeightTimeUntil)]

features, feature_names = ft.dfs(entityset = es, target_entity = 'clients', 
                                 agg_primitives = ['sum'],
                                 seed_features=seed_features,
                                 trans_primitives = [MultiplyNumeric])

दूसरा तरीका मेरा बेहतर होगा क्योंकि यह आपकी इच्छित सुविधा बनाएगा, लेकिन कुल मिलाकर कम सुविधाएँ।

1
Max Kanter 28 जून 2019, 16:56