"विश्लेषक रिक्तियों के बाजार पर शोध करना" एक बड़ी या छोटी कंपनी के एक बहुत ही वास्तविक अग्रणी विश्लेषक का वास्तविक कार्य था। पार्सर मैन्युअल रूप से एचएच के साथ दर्जनों नौकरी विवरणों को पार्सल करता है, उन्हें अनुरोध किए गए कौशल के अनुसार बिखरता है और संबंधित स्प्रेडशीट कॉलम में काउंटर बढ़ाता है।

मैंने इस कार्य में स्वचालन के लिए एक अच्छा क्षेत्र देखा और कम रक्त के साथ आसानी से और सरलता से सामना करने की कोशिश करने का फैसला किया।

मुझे इस अध्ययन में उठाए गए निम्नलिखित मुद्दों में दिलचस्पी थी:

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

Spoiler: आसान और सरल काम नहीं किया।

डेटा की तैयारी

यदि हम रिक्तियों के बारे में बहुत अधिक डेटा एकत्र करना चाहते हैं, तो यह तर्कसंगत है कि hh सीमित नहीं है। हालाँकि, के लिए शुद्धता का प्रयोग करें सादगी, हम इस संसाधन से शुरू करते हैं।

संग्रह

डेटा एकत्र करने के लिए, हम hh एपीआई के माध्यम से नौकरी खोज का उपयोग करेंगे।

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

ऐसा करने के लिए, https://api.hh.ru/vacancies?text="systems+analyst" फॉर्म का अनुरोध बनाएं और प्राप्त JSON को पार्स करें।

नमूने में सबसे अधिक प्रासंगिक रिक्तियों को प्राप्त करने के लिए, हम केवल रिक्ति हेडर में search_field=name पैरामीटर को क्वेरी में जोड़कर खोज करेंगे।

यहां आप देख सकते हैं कि इस अनुरोध के लिए कौन से रिक्त क्षेत्र वापस आ गए हैं। मैंने निम्नलिखित को चुना:

• नौकरी का शीर्षक
• शहर
• प्रकाशन की तारीख
• वेतन - ऊपरी और निचले सीमा
• वह मुद्रा जिसमें वेतन का संकेत दिया जाता है
• सकल - टी / एफ
• कंपनी
• कर्तव्यों
• उम्मीदवार के लिए आवश्यकताएं

इसके अलावा, मैं उन कौशलों का और विश्लेषण करना चाहता हूं जो कुंजी कौशल अनुभाग में इंगित किए गए हैं, लेकिन यह अनुभाग केवल पूर्ण नौकरी विवरण में उपलब्ध है। इसलिए, मैं रिक्त पदों के लिंक भी रखूंगा, ताकि बाद में उनमें से प्रत्येक के लिए कौशल की एक सूची प्राप्त कर सके।

 #     :) library(jsonlite) library(curl) library(dplyr) library(ggplot2) library(RColorBrewer) library(plotly) hh.getjobs <- function(query, paid = FALSE) { # Makes a call to hh API and gets the list of vacancies based on the given search queries df <- data.frame( query = character() #    , URL = character() #    , id = numeric() # id  , Name = character() #   , City = character() , Published = character() , Currency = character() , From = numeric() # .    , To = numeric() # .  , Gross = character() , Company = character() , Responsibility = character() , Requerement = character() , stringsAsFactors = FALSE ) for (q in query) { for (pageNum in 0:99) { try( { data <- fromJSON(paste0("https://api.hh.ru/vacancies?search_field=name&text=\"" , q , "\"&search_field=name" , "&only_with_salary=", paid ,"&page=" , pageNum)) df <- rbind(df, data.frame( q, data$items$url, as.numeric(data$items$id), data$items$name, data$items$area$name, data$items$published_at, data$items$salary$currency, data$items$salary$from, data$items$salary$to, data$items$salary$gross, data$items$employer$name, data$items$snippet$responsibility, data$items$snippet$requirement, stringsAsFactors = FALSE)) }) print(paste0("Downloading page:", pageNum + 1, "; query = \"", q, "\"")) } } names <- c("query", "URL", "id", "Name", "City", "Published", "Currency", "From", "To", "Gross", "Company", "Responsibility", "Requirement") colnames(df) <- names return(df) } 

hh.getjobs() फ़ंक्शन में, इनपुट से हमें और परिशोधन के लिए रुचि के खोज प्रश्नों का एक वेक्टर प्राप्त होता है, हम केवल एक निर्दिष्ट वेतन या एक पंक्ति में सभी के साथ रिक्तियों में रुचि रखते हैं (डिफ़ॉल्ट रूप से हम दूसरा विकल्प लेते हैं)। एक खाली dafa फ़्रेम बनाया जाता है, और फिर fromJSON() पैकेज के fromJSON() फ़ंक्शन का jsonlite , जो इनपुट URL लेता है और एक संरचित सूची देता है। अगला, इस सूची में नोड्स से, हमें वह डेटा मिलता है जिसमें हम रुचि रखते हैं और संबंधित डेटा फ़्रेम फ़ील्ड में भरते हैं।

डिफ़ॉल्ट रूप से, डेटा पृष्ठ द्वारा पृष्ठ दिया जाता है, प्रत्येक पृष्ठ पर 20 तत्वों के साथ। अधिकतम 2,000 नौकरी रिक्तियों के लिए। हमारे द्वारा प्राप्त सभी डेटा df में रिकॉर्ड किया जाता है।

जीवन हैक 1: यह इस तथ्य पर बिल्कुल नहीं है कि हमारे अनुरोध पर 2,000 रिक्तियां होंगी, और कुछ बिंदुओं पर शुरू होने पर हमें खाली पृष्ठ प्राप्त होंगे। इस मामले में, आर कसम खाता है और लूप से बाहर कूदता है। इसलिए, हम ध्यान से try() में आंतरिक लूप की सामग्री को लपेटते हैं।

जीवन हैक 2: यह आंतरिक लूप में कंसोल में वर्तमान डेटा संग्रह स्थिति के आउटपुट को जोड़ने के लिए भी समझ में आता है, क्योंकि यह एक तेज़ व्यवसाय नहीं है। मैंने ऐसा किया:

 print(paste0("Downloading page:", pageNum + 1, "; query = \"", query, "\"")) 

डेटा भरने के बाद, कॉलम का नाम बदल दिया जाता है ताकि उनके साथ काम करना सुविधाजनक हो, और परिणामस्वरूप डेटा फ़्रेम वापस आ जाए।

मैं इसे और अन्य सहायक कार्यों को एक अलग फ़ंक्शन में संग्रहीत करूंगा। मुख्य स्क्रिप्ट को अव्यवस्थित न करने के लिए फाइल करें, जो अब तक ऐसा दिखता है:

 source("functions.R") # Step 1 - get data # 1.1 get vacancies (short info) jobdf <- hh.getjobs(query = c("business+analyst" , "systems+analyst" , "product+owner"), paid = FALSE) 

अब हमें पूर्ण नौकरी विवरण से experience और key_skills ।

hh.getxp फ़ंक्शन में डेटा फ़्रेम पास करते हैं, रिक्तियों के लिए सहेजे गए लिंक के माध्यम से जाते हैं, और पूर्ण विवरण से हमें आवश्यक कार्य अनुभव का मूल्य मिलता है। परिणामी मान एक नए कॉलम में संग्रहीत किया जाता है।

 hh.getxp <- function(df) { df$experience <- NA for (myURL in df$URL) { try( { data <- fromJSON(myURL) df[df$URL == myURL, "experience"] <- data$experience$name } ) print(paste0("Filling in ", which(df$URL == myURL, arr.ind = TRUE), "from ", nrow(df))) } return(df) } 

नए सहायक फ़ंक्शन का विवरण फ़ंक्शन के लिए भेजा जाता functions.R । और मुख्य स्क्रिप्ट अब इसे एक्सेस करती है:

 # s.1.2 get experience (from full info) jobdf <- hh.getxp(jobdf) # 1.3 get skills (from full info) all.skills <- hh.getskills(jobdf$URL) 

ऊपर के टुकड़े में, हम एक नया डेटा फ्रेम भी all.skills फॉर्म की "जॉब आईडी - स्किल":

 hh.getskills <- function(allurls) { analyst.skills <- data.frame( id = character(), # id  skill = character() #   ) for (myURL in allurls) { data <- fromJSON(myURL) if (length(data$key_skills) > 0) analyst.skills <- rbind(analyst.skills, cbind(data$id, data$key_skills)) print(paste0("Filling in " , which(allurls == myURL, arr.ind = TRUE) , " out of " , length(allurls))) } names(analyst.skills) <- c("id", "skill") analyst.skills$skill <- tolower(analyst.skills$skill) return(analyst.skills) } 

preprocessing

आइए देखें कि हम कितना डेटा एकत्र करने में कामयाब रहे:

 > length(unique(jobdf$id)) [1] 1478 > length(jobdf$id) [1] 1498 

लगभग डेढ़ हजार नौकरियां! यह अच्छा लग रहा है। और जाहिर है, कई रिक्तियों को अलग-अलग अनुरोधों के लिए - दो बार खोज परिणामों में मिला। इसलिए, पहला कदम केवल अद्वितीय प्रविष्टियों को छोड़ना है: jobdf <- jobdf[unique(jobdf$id),] ।

श्रम बाजार विश्लेषकों के वेतन की तुलना करने के लिए, मुझे आवश्यकता है

1) सुनिश्चित करें कि वेतन पर सभी उपलब्ध डेटा एक ही मुद्रा में प्रस्तुत किए जाते हैं,

2) एक अलग डेटा फ्रेम में उन रिक्तियों का चयन करें जिनके लिए वेतन का संकेत दिया गया है।

हम प्रत्येक उपकथा को अधिक विस्तार से मानते हैं। पहले, आप यह पता लगा सकते हैं कि सिद्धांत रूप में, मुद्राएं table(jobdf$Currency) में हमारे डेटा में पाई जाती हैं table(jobdf$Currency) । मेरे मामले में, रूबल के अलावा, डॉलर, यूरो, hryvnias, कजाख का कार्यकाल और यहां तक ​​कि उज़्बेक रकम दिखाई दिए।

वेतन मानों को रूबल में बदलने के लिए, आपको वर्तमान विनिमय दर का पता लगाना होगा। हम सेंट्रल बैंक से पता लगाएंगे:

 quotations.update <- function(currencies) { # Parses the most up-to-date qutations data provided by the Central Bank of Russia # and returns a table with currency rate against RUR doc <- XML::xmlParse("http://www.cbr.ru/scripts/XML_daily.asp") quotationsdf <- XML::xmlToDataFrame(doc, stringsAsFactors = FALSE) quotationsdf <- select(quotationsdf, -Name) quotationsdf$NumCode <- as.numeric(quotationsdf$NumCode) quotationsdf$Nominal <- as.numeric(quotationsdf$Nominal) quotationsdf$Value <- as.numeric(sub(",", ".", quotationsdf$Value)) quotationsdf$Value <- quotationsdf$Value / quotationsdf$Nominal quotationsdf <- quotationsdf %>% select(CharCode, Value) return(quotationsdf) } 

यह सुनिश्चित करने के लिए कि पाठ्यक्रम आर में सही तरीके से संसाधित किए गए हैं, आपको यह सुनिश्चित करने की आवश्यकता है कि दशमलव भाग को एक डॉट द्वारा अलग किया गया है। इसके अलावा, आपको नाममात्र स्तंभ पर ध्यान देना चाहिए: कहीं यह 1, कहीं 10 या 100 है। इसका मतलब है कि एक पाउंड स्टर्लिंग की लागत ~ 85 रूबल है, और कहते हैं, एक सौ अर्मेनियाई ड्रम के लिए आप ~ 13 रूबल खरीद सकते हैं। आगे की प्रक्रिया की सुविधा के लिए, मैंने रूबल के सापेक्ष 1 नाममात्र के मूल्यों को कम कर दिया।

अब आप अनुवाद कर सकते हैं। हमारी लिपि यह convert.currency() फ़ंक्शन का उपयोग करती है। इसमें मौजूदा विनिमय दर quotations तालिका से ली गई है, जहां हमने सेंट्रल बैंक द्वारा प्रदान किए गए एक्सएमएल से डेटा बचाया। इसके अलावा, इनपुट फ़ंक्शन रूपांतरण के लिए लक्ष्य मुद्रा (डिफ़ॉल्ट रूप से आरयूआर) और रिक्तियों के साथ एक तालिका स्वीकार करता है, वेतन कांटे के मूल्य जिसमें एकल मुद्रा का नेतृत्व करना आवश्यक है। फ़ंक्शन अद्यतन वेतन अंकों (पहले से ही मुद्रा कॉलम के बिना, अनावश्यक के रूप में) के साथ एक तालिका देता है।

मुझे बेलारूसी रूबल के साथ टिंकर करना पड़ा: कई दृष्टिकोणों में बहुत ही अजीब डेटा प्राप्त करने के बाद, मैंने एक छोटा शोध किया और पता चला कि 2016 से बेलारूस में एक नई मुद्रा का उपयोग किया गया है, जो न केवल विनिमय दर में भिन्न होता है, बल्कि संक्षिप्त रूप में (अब BYR नहीं, बल्कि BYN) । Hh निर्देशिकाओं में , संक्षिप्त नाम BYR का उपयोग अभी भी किया जाता है, जिसके बारे में सेंट्रल बैंक के XML को कुछ भी पता नहीं है। इसलिए, फ़ंक्शन में convert.currency() I सबसे सुरुचिपूर्ण तरीके से नहीं सबसे पहले, मैं संक्षेप को वर्तमान के साथ बदल देता हूं, और उसके बाद ही सीधे रूपांतरण पर जाता हूं।

यह इस तरह दिखता है:

 convert.currency <- function(targetCurrency = "RUR", df, quotationsdf) { cond <- (!is.na(df$Currency) & df$Currency == "BYR") df[cond, "Currency"] <- "BYN" currencies <- unique(na.omit(df$Currency[df$Currency != targetCurrency])) #     ( ) if (!is.null(df$From)) { for (currency in currencies) { condition <- (!is.na(df$From) & df$Currency == currency) try( df$From[condition] <- df$From[condition] * quotationsdf$Value[quotationsdf$CharCode == currency] ) } } #     ( ) if (!is.null(df$To)) { for (currency in currencies) { condition <- !is.na(df$To) & df$Currency == currency try( df$To[condition] <- df$To[condition] * quotationsdf$Value[quotationsdf$CharCode == currency] ) } } return(df %>% select(-Currency)) } 

आप यह भी ध्यान में रख सकते हैं कि वेतन के कुछ डेटा को सकल मूल्यों में प्रस्तुत किया गया है, अर्थात, कर्मचारी को हाथ पर थोड़ा कम प्राप्त होगा। रूसी संघ के निवासियों के लिए शुद्ध वेतन की गणना करने के लिए, इन आंकड़ों से 13% कटौती की जानी चाहिए (गैर-निवासियों के लिए 30% कटौती की गई है)।

 gross.to.net <- function(df, resident = TRUE) { if (resident == TRUE) coef <- 0.87 else coef <- 0.7 if (!is.null(df$Gross)) { if (!is.null(df$From)) #     ( ) { index <- na.omit(as.numeric(rownames(df[!is.na(df$From) & df$Gross == TRUE,]))) df$From[index] <- df$From[index] * coef } if (!is.null(df$To)) #     ( ) { index <- na.omit(as.numeric(rownames(df[!is.na(df$To) & df$Gross == TRUE,]))) df$To[index] <- df$To[index] * coef } df <- df %>% select(-Gross) } return(df) } 

बेशक, मैं ऐसा नहीं करूंगा, क्योंकि इस मामले में यह विभिन्न देशों में करों पर विचार करने के लायक है, और न केवल रूस में, या प्रारंभिक खोज क्वेरी में देश द्वारा फ़िल्टर जोड़ें।

विश्लेषण से पहले अंतिम चरण तीन श्रेणियों: जून, मध्य और वरिष्ठ में मिली रिक्तियों को विभाजित करना है, और प्राप्त पदों को एक नए कॉलम में लिखना है। वरिष्ठ पदों में वे नाम शामिल होंगे जिनमें "वरिष्ठ" और इसके पर्यायवाची शब्द मौजूद हैं। इसी तरह, हम कीवर्ड "जूनियर" और समानार्थक शब्द के लिए शुरुआती स्थिति पाएंगे, और जिन पहेलियों के बीच हम शामिल हैं उनमें शामिल हैं:

 get.positions <- function(df) { df$lvl <- NA df[grep(pattern = "lead|senior|||", x = df$Name, ignore.case = TRUE), "lvl"] <- "senior" df[grep(pattern = "junior|||", x = df$Name, ignore.case = TRUE), "lvl"] <- "junior" df[is.na(df$lvl), "lvl"] <- "middle" return(df) } 

मुख्य स्क्रिप्ट में डेटा तैयारी ब्लॉक जोड़ें।

 # Step 2 - prepare data # 2.1. Convert all currencies to target currency # 2.1.1 get up-to-date currency rates quotations <- quotations.update() # 2.1.2 convert to RUR jobdf <- convert.currency(df = jobdf, quotationsdf = quotations) # 2.2 convert Gross to Net # jobdf <- gross.to.net(df = jobdf) # 2.3 define segments jobdf <- get.positions(jobdf) 

के विश्लेषण

जैसा कि ऊपर उल्लेख किया गया है, मैं प्राप्त आंकड़ों के निम्नलिखित पहलुओं का विश्लेषण करने जा रहा हूं:

• औसत वेतन बीए / एसए,
• इस स्थिति में सबसे अधिक मांग वाले कौशल और व्यक्तिगत गुण,
• कुछ कौशल और वेतन के स्तर के बीच निर्भरता (यदि कोई हो)।

औसत बीए / एसए आय

जैसा कि यह निकला, कंपनियां ऊपरी या निम्न वेतन सीमा को इंगित करने के लिए अनिच्छुक हैं।

हमारे डेटा फ़्रेम jobdf ये मान क्रमशः To और From कॉलम में हैं। मैं औसत खोजना चाहता हूं और उन्हें एक नए वेतन कॉलम में लिखना चाहता हूं।

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

 select.paid <- function(df, suggest = TRUE) { # Returns a data frame with average salaries between To and From # optionally, can suggest To or From value in case only one is specified if (suggest == TRUE) { df <- df %>% filter(!is.na(From) | !is.na(To)) magic.coefficient <- # shows the average difference between max and min salary round(mean(df$To/df$From, na.rm = TRUE), 1) df[is.na(df$To),]$To <- df[is.na(df$To),]$From * magic.coefficient df[is.na(df$From),]$From <- df[is.na(df$From),]$To / magic.coefficient } else { df <- na.omit(df) } df$salary <- rowMeans(x = df %>% select(From, To)) df$salary <- ceiling(df$salary / 10000) * 10000 return(df %>% select(-From, -To)) } 

यह एक "सॉफ्ट" डेटा फ़िल्टरिंग है, जो suggest = TRUE पैरामीटर के साथ select.paid() फ़ंक्शन में सेट किया गया है। वैकल्पिक रूप से, हम फ़ंक्शन को कॉल करते समय suggest = FALSE निर्दिष्ट कर सकते हैं और बस उन सभी लाइनों को काट सकते हैं जहां वेतन डेटा कम से कम आंशिक रूप से अनुपस्थित है। हालांकि, नरम फ़िल्टरिंग और एक जादू गुणांक का उपयोग करके, मैं नमूने में मूल डेटा के लगभग एक चौथाई को बचाने में कामयाब रहा।

हम दृश्य भाग में जाते हैं:

इस ग्राफ पर आप दो राजधानियों और क्षेत्रों में बीए / एसए वेतन के वितरण घनत्व का नेत्रहीन मूल्यांकन कर सकते हैं। लेकिन क्या होगा अगर हम अनुरोध को निर्दिष्ट करते हैं और तुलना करते हैं कि राजधानियों में मध्यम और वरिष्ठ पुरुषों को कितना मिलता है?

प्राप्त ग्राफ से यह स्पष्ट है कि मास्को और सेंट पीटर्सबर्ग में मध्यम और वरिष्ठ पुरुषों के बीच वेतन स्थितियों में अंतर बहुत अलग नहीं है। इसलिए, सेंट पीटर्सबर्ग में, मिडल्स को एक नियम के रूप में, 70 tr के क्षेत्र में, जबकि मास्को में घनत्व शिखर ~ 120 tr पर पड़ता है, और मास्को और सेंट पीटर्सबर्ग में वरिष्ठ स्तर के विशेषज्ञों की आय में अंतर। 60 हजार की औसत से भिन्न होता है।

हम उदाहरण के लिए, स्थिति के अनुसार विश्लेषकों के मास्को वेतन पर भी देख सकते हैं:

यह निष्कर्ष निकाला जा सकता है कि मॉस्को में आज प्रवेश स्तर के विश्लेषकों की बहुत अधिक मांग है, और बी) एक ही समय में, ऐसे विशेषज्ञों के लिए ऊपरी वेतन सीमा मिडिल और सीनियर्स की तुलना में बहुत अधिक सीमित है।

एक और अवलोकन: मध्यम और उच्च स्तर के मॉस्को विशेषज्ञों के औसत एसएन में एक बड़ा चौराहा क्षेत्र है। यह संकेत दे सकता है कि इन दो चरणों के बीच बाजार में धुंधली सीमा है।

कटौती के तहत चार्ट के लिए पूर्ण कोड।

 # Step 3 - analyze salaries # 3.1 get paid jobs (with salaries specified) jobs.paid <- select.paid(jobdf) # 3.2 plot salaries density by region ggplotly(ggplot(jobs.paid, aes(salary, fill = region, colour = region)) + geom_density(alpha=.3) + scale_fill_discrete(guide = guide_legend(reverse=FALSE)) + scale_x_continuous(labels = function(x) format(x, scientific = FALSE), name = ", .", breaks = round(seq(min(jobs.paid$salary), max(jobs.paid$salary), by = 30000),1)) + scale_y_continuous(name = " ") + theme(axis.text.x = element_text(size=9), axis.title = element_text(size=10))) # 3.3 compare salaries for middle / senior in capitals ggplot(jobs.paid %>% filter(region %in% c("", "-"), lvl %in% c("senior", "middle")), aes(salary, fill = region, colour = region)) + facet_grid(lvl ~ .) + geom_density(alpha = .3) + scale_x_continuous(labels = function(x) format(x, scientific = FALSE), name = ", .", breaks = round(seq(min(jobs.paid$salary), max(jobs.paid$salary), by = 30000),1)) + scale_y_continuous(name = " ") + scale_fill_discrete(name = "") + scale_color_discrete(name = "") + guides(fill=guide_legend( keywidth=0.1, keyheight=0.1, default.unit="inch") ) + theme(legend.spacing = unit(1,"inch"), axis.title = element_text(size=10)) # 3.4 plot salaries in Moscow by position ggplotly(ggplot(jobs.paid %>% filter(region == ""), aes(salary, fill = lvl, color = lvl)) + geom_density(alpha=.4) + scale_fill_brewer(palette = "Set2") + scale_color_brewer(palette = "Set2") + theme_light() + scale_y_continuous(name = " ") + scale_x_continuous(labels = function(x) format(x, scientific = FALSE), name = ", .", breaks = round(seq(min(jobs.paid$salary), max(jobs.paid$salary), by = 30000),1)) + theme(axis.text.x = element_text(size=9), axis.title = element_text(size=10))) 

प्रमुख कौशल विश्लेषण

हम बीए / एसए के लिए सबसे अधिक मांग वाले कौशल की पहचान करने के लिए - अध्ययन के प्रमुख लक्ष्य पर आगे बढ़ते हैं। ऐसा करने के लिए, हम उस डेटा का विश्लेषण करेंगे जो रिक्ति के विशेष क्षेत्र में स्पष्ट रूप से इंगित किया गया है - प्रमुख कौशल।

सबसे लोकप्रिय कौशल

इससे पहले, हम एक अलग डेटा फ्रेम all.skills , जहां हम जोड़े "नौकरी आईडी - कौशल" दर्ज की गई। table() फ़ंक्शन के साथ सबसे सामान्य कौशल खोजना आसान है:

 tmp <- as.data.frame(table(all.skills$skill), col.names = c("Skill", "Freq")) htmlTable::htmlTable(x = head(tmp[order(tmp$Freq, na.last = TRUE, decreasing = TRUE),]), rnames = FALSE, header = c("Skill", "Freq"), align = 'l', css.cell = "padding-left: .5em; padding-right: 2em;") 

आपको निम्न जैसा कुछ मिलता है:

यहां फ्रीक "की_स्किल्स" क्षेत्र में रिक्तियों की संख्या है, जिसमें कौशल कॉलम से संबंधित कौशल को इंगित किया गया है।

"लेकिन यह सब नहीं है!" (सी) यह काफी स्पष्ट है कि समान कौशल आसानी से पर्याय शब्दों में विभिन्न रिक्तियों में पाया जा सकता है।

मैंने कौशल के नाम के लिए समानार्थक शब्द का एक छोटा सा शब्दकोश संकलित किया और उन्हें श्रेणियों में विभाजित किया।

शब्दकोश श्रेणी कॉलम के साथ एक सीएसवी फ़ाइल है - निम्न में से एक: गतिविधियाँ, उपकरण, ज्ञान, मानक और व्यक्तिगत; कौशल - कौशल का मुख्य नाम, जिसे मैं सभी समानार्थक शब्द के बजाय उपयोग करूंगा; syn1, syn2, ... syn13 - वास्तव में प्रत्येक कौशल के लिए संभव बदलाव। कुछ पंक्तियों में समानार्थक शब्द के खाली कॉलम हो सकते हैं।

 category;skill;syn1;syn2;syn3;syn4;syn5;syn6;syn7;syn8;syn9;syn10;syn11;syn12;syn13 tools;axure;;;;;;;;;;;;; tools;lucidchart;;;;;;;;;;;;; standards;archimate;;;;;;;;;;;;; standards;uml;activity diagram;use case diagram;ucd;class diagram;;;;;;;;; personal;teamwork;team player;  ;;;;;;;;;;; activities;wireframing;mockup;mock-up;;-;wireframe;;ui;ux/;/ux;;;; 

पहले, शब्दकोश आयात करें, और फिर मौजूदा समतुल्यता के आधार पर कौशल को फिर से वितरित करें:

 # Analyze skills # 4.1 import dictionary dict <- read.csv(file = "competencies.csv", header = TRUE, stringsAsFactors = FALSE, sep = ";", na.strings = "", encoding = "UTF-8") # 4.2 match skills with dictionary all.skills <- categorize.skills(all.skills, dict) 

कट के तहत, आप categorize.skills() । categorize.skills() फ़ंक्शन के भराई को देख सकते हैं।

 categorize.skills <- function(analyst_skills, dictionary) { analyst_skills$skill.group <- NA analyst_skills$category <- NA for (myskill in dictionary$skill) { category <- dictionary[dictionary$skill == myskill, "category"] mypattern <- paste0(na.omit(t(dictionary %>% filter(skill == myskill) %>% select(starts_with("syn")))), collapse = "|") if (nchar(mypattern) > 1) mypattern <- paste0(c(myskill, mypattern), collapse = "|") else mypattern <- myskill try( { analyst_skills[grep(x = analyst_skills$skill, pattern = mypattern),"skill.group"] <- myskill analyst_skills[grep(x = analyst_skills$skill, pattern = mypattern),"category"] <- category } ) } return(analyst_skills) } 

मैं मूल कौशल डेटा फ़्रेम में श्रेणी और कौशल कॉलम जोड़ता हूं। समूह - क्रमशः श्रेणी और कौशल के सामान्यीकृत नाम के लिए। फिर मैं आयातित शब्दकोश से गुजरता हूं और समानार्थक शब्द की प्रत्येक पंक्ति से grep() फ़ंक्शन के लिए एक पैटर्न grep() हूं। पंक्ति में प्रत्येक गैर-रिक्त स्तंभ मान जोड़कर, मैं उन्हें "या" स्थिति प्राप्त करने के लिए डैश के साथ अलग करता हूं। इसलिए, स्रोत तालिका से सभी कौशलों के लिए, जिसमें uml|activity diagram|use case diagram|ucd|class diagram शामिल है uml|activity diagram|use case diagram|ucd|class diagram , मैं कौशल में "uml" मान लिखूंगा। समूह कॉलम। और इसलिए यह सभी के साथ होगा! .. मूल डेटा फ्रेम से कौशल।

सबसे लोकप्रिय कौशल के शीर्ष पर फिर से अनुरोध करके, आप देख सकते हैं कि बलों का संरेखण कुछ हद तक बदल गया है:

तीन नेताओं के पास अब परियोजना प्रबंधन, व्यवसाय विश्लेषण और प्रलेखन है, और यूएमएल का ज्ञान शीर्ष 7 से स्थानांतरित हो गया है।

श्रेणियों के माध्यम से जाना और यह पता लगाना काफी दिलचस्प है कि उनमें से प्रत्येक में कौन से कौशल सबसे अधिक मांग में हैं।

उदाहरण के लिए, श्रेणी ज्ञान के लिए, स्थिति निम्नानुसार है:

 tmp <- merge(x = all.skills, y = jobdf %>% select(id, lvl), by = "id", sort = FALSE) tmp <- na.omit(tmp) ggplot(as.data.frame(table(tmp %>% filter(category == "knowledge") %>% select(skill.group)))) + geom_bar(colour = "#666666", stat = "identity", aes(x = reorder(Var1, Freq), y = Freq, fill = reorder(Var1, -Freq))) + scale_y_continuous(name = " ") + theme(legend.position = "none", axis.text = element_text(size = 12)) + coord_flip() 

ग्राफ दिखाता है कि डेटाबेस, सॉफ्टवेयर डेवलपमेंट मेथडोलॉजी और 1 सी के क्षेत्र में ज्ञान की सबसे बड़ी मांग है। इसके बाद सीआरएम, ईआरपी-सिस्टम और प्रोग्रामिंग की मूल बातें के क्षेत्र में ज्ञान प्राप्त करें।

जहां तक ​​मानकों का सवाल है, एसक्यूएल और यूएमएल का ज्ञान वास्तव में बहुत मांग में है, एआरआईएस संकेतन उनकी ऊँची एड़ी के जूते के लिए आता है, लेकिन GOSTs केवल छठे स्थान पर हैं।

 ggplot(as.data.frame(table(tmp %>% filter(category == "standards") %>% select(skill.group)))) + geom_bar(colour = "#666666", stat = "identity", aes(x = reorder(Var1, Freq), y = Freq, fill = Var1)) + scale_y_continuous(name = " ") + theme(legend.position = "none", axis.text = element_text(size = 12)) + coord_flip() 

प्रयुक्त उपकरणों के लिए, हम एक बार फिर से पुष्टि करते हैं कि सिर विश्लेषक का मुख्य उपकरण है। कोई भी एमएस ऑफिस लाइन और टास्क ट्रैकिंग सिस्टम के बिना नहीं कर सकता है, लेकिन बाकी उस संपादक के लिए थोड़ी चिंता का विषय है जिसमें विश्लेषक अपनी योजनाओं या स्केच इंटरफेस मॉडल बनाता है।

 ggplot(tmp %>% filter(category == "tools")) + geom_histogram(colour = "#666666", stat = "count", aes(skill.group, fill = skill.group)) + scale_y_continuous(name = " ") + theme(legend.position = "none", axis.text = element_text(size = 12)) + coord_flip() 

आय पर कौशल का प्रभाव

, , . , , , .

jobs.paid all.skills , data frame.

 # 4.4 vizualize paid skills tmp <- na.omit(merge(x = all.skills, y = jobs.paid %>% select(id, salary, lvl, City), by = "id", sort = FALSE)) 

:

 > head(tmp) id skill skill.group category salary lvl City 2 25781585 android mobile os knowledge 90000 middle  3 25781585   project management activities 90000 middle  5 25781585   project management activities 90000 middle  6 25781585 ios mobile os knowledge 90000 middle  7 25750025 aris aris standards 70000 middle  8 25750025 - business analysis activities 70000 middle  

, .. . :

 ggplotly(ggplot(tmp %>% filter(category == "activities"), aes(skill.group, salary)) + coord_flip() + geom_count(aes(size = ..n.., color = City)) + scale_fill_discrete(name = "") + scale_y_continuous(name = ", .") + scale_size_area(max_size = 11) + theme(legend.position = "bottom", axis.title = element_blank(), axis.text.y = element_text(size=10, angle=10))) 

, BA/SA .

:

 ggplot(tmp %>% filter(category == "personal", City %in% c("", "-")), aes(tools::toTitleCase(skill), salary)) + coord_flip() + geom_count(aes(size = ..n.., color = skill.group)) + scale_y_continuous(breaks = round(seq(min(tmp$salary), max(tmp$salary), by = 20000),1), name = ", .") + scale_size_area(max_size = 10) + theme(legend.position = "none", axis.title = element_text(size = 11), axis.text.y = element_text(size=10, angle=0)) 

, MS Office , — , - . , , , .

, , : UML ARIS, SQL ( ) , IDEF — , "".

, , , . , 1478 - key_skills. , - .

, data frame:

 > jobdf$Responsibility[[1]] [1] "Training course in business analysis. ● Define needs of the user/client, understand the problem which needs to be solved. ● " > jobdf$Requirement[[1]] [1] "At least 6 months' experience in business analysis. ● Knowledge of qualitative methods such as usability testing, interviewing, focus groups. ● " 

, , . URL' , .

 hh.get.full.desrtion <- function(df) { df$full.description <- NA for (myURL in df$URL) { try( { data <- fromJSON(myURL) if (length(data$description) > 0) { df$full.description[which(df$URL == myURL, arr.ind = TRUE)] <- data$description } print(paste0("Filling in " , which(df$URL == myURL, arr.ind = TRUE) , " out of " , length(df$URL))) } ) } df$full.description <- tolower(df$full.description) return(df) } 

- , html- ., gsub :

 remove.Html <- function(htmlString) { #remove html tags return(gsub("<.*?>", "", htmlString)) } 

, , , , . data frame ( df), , df "id, skill.group, category".

 skills.from.desc <- function(df, dictionary) { sk <- data.frame( id = numeric() , skill.group = character() , category = character() ) for (myskill in dictionary$skill) { category <- dictionary[dictionary$skill == myskill, "category"] mypattern <- paste0(na.omit(t(dictionary %>% filter(skill == myskill) %>% select(starts_with("syn")))), collapse = "|") if (nchar(mypattern) > 1) { mypattern <- paste0(c(myskill, mypattern), collapse = "|") } else { mypattern <- myskill } cond = grep(x = df$full.description, pattern = mypattern) tmp <- data.frame( id = df[cond, "id"], skill.group = rep(myskill, length(cond)), category = rep(category, length(cond)) ) sk <- rbind(sk, tmp) } return(sk) } 

 # 5 text analysis # 5.1 get full descriptions jobdf <- hh.get.full.description(jobdf) jobdf$full.description <- remove.Html(tolower(jobdf$full.description)) sk.from.desc <- skills.from.desc(jobdf, dict) 

, ?

 > head(sk.from.desc) id skill.group category 1 25638419 axure tools 2 24761526 axure tools 3 25634145 axure tools 4 24451152 axure tools 5 25630612 axure tools 6 24985548 axure tools > tmp <- as.data.frame(table(sk.from.desc$skill.group), col.names = c("Skill", "Freq")) > htmlTable::htmlTable(x = head(tmp[order(tmp$Freq, na.last = TRUE, decreasing = TRUE),], 20), rnames = FALSE, header = c("Skill", "Freq"), align = 'l', css.cell = "padding-left: .5em; padding-right: 2em;") 

, ! Project management, key_skills, ( ).

, , key_skills -5.

, . 1478 , , key_skills, , .

, , BA , - .

, .

data frame , , . , -.

 tmp <- na.omit(merge(x = sk.from.desc, y = jobs.paid %>% filter(City %in% c("", "-")) %>% select(id, salary, lvl, City), by = "id", sort = FALSE)) 

 > head(tmp) id skill.group category salary lvl City 1 25243346 uml standards 160000 middle  2 25243346 requirements management activities 160000 middle  3 25243346 designing business processes activities 160000 middle  4 25243346 communication skills personal 160000 middle  5 25243346 mobile os knowledge 160000 middle  6 25243346 ms visio tools 160000 middle  

, , , .

 ggplotly(ggplot(tmp %>% filter(category == "activities"), aes(skill.group, lvl)) + geom_count(aes(color = salary, size = ..n..)) + scale_size_area(max_size = 13) + theme(legend.position = "right", legend.title = element_text(size = 10), axis.title = element_blank(), axis.text.y = element_text(size=10)) + coord_flip() + scale_color_continuous(labels = function(x) format(x, scientific = FALSE), breaks = round(seq(min(tmp$salary), max(tmp$salary), by = 70000),1), low = "blue", high = "red", name = ", .")) 

?

-, , - . ( , , , .)

-, , "" -, .

, key_skills.

, , 150 .. UML ARIS, IDEF, , — .

:

, - , , key_skills , . , 150 .. , .

?

, - :

, , , ? , . , , . , ó ( ) .

, - :

-

BA/SA ,

• . , ;
• ( ) 200 .. , , ;
• ;
• — - ( , , )
• key_skills hh , ;
• , , , (!) ;
• , -, UX ;
• . , - 150 ..;
• , , SQL, UML & ARIS. , .. . , , , .

 wordcloud2::wordcloud2(data = table(sk.from.desc$skill.group), rotateRatio = 0.3, color = 'random-dark')