"डिजिटल ट्विन" की अवधारणा में बढ़ती रुचि के संदर्भ में व्यावसायिक प्रक्रिया खनन पर संक्षिप्त लेख। इस विषय के समय-समय पर उभरने के कारण, मैं समाधान के लिए दृष्टिकोण साझा करना उचित मानता हूं।

समस्या का बयान

स्थिति अत्यंत सरल है।

• कंपनी X (Y, Z, ...) है।
• कंपनी के पास विभिन्न आईटी प्रणालियों द्वारा स्वचालित व्यावसायिक प्रक्रियाएं हैं।
• ऐसे व्यापारिक विश्लेषक हैं जिन्होंने इन प्रक्रियाओं के लिए bpmn आरेख तैयार किए हैं। विशेष रूप से, इन प्रक्रियाओं को कैसे देखा जाना चाहिए, इसका अपना "बीपीएन विचार" है।
• व्यावसायिक उपयोगकर्ता इन प्रक्रियाओं का किसी प्रकार का प्रतिनिधित्व (KPI) करना चाहते हैं।

सच्चाई कैसे प्राप्त करें और इन मैट्रिक्स को कैसे गिनें?

यह पिछले प्रकाशनों का एक सिलसिला है।

हम कंप्यूटर के अनुकूल आवश्यकताओं में कार्य को तैयार करते हैं

मूल आसन:

• एक अस्थायी इवेंट लॉग (आईटी सिस्टम के विभिन्न लॉग, सीडीआर \ xdr, डेटाबेस में घटनाओं के सिर्फ रिकॉर्ड) शुद्धता, पूर्णता और स्थिरता की डिग्री बदलती है।
• आईटी सिस्टम एक राज्य मशीन के रूप में कार्य करता है और उपयोगकर्ताओं के कार्यों और उन में प्रोग्रामर द्वारा निर्धारित व्यावसायिक तर्क के अनुसार विभिन्न राज्यों के बीच "चलना" करता है।
• उपयोगकर्ता का सहभागिता व्यवहारिक रूप में किया जाता है।

भौतिक दुनिया सुधार:

• आईटी प्रणालियों में किए गए परिवर्तनों की संख्या ऐसी है कि व्यावसायिक विश्लेषकों के बीपीएन आरेखों का वास्तविकता से कोई लेना-देना नहीं है।
• डेटा बहुत असंरचित हो सकता है (उदाहरण के लिए, एप्लिकेशन लॉग)।
• "लेन-देन" एक तार्किक अवधारणा है। ईवेंट रिकॉर्ड्स में स्वयं इस राज्य में निहित गुण होते हैं और कोई अंत-टू-एंड लेनदेन पहचानकर्ता नहीं होता है।
• प्रति दिन रिकॉर्ड की संख्या दसियों, सैकड़ों, हजारों लाखों टुकड़े हैं ।

सेट-काउंट सॉल्यूशन

ऐसी समस्याओं को हल करने के लिए यह आवश्यक है:

• लेन-देन का पुनर्निर्माण करें
• वास्तविक व्यापार प्रक्रियाओं का पुनर्निर्माण करें
• गणना करें;
• मानव-पठनीय प्रारूप में परिणाम उत्पन्न करते हैं।

आप विक्रेता समाधान ढूंढना शुरू कर सकते हैं और लाखों का भुगतान कर सकते हैं। लेकिन हमारे हाथ में आर है। यह पूरी तरह से हमें इस समस्या को हल करने की अनुमति देता है। नीचे संक्षिप्त विचार।

सब कुछ सरल लगता है और आर के पास बूपाआर पैकेज का एक अच्छा सुसंगत सेट है। लेकिन मरहम में एक मक्खी मौजूद है और यह सब कुछ जहर देती है। यह स्वीकार्य समय में सेट केवल घटनाओं की एक छोटी संख्या (सैकड़ों हजारों - कई मिलियन) के साथ सामना कर सकता है।
बड़े संस्करणों के लिए, अन्य दृष्टिकोणों का उपयोग किया जाना चाहिए।

गति जोड़ें!

एक इनपुट डेटासेट का अनुकरण करें

विचारों को प्रदर्शित करने के लिए, कुछ प्रकार के परीक्षण डेटा सेट करना आवश्यक है। चलो गणितीय मॉडल के लिए भौतिक स्रोत के रूप में दुकानों की संघीय श्रृंखला का एक उदाहरण लेते हैं। सौभाग्य से, यह सभी के लिए समझ में आता है। यद्यपि उसी सफलता के साथ यह एटीएम, कॉल सेंटर, सार्वजनिक परिवहन, जल आपूर्ति आदि हो सकता है।

• विभिन्न आकारों (छोटे, मध्यम और बड़े) की दुकानें हैं।
• दुकानों में कैश डेस्क (पॉज़ टर्मिनल) हैं।
• स्टोर नंबर अल्फ़ान्यूमेरिक हो सकते हैं; टर्मिनल नंबर डिजिटल हो सकते हैं।
• दुकानदार दुकानों पर जाते हैं और कार्ड से भुगतान करते समय कुछ खरीदते हैं।
• कार्ड और बैंक के साथ पॉज़ टर्मिनल की बातचीत को राज्यों के एक निश्चित समूह और उनके बीच संक्रमण के नियमों द्वारा वर्णित किया गया है।
• लेनदेन सफल, असफल, स्थगित और अपूर्ण हैं (उदाहरण के लिए बैंक अनुपलब्ध है)।
• लेन-देन में टाइमआउट होता है।

व्यापार लेनदेन पैटर्न के निम्नलिखित सेट लें:

"INIT-REQUEST-RESPONSE-SUCCESS" "INIT-REQUEST-RESPONSE-ERROR" "INIT-REQUEST-RESPONSE-DEFFERED" "INIT-REQUEST" "INIT" 

दृष्टिकोण का प्रदर्शन करने के लिए, हम एक छोटा सा नमूना बनाएंगे, लेकिन यह सभी अरबों रिकॉर्डों पर ठीक काम करता है (सुपरदीप अनुकूलन के बिना ऐसी मात्रा के लिए, विशेषता समय को बहुत ही औसत प्रदर्शन के एकल सर्वर पर केवल सैकड़ों सेकंड में मापा जाता है )।

बड़े संस्करणों के लिए डायरेक्ट स्पॉइलर:

• कई स्थानों पर, tidyverse इसका मतलब है कि tidyverse जवाब नहीं मिल सकता है;
• माइक्रोस्टेप्स का अनुकूलन भी उपयोगी है और एक महत्वपूर्ण योगदान कर सकता है।

 library(tidyverse) library(datapasta) library(tictoc) library(data.table) library(stringi) library(anytime) library(rTRNG) data.table::setDTthreads(0) #      data.table data.table::getDTthreads() #     set.seed(46572) RcppParallel::setThreadOptions(numThreads = parallel::detectCores() - 1) #   --   -,     #  5   -, 2  --   bo_pattern <- tibble::tribble( #  ,    ,    ~pattern, ~prob, ~mean_duration, "INIT-REQUEST-RESPONSE-SUCCESS", 0.7, 5, "INIT-REQUEST-RESPONSE-ERROR", 0.15, 5, "INIT-REQUEST-RESPONSE-DEFFERED", 0.07, 8, "INIT-REQUEST", 0.05, 2, "INIT", 0.03, 0.5 ) #    +     checkmate::assertTRUE(sum(bo_pattern$prob) == 1) df <- bo_pattern %>% separate_rows(pattern) %>% #   mutate(coeff = sum(prob)) %>% group_by(pattern) %>% #    summarise(event_prob = sum(prob/coeff)*100) %>% ungroup() checkmate::assertTRUE(sum(df$event_prob) == 100) #   3  :  (4 ),  (12 ),  (30 ) df1 <- tribble( ~type, ~n_pos, ~n_store, "small", 4, 10, "medium", 12, 5, "large", 30, 2 ) %>% #       mutate(store = map2(row_number(), n_store, ~sample(x = .x * 1000 + 1:.y, size = .y, replace = FALSE))) %>% unnest(store) %>% #       mutate(pos = map(n_pos, ~sample(x = .x, size = .x, replace = FALSE))) %>% unnest(pos) %>% mutate(pattern = sample(bo_pattern$pattern, n(), replace = TRUE, prob = bo_pattern$prob)) tic("Generate transactions") #     ,      #         ,       df2 <- df1 %>% #         select(-matches("duration")) %>% left_join(bo_pattern, by = "pattern") %>% #   sample_frac(size = 200, replace = TRUE) %>% mutate(duration = rnorm(n(), mean = mean_duration, sd = mean_duration * .25)) %>% select(-prob, -mean_duration) %>% #   ,      >  #    30  filter(duration > 0.5 & duration < 30) %>% #    POS       mutate(session_id = row_number()) %>% #     ,       separate_rows(pattern) %>% rename(event = pattern) toc() tic("Generate time markers, data.table way") samples_tbl <- data.table::as.data.table(df2) %>% # setkey(session_id, duration, physical = FALSE) %>% #           # 1-       , ,      5  # .[, ticks := base::sort(runif(.N, 5, 5 + duration)), by = .(session_id, duration)] %>% #          match.arg   base::order!! #     #       0  1     #     # .[, tshift := runif(.N, 0, 1)] %>% #    trng     (    ) # ,           .[, trand := runif_trng(.N, 0, 1, parallelGrain = 100L) * duration] %>% #      ,      # .[, ticks := sort(tshift), by = .(session_id)] %>% #  ,     session_id,   ,     .[, t_idx := session_id + trand / max(trand)/10] %>% #         # session_id            .  .[, tshift := (sort(t_idx) - session_id) * 10 * max(trand)] %>% #   ,     POS     (60 ) .[event == "INIT", tshift := tshift + runif_trng(.N, 0, 60, parallelGrain = 100L)] %>% #     .[, `:=`(duration = NULL, trand = NULL, t_idx = NULL, n_store = NULL, n_pos = NULL, timestamp = as.numeric(anytime("2019-03-11 08:00:00 MSK")))] %>% #     ,   01.03.2019     .[, timestamp := timestamp + cumsum(tshift), by = .(store, pos)] %>% #      .[timestamp <= as.numeric(anytime("2019-04-11 23:00:00 MSK")), ] %>% #           .[, timestamp := anytime(timestamp, tz = "Europe/Moscow")] %>% as_tibble() %>% select(store, pos, event, timestamp, session_id) toc() 

प्रयोग की शुद्धता के लिए, हम केवल महत्वपूर्ण मापदंडों को छोड़ देते हैं और सब कुछ मिलाते हैं। वास्तविक जीवन में, खंडों (संभवतः अलग-अलग समय ब्लॉकों में) को बेतरतीब ढंग से फेंकना आवश्यक है, जिससे डेटा प्राप्त करने में नुकसान होता है।

 #   log_tbl <- samples_tbl %>% select(store, pos, state = event, timestamp_msk = timestamp) %>% sample_n(n()) #   log_tbl %>% mutate(timegroup = lubridate::ceiling_date(timestamp_msk, unit = "10 mins")) %>% ggplot(aes(timegroup)) + # geom_bar(width = 0.7*600) + geom_bar(colour = "white", size = 1.3) + theme_bw() 

हम एक चित्र के साथ प्रक्रिया आरेख का वर्णन करते हैं

और राज्य वितरण

थोड़ा उतार-चढ़ाव इस तथ्य के कारण है कि तालिका को शुरुआत में माना जाता है (इसे कोड में शामिल किया गया है), और bupaR::process_map ने अंत में काम किया जब कुछ यादृच्छिक रूप से उत्पन्न डेटा जो bupaR::process_map बाधाओं को फिट नहीं करते थे उन्हें फ़िल्टरिंग तत्वों द्वारा काट दिया गया था।

लेन-देन पुनर्निर्माण

पहली चीज जो आम तौर पर पेश की जाती है जब आपको समय श्रृंखला को इकट्ठा / तुलना करना / समूहबद्ध करना और चक्रों की तुलना करना होता है। 100 प्रविष्टियों के साथ डेमो में, यह बढ़ोतरी काम करेगी, लेकिन लाखों सूचियां नहीं होंगी। इस कार्य से निपटने के लिए, आपको समय की हानि बिंदुओं (आंतरिक छोरों, मध्यवर्ती स्मृति आवंटन और प्रतिलिपि) को स्थानीय करने की आवश्यकता है और उन्हें कम से कम खत्म करने का प्रयास करें।

नतीजतन, इस समस्या को दस लाइनों तक कम किया जा सकता है।

 clean_dt <- as.data.table(log_tbl) %>% #     INIT .[, start := (state == "INIT")] %>% #  session_id      ,  #             .[, event_date := lubridate::as_date(timestamp_msk)] %>% .[, date_str := format(.BY[[1]], "%y%m%d"), by = event_date] %>% #            # timestamp_msk    setorder(store, pos, timestamp_msk) %>% #     --              .[, session_id := paste(date_str, store, pos, cumsum(start), sep = "_")] %>% #        ( 30 ) # .[, time_shift := timestamp_msk - shift(timestamp_msk), by = .(store, pos)] %>% #        ,   INIT .[, time_locf := cummax(as.numeric(timestamp_msk) * as.numeric(start)), by = .(store, pos)] %>% .[, time_shift := as.numeric(timestamp_msk) - time_locf] %>% #   ,       30  .[, lost_chain := time_shift > 30] %>% # .[, time_shift := as.numeric(!start) * as.numeric(timestamp_msk - shift(timestamp_msk, fill = 0))] %>% # INIT    # .[, time_accu := cumsum(time_shift)] %>% .[, date_str := NULL] #          #    tidyverse  ,      dt <- as.data.table(clean_dt) %>% #     !!! .[lost_chain != TRUE] %>% #        1-    .[order(timestamp_msk, store, pos)] %>% .[, bp_pattern := stri_join(state, collapse = "-"), by = session_id] #     as_tibble(dt) %>% distinct(session_id, bp_pattern) %>% count(session_id, sort = TRUE) 

कुछ सेकंड में, हमारे पास व्यावसायिक प्रक्रियाओं की एक पुनर्निर्मित तस्वीर है।

और (जिसने सोचा होगा !!!) वास्तव में, यह पता चलता है कि आईटी प्रणालियों में स्वचालित व्यापार प्रक्रियाएं कुछ अलग तरीके से काम करती हैं (या बिल्कुल नहीं) क्योंकि व्यापार विश्लेषकों ने सभी को आश्वस्त किया है। "प्रक्रिया के मालिकों" के चमत्कार और तर्क अंतिम तस्वीर के अध्ययन के साथ होंगे।

सक्रिय रूप से चालें लागू करें

जब कंप्यूटिंग गति एक महत्वपूर्ण मात्रा बन जाती है, तो काम कोड लिखना पर्याप्त नहीं है। सभी स्तरों पर ध्यान देना आवश्यक है। कई एल्गोरिथम चालें भी हैं जो निष्पादन समय को काफी कम कर सकती हैं।

विशेष रूप से, इस कार्य में हम निम्नलिखित का उल्लेख कर सकते हैं:

1. मुख्य प्रसंस्करण के लिए, केवल data.table (गति, लिंक पर काम), आंतरिक क्वेरी अनुकूलन के लिए लेखांकन।
2. POSIXct में मिलीसेकंड हो सकता है (हालांकि यह सामान्य रूप से प्रदर्शित नहीं होता है, लेकिन options(digits.secs=X) का उपयोग करके इसे ठीक किया जा सकता है), हम उन्हें वहां छिपाते हैं, तुलना करना और क्रमबद्ध करना आसान होगा।
3. समूहों के अंदर भौतिक छँटाई से बचें! संपूर्ण वेक्टर की एकल भौतिक छंटाई समूहों में डेटा की छंटाई सुनिश्चित करती है।
4. समूहों के भीतर कंप्यूटिंग से बचें। हम वह सब करने की कोशिश करते हैं जो स्रोत डेटा पर संभव है (हम वेक्टराइजेशन लागू करते हैं, फ़ंक्शन कॉल के लिए चालान कम करते हैं)।
5. हम समय अंतराल से निपटने के लिए एक लेन-देन टाइमआउट का उपयोग करते हैं।
6. लोफ (लास्ट ऑब्जर्वेशन कैरी फॉरवर्ड) के तरीके धीमे हैं। किसी टाइमलाइन पर प्रॉपर्टी ट्रांसफर करने के लिए, cummax , cummax इस्तेमाल करें।
7. समय लेने वाली कार्रवाई, जैसे कि POSIX -> स्ट्रिंग रूपांतरण, नियमित खोज, आदि। हम इसे तत्व द्वारा नहीं करते हैं, लेकिन दृढ़ संकल्प पर। आंतरिक अनुक्रमित और परिवर्तित क्षेत्र के समूहीकरण पर ओवरहेड अतुलनीय रूप से छोटे होते हैं।
8. हम सक्रिय रूप से मल्टीथ्रेडिंग (इंट्रा-पैकेट सहित) का उपयोग करते हैं।
9. Microoptimization की उपेक्षा न करें। उदाहरण के लिए, stri_c से कई गुना तेज है।

 #  1 log <- getLog(fileName) bench::mark( paste0 = paste0(log$value, collapse = "\n"), stringi = stri_c(log$value, collapse = "\n") ) # # A tibble: 2 x 13 # expression min median `itr/sec` mem_alloc `gc/sec` n_itr n_gc total_time # <bch:expr> <bch:> <bch:> <dbl> <bch:byt> <dbl> <int> <dbl> <bch:tm> # 1 paste0 58ms 59.1ms 16.9 496KB 0 9 0 533ms # 2 stringi 16.9ms 17.5ms 57.1 0B 0 29 0 508ms 

पिछला पोस्ट - स्विस जोंस प्रसंस्करण चाकू ।