सर्च इंजन मार्केटिंग (SEM) के लिए डेटा साइंस

पिछले दो वर्षों से DataCamp का भारी उपयोगकर्ता होने के नाते, मैंने बहुत कुछ सीखा है। मेरा मुख्य व्यवसाय ऑनलाइन मार्केटिंग में है, और मुझे सीखी हुई डेटा साइंस स्किल्स से बहुत लाभ हुआ है। अब मैं कहीं बड़े और अधिक जटिल कैंपेन चला पाने और उन्हें प्रभावी ढंग से बनाए रखने में सक्षम हूँ। चूंकि अब मैं सामग्री, विभिन्न विषयों और R में पैकेजों और Python से काफी परिचित हूँ, मैंने सोचा कि मैं DataCamp के लिए सर्च कैंपेन कैसे बना सकता हूँ—बस एक अभ्यास के तौर पर।

इस ट्यूटोरियल में, आप निम्नलिखित विषयों से निपटेंगे:

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

सर्च इंजन मार्केटिंग (SEM) और कैंपेन

SEM क्या है?

SEM आज के बढ़ते प्रतिस्पर्धी बाजार में अपना व्यवसाय बढ़ाने के सबसे प्रभावी तरीकों में से एक है। यह सर्च इंजनों पर विज्ञापन खरीदकर वेबसाइट ट्रैफिक पाने की प्रक्रिया है। Google AdWords ऑनलाइन विज्ञापन के सबसे लोकप्रिय रूपों में से एक है: आप अपने व्यवसाय से संबंधित कीवर्ड के लिए सर्च इंजन के स्पॉन्सर्ड लिंक में विज्ञापन प्लेसमेंट के लिए बोली लगाते हैं, फिर आप प्रत्येक क्लिक के लिए सर्च इंजन को शुल्क चुकाते हैं।

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

हालांकि प्रति क्लिक कीमत तय करने की सटीक प्रक्रिया एक सख्ती से सुरक्षित रहस्य है और कई कारकों पर निर्भर करती है, मुख्य विचार यह है कि आपके विज्ञापन जितने अधिक प्रासंगिक होंगे, आपका प्रति क्लिक खर्च उतना ही कम होगा।

सर्च कैंपेन सेट करना

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

लेकिन शुरू करने से पहले, आइए देखते हैं कि ये सर्च कैंपेन वास्तव में हैं क्या!

Ad Groups

सर्च कैंपेन शुरू करने के लिए, आपको सबसे पहले अपने ऐड ग्रुप्स के लिए एक योजना बनानी होगी। यही वह बुनियादी इकाई है जहाँ आप कीवर्ड, विज्ञापन और लैंडिंग पेजों को मैप करते हैं। लेकिन ये तीनों घटक वास्तव में क्या हैं?

1. कीवर्ड: उपयोगकर्ता का इरादा, वे क्या ढूंढ रहे हैं।
2. विज्ञापन: उस इरादे के लिए उपयोगकर्ता से आपका वादा।
3. लैंडिंग पेज: आपके वादे की डिलीवरी।

इन तीनों तत्वों को सही ढंग से मैप करना काम का लगभग 70-80% है। यदि आप इसे सही कर लेते हैं, तो रखरखाव और बदलाव बहुत आसान हो जाते हैं।

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

ध्यान दें कि हर ऐड ग्रुप एक कैंपेन का हिस्सा होना चाहिए। कैंपेन स्तर पर, आपके पास ऐसी सेटिंग्स होती हैं जो कैंपेन के सभी ऐड ग्रुप्स को नियंत्रित करती हैं, जैसे भाषा टारगेटिंग, लोकेशन, डिवाइस, दिन का समय, आदि।

सर्च कैंपेन, चरण-दर-चरण

पिछले सेक्शन में आपने उच्च स्तर से सर्च कैंपेन देखें: आपने देखा कि कीवर्ड, विज्ञापन और लैंडिंग पेज एक ऐड ग्रुप का हिस्सा होते हैं और आपको इस बुनियादी संगठन इकाई के लिए एक योजना बनानी होती है जहाँ आप इन तीन घटकों को इस तरह मैप करते हैं कि वे आपकी व्यवसाय रणनीति को दर्शाएँ। इस सेक्शन में, आप और गहराई से देखेंगे कि कैंपेन सेट करने के लिए क्या किया जा सकता है, खासकर उन चरणों पर ध्यान केंद्रित करते हुए जिनसे आप इस ट्यूटोरियल में गुजरेंगे।

जैसा कि ऊपर दिखाया गया है, यही वह मैपिंग है जिसे आप प्राप्त करना चाहते हैं। आउटपुट के रूप में, आप दो मुख्य DataFrame रखना चाहेंगे: एक कीवर्ड के लिए और दूसरा विज्ञापनों के लिए। आप नीचे देख सकते हैं कि यह कैसा दिखेगा।

एक बार ये तैयार हो जाएँ, तो आप इन्हें Comma-separated Value (CSV) फाइलों के रूप में Google AdWords या अन्य ऐसे प्लेटफॉर्म पर अपलोड करने के लिए तैयार होंगे जो बिल्कुल इसी तरह काम करते हैं। Google AdWords अब तक का सबसे लोकप्रिय पेड सर्च प्लेटफॉर्म है जिसका उपयोग सर्च मार्केटर्स करते हैं, इसके अलावा Bing Ads, Yandex, Baidu, और अन्य भी हैं।

ध्यान दें कि यदि आप अपना डेटा Google Adwords या Bing Ads के अलावा अन्य प्लेटफॉर्म पर इम्पोर्ट करना चाहते हैं, तो आपको छोटे-मोटे बदलाव करने होंगे!

बिजनेस केस: DataCamp

जैसा कि आपने भूमिका में पढ़ा, आप DataCamp के लिए सर्च कैंपेन बनाना चाहते हैं। जिस विभिन्न तरीकों से कोई व्यक्ति इस कंपनी के उत्पाद—यानी डेटा साइंस शिक्षा—में रुचि व्यक्त कर सकता है, उन पर नज़र डालते हुए, आप आसानी से उनमें से कुछ के आरंभिक सूची बना सकते हैं:

1. इंस्ट्रक्टर्स: 'Hadley Wickham course', 'courses by Garrett Grolemund', आदि।
2. तकनीकें: 'python course', 'r courses', 'sql data science course', आदि।
3. कोर्स: हमारे पास मौजूद विशिष्ट कोर्स के नाम; 'unsupervised learning in python', 'deep learning in python', आदि।
4. टॉपिक्स: 'machine learning courses', 'data visualization course', आदि।
5. पैकेज/लाइब्रेरी: 'learn ggplot', 'matplotlib tutorial', आदि।

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

इसलिए, इस सेटअप को करने के लिए आपको दो मुख्य चीज़ों की जानकारी होनी चाहिए:

• प्रोडक्ट नॉलेज: यह जानना कि DataCamp के पास कौन से कोर्स और टॉपिक्स हैं, वे वेबसाइट पर कैसे व्यवस्थित हैं, और उन्हें कैसे समूहित किया गया है। आप इसे ब्राउज़ करके जान सकते हैं, और आंतरिक जानकारी से निश्चित रूप से बेहतर इनसाइट मिल सकती है (खासकर यदि बदलाव की योजना है!)।
• प्रासंगिक कीवर्ड: वे सभी संभावित तरीके जिनसे कोई व्यक्ति आपकी दी हुई चीज़ों में इच्छा व्यक्त कर सकता है। DataCamp के मामले में, ये 'course', 'learn', 'education', 'tutorial', आदि हैं। आप यह ब्रेनस्टॉर्मिंग, कीवर्ड टूल्स देखने, और अन्य तरीकों से कर सकते हैं।

आपके SEM कैंपेन के लिए कीवर्ड जनरेशन

आइए कीवर्ड जनरेट करके शुरू करते हैं!

1. इंस्ट्रक्टर कीवर्ड जनरेट करें

यह कैंपेन उन लोगों को टारगेट करेगा जो DataCamp के किसी भी इंस्ट्रक्टर द्वारा दिए गए कोर्स ढूंढते हैं।

आप कीवर्ड को "course by <instructor name>" तक सीमित रख सकते हैं या केवल इंस्ट्रक्टर के नाम को टारगेट करते हुए व्यापक सेट कीवर्ड चुन सकते हैं। शुरुआत में, 'course' या 'courses' के साथ नामों को टारगेट करना बेहतर है और प्रभाव देखें।

आपको यह भी जाँचना होगा कि आपके पास जो नाम हैं, वे कहीं किसी और मशहूर व्यक्ति के नाम तो नहीं हैं, या बहुत सामान्य नाम तो नहीं हैं, और फिर आपको उस इंस्ट्रक्टर के कीवर्ड को सीमित करना होगा।

आप इंस्ट्रक्टर्स के नाम और प्रत्येक के URLs प्राप्त करके शुरू करते हैं:

import requests
from bs4 import BeautifulSoup


instructors_page = 'https://www.datacamp.com/instructors?all=true'
instructor_link_selector = '.instructor-block__description .instructor-block__link' # CSS class of the link
instructor_name_selector = '.mb-sm'  # CSS class of the name

instructor_resp = requests.get(instructors_page)
soup = BeautifulSoup(instructor_resp.text, 'lxml')

instructor_urls = [url['href'] for url in soup.select(instructor_link_selector)]
instructor_names = [name.text.strip() for name in soup.select(instructor_name_selector)]
instructor_urls = ['https://www.datacamp.com' + url for url in instructor_urls]
संचालित द्वारा

आप उन्हें आगे उपयोग के लिए एक DataFrame में रखते हैं। URLs का उपयोग आगे विज्ञापन जनरेट करने के लिए किया जाएगा।

instructor_df = pd.DataFrame({
    'name': instructor_names,
    'url': instructor_urls
})
print(instructor_df.shape)
instructor_df.head()
संचालित द्वारा

(72, 2)
संचालित द्वारा

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

नीचे दिए गए कोड में प्रयुक्त वेरिएबल्स:

col_names: यह उस टेबल के हेडर नामों की सूची है जिसे अंततः हम Google AdWords पर अपलोड करेंगे।
words: वे शब्द जिन्हें आप इंस्ट्रक्टर नामों के साथ मिलाकर पूर्ण कीवर्ड/वाक्यांश बनाएँगे।
match_types: अधिक विवरण AdWords हेल्प सेंटर पर मिल सकते हैं, पर मूल बातें यहाँ हैं।
[data science course], "data science course", और data science course तकनीकी तौर पर तीन अलग-अलग कीवर्ड हैं।

• exact match (कोष्ठकों में) केवल तभी विज्ञापन ट्रिगर करेगा जब उपयोगकर्ता ठीक वही कीवर्ड खोजे, उदाहरण के लिए, 'data science course' बिल्कुल इसी तरह लिखा हुआ।
• phrase match (उद्धरण के साथ) तब विज्ञापन ट्रिगर करेगा जब उपयोगकर्ता उस सटीक स्ट्रिंग के साथ उससे पहले या बाद में कुछ भी खोजे। जैसे "best data science course" या "data science course online" हमारे विज्ञापन ट्रिगर करेंगे।
• broad match (कोई विराम चिह्न नहीं) तब हमारे विज्ञापन ट्रिगर करेगा जब कोई 'data science course' से मिलता-जुलता या संबंधित कुछ भी खोजे। यह Google के एल्गोरिद्म पर निर्भर है, और इसके साथ सावधान रहना चाहिए, क्योंकि यह 'data science platform' जैसी खोजों पर भी विज्ञापन ट्रिगर कर सकता है, जो ठीक वैसा नहीं है जिसे हम प्रमोट करना चाहते हैं। मुझे modified broad match अधिक पसंद है, क्योंकि यह टारगेटिंग को थोड़ा और सीमित करता है। यह मूल रूप से तब विज्ञापन ट्रिगर करता है जब कोई उस शब्द के किसी भी डेरिवेटिव को खोजे, न कि अर्थ में किसी भी समान शब्द को। इसे शब्द की शुरुआत में '+' चिह्न से दर्शाया जाता है। तो '+game' 'gaming', 'gamers' से विज्ञापन ट्रिगर करेगा, लेकिन 'play' से नहीं।

col_names = ['Campaign', 'Ad Group', 'Keyword', 'Criterion Type']
instructor_keywords = []

words = ['course', 'courses', 'learn', 'data science', 'data camp', 'datacamp']
match_types = ['Exact', 'Phrase', 'Broad']
for instructor in instructor_df['name']:
    for word in words:
        for match in match_types:
            if match == 'Broad':
                keyword = '+' + ' +'.join([instructor.replace(' ', ' +').lower(), word])  # modified broach match
            else:
                keyword = instructor.lower() + ' ' + word
            row = ['SEM_Instructors',  # campaign name
                   instructor,  # ad group name
                   keyword, # instructor <keyword>
                   match]  # keyword match type
            instructor_keywords.append(row)

# do the same by having the keywords come before the instructor name
for instructor in instructor_df['name']:
    for word in words:
        for match in match_types:
            if match == 'Broad':
                keyword = '+' + ' +'.join([word, instructor.replace(' ', ' +').lower()])
            else:
                keyword = word + ' ' + instructor.lower() 
            row = ['SEM_Instructors',  # campaign name
                   instructor,  # ad group name
                   keyword, # <keyword> instructor 
                   match]  # keyword match type
            instructor_keywords.append(row)


instructor_keywords_df = pd.DataFrame.from_records(instructor_keywords, 
                                                   columns=col_names)
print('total keywords:', instructor_keywords_df.shape[0])
instructor_keywords_df.head()
संचालित द्वारा

total keywords: 2592
संचालित द्वारा

मूल रूप से, आप इंस्ट्रक्टर नामों, विभिन्न कीवर्ड और सभी मैच प्रकारों पर लूप चला रहे हैं, ताकि हमारे पास सभी संभव संयोजन हों। हम यह दो बार करते हैं, एक बार 'instructor name keyword' और दूसरी बार 'keyword instructor name' टेम्पलेट के लिए।

अब आप सभी सेगमेंट्स के लिए यही काम छोटे बदलावों के साथ दोहराएँगे—कीवर्ड पर और डेटा कैसे निकाला जाए, इस पर।

R for Data Science से मैंने एक अच्छा दिशानिर्देश सीखा है: यदि आप दो से अधिक बार कॉपी-पेस्ट करने जा रहे हैं, तो एक फंक्शन लिखने का समय है!

def generate_keywords(topics, keywords, match_types=['Exact', 'Phrase', 'Broad'],
                     campaign='SEM_Campaign'):
    col_names = ['Campaign', 'Ad Group', 'Keyword', 'Criterion Type']
    campaign_keywords = []

    for topic in topics:
        for word in keywords:
            for match in match_types:
                if match == 'Broad':
                    keyword = '+' + ' +'.join([topic.lower().replace(' ', ' +'), word.replace(' ', ' +')])
                else:
                    keyword = topic.lower() + ' ' + word
                row = [campaign,  # campaign name
                       topic,  # ad group name
                       keyword, # instructor <keyword>
                       match]  # keyword match type
                campaign_keywords.append(row)

    # I said more than twice! :)             
    for topic in topics:
        for word in keywords:
            for match in match_types:
                if match == 'Broad':
                    keyword = '+' + ' +'.join([word.replace(' ', ' +'), topic.lower().replace(' ', ' +')])
                else:
                    keyword = word + ' ' + topic.lower()
                row = [campaign,  # campaign name
                       topic,  # ad group name
                       keyword, # <keyword> instructor
                       match]  # keyword match type
                campaign_keywords.append(row)

    return pd.DataFrame.from_records(campaign_keywords, columns=col_names)
संचालित द्वारा

इसे आजमाते हैं:

topics = ['Data Science', 'Machine Learning']
keywords = ['course', 'tutorial']
generate_keywords(topics, keywords).head(10)
संचालित द्वारा

यह अच्छा दिख रहा है। अब आइए आपके प्रत्येक सेगमेंट के लिए प्रासंगिक टॉपिक्स और कीवर्ड जनरेट करते हैं!

2. तकनीकी कीवर्ड

topics = ['R', 'Python', 'SQL', 'Git', 'Shell']  # listed on the /courses page
keywords = ['data science', 'programming', 'analytics', 'data analysis', 'machine learning',
            'deep learning', 'financial analysis', 'data viz', 'visualization', 'data visualization',
            'learn', 'course', 'courses', 'education', 'data import', 'data cleaning', 
            'data manipulation', 'probability', 'stats', 'statistics', 'course', 'courses',
           'learn', 'education', 'tutorial']  # @marketing_team: this list can / should be refined or 
                                              # expanded based on the strategy and how specific the 
                                              # targeting needs to be
tech_keywords = generate_keywords(topics, keywords, campaign='SEM_Technologies')
print('total keywords:', tech_keywords.shape[0])
tech_keywords.head()
संचालित द्वारा

total keywords: 750
संचालित द्वारा

3. कोर्स कीवर्ड जनरेट करना

संभवतः यह सबसे विशिष्ट सेगमेंट है, और इसलिए लोगों को टारगेट करने के लिए सबसे प्रासंगिक। यदि कोई "data visualization with r" खोज रहा है और DataCamp के पास वह कोर्स है, तो विज्ञापन अत्यंत प्रासंगिक होगा, क्योंकि आपके पास वही सही लैंडिंग पेज होगा जो ठीक उस उपयोगकर्ता की ज़रूरत को पूरा करता है।

हालाँकि एक छोटी समस्या है। कुछ कोर्स नाम उस चीज़ से मेल नहीं खाते जो कोई उपयोगकर्ता आम तौर पर खोजेगा: 'Machine Learning with the Experts: School Budgets', 'Sentiment Analysis in R: The Tidy Way'। ये बुरे कोर्स नाम नहीं हैं, पर इनके लिए ऐसे उपयुक्त कीवर्ड चुनने में ध्यान देना होगा जिन्हें लोग खोज में इस्तेमाल कर सकते हैं।

फिर से, आप कोर्स के नाम और संबंधित URLs वैसे ही स्क्रैप कर सकते हैं जैसे आपने इंस्ट्रक्टर कैंपेन में किया था:

courses_page = 'https://www.datacamp.com/courses/all'
course_link_selector = '.courses__explore-list .course-block'

course_resp = requests.get(courses_page)
soup = BeautifulSoup(course_resp.text, 'lxml')

course_urls = [link.contents[1]['href'] for link in soup.select(course_link_selector)] 
course_urls = ['https://www.datacamp.com' + url for url in course_urls]
course_names = [link.h4.text for link in soup.select(course_link_selector)]
संचालित द्वारा

course_df = pd.DataFrame({
    'name': course_names,
    'url': course_urls
})
course_df['name_clean'] = course_df.name.str.replace('\(.*\)', '').str.strip()  # remove (part x)
print('total keywords:', course_df.shape[0])
course_df.head()
संचालित द्वारा

total keywords: 104
संचालित द्वारा

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

कृपया ध्यान दें कि नीचे खाली कैरेक्टर का उपयोग गलती नहीं है। कोर्स के नाम पर्याप्त लंबे और विशिष्ट हैं कि वे स्वयं ही कीवर्ड बनने के लिए उपयुक्त हैं, बिना 'learn' या 'course' जैसे अतिरिक्त क्वालिफायर जोड़े। इसलिए आप केवल कोर्स नामों का उपयोग करेंगे, साथ ही क्वालिफायर कीवर्ड के साथ भी।

keywords = ['', 'learn', 'course', 'courses', 'tutorial', 'education']
course_keywords = generate_keywords(course_df['name_clean'], keywords, campaign='SEM_Courses')
print('total keywords:', course_keywords.shape[0])
course_keywords.head(10)
संचालित द्वारा

total keywords: 3744
संचालित द्वारा

4. टॉपिक्स के लिए कीवर्ड

ये मूलतः जनरल टॉपिक्स हैं जिन्हें लोग खोजने में रुचि ले सकते हैं। ये 'tracks' सेक्शन द्वारा कवर किए जाते हैं, जिसमें 'स्किल्स' और 'कैरियर' सब-सेक्शन्स हैं। आपके उद्देश्य के लिए, इन्हें उसी कैंपेन के तहत समूहित किया जा सकता है। प्रक्रिया फिर वही है, जैसा आपने पिछले सेक्शन्स में किया!

स्किल्स

skills_page = 'https://www.datacamp.com/tracks/skill'
skills_link_selector = '#all .shim'

skills_resp = requests.get(skills_page)
skill_soup = BeautifulSoup(skills_resp.text, 'lxml')

skills_urls = [link['href'] for link in skill_soup.select(skills_link_selector)] 
skills_names = [skill.replace('/tracks/', '').replace('-', ' ') for skill in skills_urls]
skills_urls = ['https://www.datacamp.com' + url for url in skills_urls]
संचालित द्वारा

कैरियर

career_page = 'https://www.datacamp.com/tracks/career'
career_link_selector = '#all .shim'

career_resp = requests.get(career_page)
career_soup = BeautifulSoup(career_resp.text, 'lxml')

career_urls = [link['href'] for link in career_soup.select(career_link_selector)] 

career_names = [career.replace('/tracks/', '').replace('-', ' ') for career in career_urls]
career_urls = ['https://www.datacamp.com' + url for url in career_urls]
संचालित द्वारा

tracks_df = pd.DataFrame({
    'name': skills_names + career_names,
    'url': skills_urls + career_urls
})
tracks_df['name'] = [x.title() for x in tracks_df['name']]
tracks_df.head()
संचालित द्वारा

tracks_keywords = generate_keywords(tracks_df['name'], keywords, campaign='SEM_Tracks')
print('total keywords:', tracks_keywords.shape[0])
tracks_keywords.head()
संचालित द्वारा

total keywords: 720
संचालित द्वारा

अंत में, आप instructor_keywords, tech_keywords, course_keywords, और tracks_keywords में सूचीबद्ध सभी कीवर्ड को जोड़कर एक बड़ा DataFrame बना लेते हैं:

full_keywords_df = pd.concat([instructor_keywords_df, tech_keywords, course_keywords, tracks_keywords])
print('total keywords:', full_keywords_df.shape[0])
print('total campaigns:', len(set(full_keywords_df['Campaign'])))
print('total ad groups:', len(set(full_keywords_df['Ad Group'])))
full_keywords_df.to_csv('keywords.csv', index=False)
full_keywords_df.head()
संचालित द्वारा

total keywords: 7806
total campaigns: 4
total ad groups: 191
संचालित द्वारा

अब आप अपने कीवर्ड के साथ जाने के लिए तैयार हैं! यदि आप पूरे डेटा सेट पर नज़र डालना चाहते हैं, तो उसे यहाँ पाएं। अगला, आपको अपने प्रत्येक ऐड ग्रुप के लिए विज्ञापन जनरेट करने की जरूरत है।

आइए विज्ञापन जनरेट करें।

विज्ञापन जनरेशन और कॉपी राइटिंग

वर्तमान में आपके पास निम्नलिखित हैं:

• full_keywords_df DataFrame में कैंपेन और ऐड ग्रुप नाम एक-दूसरे से ठीक तरह मैप किए गए हैं
• ऐड ग्रुप का नाम और संबंधित URL (आपके पिछले स्क्रैपिंग—कोर्स, इंस्ट्रक्टर्स और ट्रैक्स—से), और तकनीकों के लिए एक जनरेट करना है।

इसे ध्यान में रखते हुए, आप निम्नलिखित योजना अपना सकते हैं:

1. उपयोग के लिए विज्ञापन टेम्पलेट बनाएं (शुरुआत में 2-3 पर्याप्त हैं)
2. Campaign कॉलम बनाएं और उसे ('name', 'url') DataFrames में जोड़ें
3. सभी ('name', 'url') DataFrames को एक बड़े DataFrame में मर्ज करें

4. सभी ऐड ग्रुप्स के लिए सभी विज्ञापन जनरेट करें; इसमें प्रत्येक विज्ञापन के लिए निम्न फील्ड शामिल होंगे (ये उसी DataFrame में नए कॉलम होंगे जिस पर आप काम कर रहे हैं):

   • Headline 1: अधिकतम 30 अक्षर
   • Headline 2: अधिकतम 30 अक्षर
   • Display URL: Final URL से स्वचालित रूप से निष्कर्षित
   • Final URL: पूर्ण पाथ जहाँ उपयोगकर्ता पहुँचेंगे (Display URL के समान डोमेन होना चाहिए)

5. सुनिश्चित करें कि काम keywords DataFrame के साथ सुसंगत है

6. अपलोड करें और कैंपेन लॉन्च करें!

विज्ञापन जनरेट करने का अर्थ है विषय नाम (कोर्स, टेक, इंस्ट्रक्टर, आदि) को टेम्पलेट में जहाँ होना चाहिए वहाँ रखना, और आपके पास जो ऐड ग्रुप हैं उनके लिए 2-3 विज्ञापन विविधताएँ बनाना।

विज्ञापन टेम्पलेट

एक महत्वपूर्ण बात जिस पर ध्यान देना है, वह यह कि भले ही ऐड ग्रुप नामों को जहाँ होना चाहिए वहाँ प्लग करना सीधी प्रक्रिया है, समस्या यह है कि आपको उपरोक्त सीमाओं के भीतर फील्ड्स की लंबाई रखनी है। और चूंकि आपके कोर्स और टॉपिक्स के नामों में काफी भिन्नता है, आपको देखना होगा कि आप इसके बारे में क्या कर सकते हैं।

आइए देखें कि यह समस्या कितनी बड़ी है:

%matplotlib inline
import matplotlib.pyplot as plt
adgroup_lengths = pd.Series([len(adgrp) for adgrp in full_keywords_df['Ad Group'].unique()])
long_adgroups = sum(adgroup_lengths > 30)
plt.figure(figsize=(9,6))
plt.hist(adgroup_lengths, rwidth=0.9, bins=50)
plt.vlines(x=30, ymin=0, ymax=10, colors='red')
plt.title(str(long_adgroups) + ' ad group name lenghts > 30 (don\'t fit in a headline)',  fontsize=17)
plt.xlabel('Ad Group Name Lengths', fontsize=15)
plt.ylabel('Count', fontsize=15)
plt.yticks(range(11))
plt.xticks(range(0, 51, 5))
plt.grid(alpha=0.5)
plt.show()
संचालित द्वारा

लगता है आपकी समस्या तुच्छ नहीं है, और इसका कोई सीधा समाधान नहीं है। आदर्श रूप से, आप चाहेंगे कि दोनों हेडलाइंस में उस उत्पाद (कोर्स) का पूरा शीर्षक हो जिसे हम प्रमोट कर रहे हैं।

मैंने इसके अलग-अलग तरीके सोचे, और एक साधारण एल्गोरिद्म लिखने का फैसला किया जो नाम को दो वाक्यों में बाँटता है, प्रत्येक में अधिकतम तीस अक्षर हों।

यह एल्गोरिद्म सामान्य उपयोग के लिए उपयुक्त नहीं है, और इसे सामान्य बनाने के लिए कुछ बदलावों की जरूरत है, लेकिन यह इस डेटा सेट के लिए पर्याप्त अच्छा काम करता है:

def split_string(string, splits=2, max_len=60):
    """Split `string` into `splits` words, each shorter than `max_len` / `splits`"""
    if len(string) < max_len / splits:
        return string, ''
    str_words = string.split(' ')
    result = ''
    for i, word in enumerate(str_words):
        if len(result + ' ' + word) <= max_len / splits:
            result += word + ' '
        else:
            break
    spaces = result.strip().count(' ')
    result2 = string[string[len(result):].index(word) + len(result):]
    return result.strip(), result2
संचालित द्वारा

print(split_string('this is a very long course name that needs splitting', 2, 60))
print(split_string('short course name', 2, 60))
संचालित द्वारा

('this is a very long course', 'name that needs splitting')
('short course name', '')
संचालित द्वारा

आम तौर पर मैं ऐसा नहीं करता, लेकिन मुझे यह तकनीक पसंद आई, और मुझे लगता है कि मैं इसे अन्य कैंपेन बनाते समय भी उपयोग करूँगा। ट्यूटोरियल लिखने का यह एक अच्छा साइड इफेक्ट है!

अब आइए उन टेम्पलेट्स के बारे में सोचें जिन्हें आप लिखना चाहते हैं।

सामान्य विज्ञापन टेम्पलेट जिसमें मैं इन तत्वों का उपयोग करता हूँ (आमतौर पर इसी क्रम में):

• प्रोडक्ट: यदि मैं Google पर 'data science course' खोज रहा हूँ, तो मुझे कहीं न कहीं लिंक/विज्ञापनों में 'data science course' दिखना चाहिए।
• लाभ: यह भावनात्मक/मनोवैज्ञानिक पहलू है जिसे लोग वास्तव में पाना चाहते हैं, केवल कोर्स पूरा करने से परे—'अपने करियर को बढ़ावा दें', 'भीड़ से अलग दिखें'।
• फीचर्स: अब जब आपने मुझे बहुत कुछ वादा कर दिया है, तो दिखाएँ कि आप वहाँ कैसे पहुँचाएँगे! '100 से अधिक डेटा साइंस कोर्स', 'शीर्ष विशेषज्ञों से सीखें', 'अपनी कोडिंग स्किल्स पर तुरंत फीडबैक पाएँ'।
• कॉल टू एक्शन: ठीक है, आपने बताया कि आपके पास क्या है, मुझे खरीदने के लिए प्रेरित किया, और दिखाया कि मैं वहाँ कैसे पहुँचूँगा। मैं तैयार हूँ। अब क्या करूँ? 'फ्री ट्रायल के लिए साइन अप करें', 'पहले अध्याय मुफ़्त में देखें', 'वार्षिक सदस्यता पर 20% की बचत'

इन सबको एक ट्वीट-जितने लंबे विज्ञापन में समाहित करना आसान नहीं है, और इनमें से कुछ ओवरलैप भी हो सकते हैं। लेकिन आप अपनी पूरी कोशिश करेंगे।

• Headline 1: इसमें हमेशा कोर्स का नाम (या पहला आधा हिस्सा) होगा।
• Headline 2: कोर्स नाम का दूसरा आधा हिस्सा, या निम्न में से कोई एक:
  • Boost Your Data Science Career
  • Stand Out From the Crowd
  • Tackle Complex Questions
• Description: प्रत्येक ऐड ग्रुप में नीचे दिए गए तीन विविधता होंगे और वे रोटेट होंगे।
  • Learn Directly From the Top Experts in the Field. 20% off Annual Subscriptions
  • Get Ahead of the Curve, Master Data Science Skills. $29 / Month. Cancel Anytime
  • Choose From a Wide Variety of Topics Tuaght by the Best in the World. Start Now

Campaign कॉलम बनाएं

full_keywords_df.Campaign.unique()  # just to make sure you have consistent naming conventions
संचालित द्वारा

array(['SEM_Instructors', 'SEM_Technologies', 'SEM_Courses', 'SEM_Tracks'], dtype=object)
संचालित द्वारा

course_df['Campaign'] = 'SEM_Courses'
course_df = course_df.rename(columns={'name_clean': 'name', 'name': 'old_name'})
course_df.head()
संचालित द्वारा

instructor_df['Campaign'] = 'SEM_Instructors'
instructor_df.head()
संचालित द्वारा

tracks_df['Campaign'] = 'SEM_Tracks'
tracks_df.head()
संचालित द्वारा

tech_domain = 'https://www.datacamp.com/courses/tech:'
tech_domain_list = []
for tech in ['R', 'Python', 'SQL', 'Git', 'Shell']:
    tech_domain_list.append((tech, tech_domain + tech))
tech_df = pd.DataFrame.from_records(tech_domain_list, columns=['name', 'url'])
tech_df['Campaign'] = 'SEM_Technologies'
tech_df
संचालित द्वारा

सभी ('name', 'url') DataFrames मर्ज करें

full_ads_df = pd.concat([course_df[['Campaign', 'name', 'url']],
                        instructor_df,
                        tracks_df,
                        tech_df], ignore_index=True)
full_ads_df = full_ads_df.rename(columns={'name': 'Ad Group', 'url': 'Final URL'})
print('total rows:', full_ads_df.shape[0])
n_adgroups = full_ads_df.shape[0]
full_ads_df.head()
संचालित द्वारा

total rows: 201
संचालित द्वारा

विज्ञापन जनरेट करें

बस यह ट्रैक रखने के लिए कि आप कहाँ हैं। अब आपके पास विज्ञापनों का DataFrame है जिसमें Campaign, Ad Group, और Final URL कॉलम ठीक तरह से मैप्ड हैं। आपको Headline 1, Headline 2, और Description फील्ड्स जोड़ने हैं।

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

आइए full_ads_df में प्रत्येक पंक्ति को तीन बार डुप्लिकेट करके शुरू करते हैं:

full_ads_df = full_ads_df.iloc[[x  for x in range(n_adgroups) for i in range(3)], :] 
print('total rows:', full_ads_df.shape[0])
full_ads_df.head(9)
संचालित द्वारा

total rows: 603
संचालित द्वारा

अब आप ऊपर बनाए गए तीन अलग-अलग विवरण जोड़ते हैं।

Description = [
    'Learn Directly From the Top Experts in the Field. 20% off Annual Subcriptions',
    'Be Ahead of the Curve, Master Data Science Skills. $29 / Month. Cancel Anytime',
    'Choose From a Wide Variety of Topics Tuaght by the Best in the World. Start Now'   
]
Description = [x for i in range(n_adgroups) for x in Description ]
full_ads_df['Description'] = Description
full_ads_df.head()
संचालित द्वारा

अगला, आप DataFrame में Headline 1 और Headline 2 जोड़ते हैं। आप लगभग तैयार हैं!

benefits = [
    'Boost Your Data Science Career',
    'Stand Out From the Crowd',
    'Tackle Complex Questions'    
]
संचालित द्वारा

जिन मामलों में ऐड ग्रुप की लंबाई 30 या उससे कम है, उनमें लाभों को Headline 2 के रूप में शामिल किया जाएगा। इस स्थिति में, आपके पास एक खाली फील्ड होगा, जिसे आप अपने पास उपलब्ध लाभों में से किसी एक से भरेंगे।

benefits = [x for i in range(n_adgroups) for x in benefits]
headlines = [split_string(x) for x in full_ads_df['Ad Group']]
full_ads_df['Headline 1'] = [x[0] for x in headlines]
full_ads_df['Headline 2'] = [x[1] if x[1] else benefits[i] for i, x in enumerate(headlines)]
print('total ads:', full_ads_df.shape[0])
full_ads_df.head(9)
संचालित द्वारा

total ads: 603
संचालित द्वारा

जैसा कि आप देख सकते हैं, "Intro to Python for Data Science" इतना लंबा था कि वह दो फील्ड ले ले, तो आप स्पष्टता बनाए रखने के लिए इसे ऐसे ही रहने दें। दूसरे मामले में "Introduction to R" पहली हेडलाइन में फिट हो जाता है, तो आप Headline 2 में बनाए गए तीन अलग-अलग लाभ शामिल करते हैं।

और आप काम पूरा कर चुके हैं!

विवरण दोबारा जाँचें

बस एक त्वरित जाँच, यह सुनिश्चित करने के लिए कि दोनों DataFrames में सभी कैंपेन और ऐड ग्रुप नाम समान हैं।

ads_check = (full_ads_df[['Campaign', 'Ad Group']]
             .drop_duplicates()
             .sort_values(['Campaign', 'Ad Group'])
             .reset_index(drop=True))
keywords_check = (full_keywords_df[['Campaign', 'Ad Group']]
                  .drop_duplicates()
                  .sort_values(['Campaign', 'Ad Group'])
                  .reset_index(drop=True))

all(ads_check == keywords_check)
संचालित द्वारा

True
संचालित द्वारा

full_ads_df.to_csv('ads.csv', index=False)
संचालित द्वारा

अपलोड करें और लॉन्च करें

जैसा कि चर्चा की गई, यह ट्यूटोरियल केवल SEM कैंपेन के विशिष्ट चरणों को कवर करता है और इसलिए यह मानता है कि आपको सर्च इंजन मार्केटिंग कैसे काम करती है इसकी बुनियादी समझ है। यदि आप अपने ऐड ग्रुप्स को अपलोड और लॉन्च करने के तरीके के मैकेनिक्स और विवरण के बारे में अधिक जानना चाहते हैं, तो आप शुरुआत कैसे करें, इस पर AdWords की गाइड देख सकते हैं। अलग-अलग क्षेत्रों में पूरे कोर्स एक्सेस करने के लिए, आप Google Academy for Ads देख सकते हैं।

डेटा साइंस और SEM: जानने को बहुत कुछ बाकी है!

जो दो CSV फाइलें अब आपके पास हैं, उनसे आप अपलोड कर सकते हैं और अपने कैंपेन चलाना शुरू कर सकते हैं। आपको दैनिक बजट, जियो-टार्गेटिंग और कुछ अन्य पैरामीटर्स सेट करने होंगे, पर अधिकांशतः, आप तैयार हैं।

यदि आप CSV फाइलें देखना चाहते हैं, तो वे यहाँ मिलेंगी:

• keywords
• ads

आशा है कि आपको यह ट्यूटोरियल उपयोगी लगा होगा। पढ़ने के लिए धन्यवाद, और यदि आप Python की मदद से किए गए किसी भी ग्रोथ प्रोजेक्ट को साझा करना चाहते हैं, तो मुझसे Twitter पर @eliasdabbas पर संपर्क करने में संकोच न करें।