Как посчитать воронку продаж питон

Русские Блоги

Python рассчитывает коэффициент удержания и коэффициент конверсии (анализ воронки)

1. Данные дела

В операциях с данными часто используются анализ коэффициента удержания и анализ коэффициента конверсии (воронки). В этой статье собраны конкретные примеры, чтобы обобщить, как использовать python для определения коэффициентов удержания за n дней и коэффициентов конверсии между ссылками.
Интерпретация индекса

Введение в набор данных по делу:
В этой статье для анализа используются рабочие данные приложения Taobao. Набор данных содержит следующие поля (части):

• user_id: идентификатор пользователя
• время: время, когда произошло действие пользователя
• behavior_type: тип поведения пользователя, который можно разделить на (1 щелчок, 2 избранных, 3 добавления в корзину и 4 оплаты покупок).

По временному полю можно получить следующие характеристические данные:

• день: дата, когда произошло поведение пользователя
• час: период
• будний день: цикл

2. Расчет коэффициента удержания

Удерживать пользователей: Пользователи, которые начинают использовать продукт в определенный период времени и продолжают использовать продукт через определенный период времени, являются зарезервированными пользователями.
Коэффициент удержания= Количество пользователей, все еще использующих продукт / исходное общее количество пользователей.
классифицируется по параметру времени. Уровень удержания часто делится на удержание на следующий день, удержание в течение 3 дней, удержание в течение 7 дней и удержание в течение 30 дней.
Логика программы:

1. Определите нового пользователя, установленного на указанную дату, запишите количество пользователей как b
2. Получите коллекцию пользователей на энный день
3. Определите и подсчитайте количество новых пользователей, которые все еще используют продукт на n-й день указанной даты, и запишите количество пользователей как
4. Уровень удержания = a / b

3. Расчет коэффициента конверсии (анализ воронки).

С помощью анализа воронки мы можем обнаружить конверсию и потерю каждого шага в многоэтапном процессе.
В воронке этого случая последовательность процесса: 1 клик-3 добавить к корзине-2 сбор-4 платеж (при условии, что вышеуказанные шаги могут выполняться только последовательно или прерываться, а промежуточный процесс нельзя пропустить к следующему Узлов).
Программная логика: Подсчитайте количество пользователей, переходящих по каждой ссылке отдельно, и сравните их отдельно.

Визуализация данных с использованием Plotly и Python

Визуализация данных — важная часть деловой практики, потому что сегодня компании генерируют большие объемы данных. Датчики по всему миру собирают климатические данные, данные о пользователях, прогнозируемые данные о рулевом колесе и т. Д. Все эти собранные данные содержат ключевые идеи и визуализации для предприятий, которые упрощают понимание этих данных.

Анализ данных Python можно выполнить с помощью нескольких пакетов. Matplotlib и Seaborn — самые распространенные пакеты в Python. Поговорим о пакете Plotly. Его можно использовать в сценариях Python, записной книжке Jupyter и базах данных для веб-приложений.

Вступление

Matplotlib идеален, Seaborn великолепен, но Plotly? Это совершенно новый уровень. Plotly предлагает больше, чем ваш средний график, предоставляя возможности полной интерактивности и многочисленные инструменты редактирования. Отличается от других возможностью иметь графики в автономном или онлайн-режиме, он также оснащен надежным API, который будет работать без проблем, если он настроен для отображения графиков в веб-браузере, а также возможностью сохранять локальную копию. . Одна из единственных трудностей, с которыми вы столкнетесь, — это работа с множеством вариантов выбора ресурсов, которые вы хотите использовать для своих историй.

Настройка

Чтобы установить пакет Plotly , откройте Терминал и введите pip install plotly . Plotly — это платформа, работающая на JSON, формате, в котором параметры передаются в Plotly API в словарных форматах. Сюжет и информация сохраняются в вашей учетной записи Plotly при просмотре визуализаций. У вас будет в общей сложности 25 графиков, которые можно сохранить в Интернете без взимания платы за дополнительное хранилище в облаке, но эти изображения можно легко хранить локально и удалять, освобождая место для большего количества.

Есть два основных способа отображения графиков. Функция py.iplot() отображает графики в выходных данных под ячейкой, если вы используете Jupyter Notebook или другую интерактивную среду Python (файлы с расширением .ipynb ). С другой стороны, py.plot() возвращает URL-адрес, который можно сохранить, и использует веб-браузер по умолчанию для его открытия.

Начиная

import plotly.plotly as py : Он имеет функции для связи с серверами Plotly.

import plotly.graph_objs as go : Здесь есть функции для создания графических объектов. Это полезный модуль для вызова справки, чтобы увидеть все атрибуты, принятые в качестве параметров объекта.

Мы собираемся построить простую воронку конверсии для веб-сайта электронной коммерции. Цель состоит в том, чтобы построить простую воронку конверсии и получить полезную информацию.

Загрузить набор данных

Перед загрузкой данных импортируйте необходимые зависимости.

Первым процессом в конвейере обработки данных является исследовательский анализ данных. Хорошая практика состоит в том, чтобы сначала понять данные и попытаться собрать из них как можно больше идей. EDA — это понимание имеющихся данных, прежде чем их испортить. Затем мы можем изучить данные, чтобы увидеть, сколько пропущенных значений присутствует в каждом наборе данных. В каждом наборе данных есть только один шаг воронки конверсии, и они связаны user_id

Теперь мы можем создать таблицу, в которой мы можем видеть значения для различных шагов воронки.

Базовая воронка конверсии

Воронка конверсии описывает различные этапы пути покупателя, ведущего к покупке, с разделением на верхнюю, среднюю и нижнюю воронки.

Эта воронка будет базовой. Давайте визуализируем воронку конверсии, показывающую количество конверсий для каждого события / фазы.

Подготовка и объединение данных для сегментированных воронок

Эта воронка представляет собой то же, что мы видим в table1.py из выше, но с большим визуальным эффектом. Кроме того, значительно сокращается количество пользователей на странице поиска по сравнению с количеством пользователей на странице оплаты. Это могло быть связано с очень многими факторами. Сайт электронной коммерции может предлагать различные стратегии, чтобы сдерживать клиентов и увеличивать их удержание.

Если мы углубимся в данные, мы сможем получить больше информации. На каждом этапе воронки мы можем найти взаимосвязь между полом и подтверждением оплаты. Для этого все фреймы данных необходимо объединить в один фрейм данных. Важно подсчитывать каждого пола на каждом этапе или процессе.

Представим приведенную выше таблицу в виде сегментированной воронкообразной диаграммы.

Судя по диаграмме сегментированной воронки, больше женщин сделали последний платеж за покупку продукта, чем мужчины. Хотя разница между полом небольшая.

Чтобы узнать, какой тип устройства каждый пол больше всего использует для доступа к сайту электронной коммерции, мы можем создать сегментированную воронку для каждого типа устройства и пола. Звучит хорошо, правда? Вернемся к данным снова

Это достигается с помощью функции groupby в Pandas. Мы объединяем данные о поле и типе устройства вместе.

Я построил воронкообразную диаграмму с накоплением для облегчения интерпретации и анализа.

Рекомендации

В зависимости от того, как долго ваш путь конверсии, вам может потребоваться ряд различных взаимодействий с вашими клиентами, чтобы заработать их лояльность и перевести их на следующий этап воронки.

Как мы видим по визуальному впечатлению, большинство пользователей заходят на сайт электронной коммерции со своего рабочего стола, и количество пользователей на домашней странице резко сокращается по сравнению с количеством пользователей на странице подтверждения. Сайт электронной коммерции может предлагать стратегии, чтобы удерживать клиентов от использования их настольных приложений. Есть много причин, по которым потенциальный покупатель отказывается от своей корзины. Они могли просто просматривать страницы, сравнивать цены или забыли совершить покупку. Брошенные тележки не означают пропущенные продажи, поэтому вы все равно можете общаться с ними, используя электронный маркетинг, ретаргетинговую рекламу или даже push-уведомления.

User conversion funnel

This is the third part of the series Mobile Analytics using Python, describing how to calculate your key app usage metrics using nothing but python.

Code snippets provided in each section, and the Github repo can be found here.

Objective

In this section we will be carrying out a funnel analysis to calculate the number/percentage of users that perform each step, visualising the conversion down the funnel.

We will also extend the code to be able to produce stacked funnel plots, whereby users will be grouped together using any of the user properties.

Why bother?

Funnel analysis is critical in identifying bottlenecks at any point in the user journey. Usually, there is a key event which generates revenue for the business. Maximising the number of people performing this action is thus to our best interest.

Users can have numerous significant drop-off points. Visualising these helps in deciding which area to focus on to maximise conversion from one point to another.

What stands out from the above plot is that not enough users purchase an item. In addition, maybe we could also improve the sign up process so that fewer people are lost at this stage.

Note that maximising the conversion to the step just before the revenue making event might make sense for some businesses, but not for others. You can increase overall user activity and engagement, but at the end of the day if you have many users that explore the app but do not generate revenue for you you might have been focussing on the wrong area.

Targeting users that generate revenue is a more stochastic approach, and that’s why we will be plotting stacked funnel plots that will allow us to make comparisons between conversions of different user segments.

Studying the funnel plot above, even though you have more non-organic (blue) users, it is clear that the conversion for organic users in the last two steps is higher, with a final conversion of 1% at the purchase point for organic and 0.2% for non-organic (too small to be visible in the image above; later these plots will be interactive and all the stats can be visualised by hovering over the stage of interest). If the total number of users can be considered to be representative of the total population, this would hint that organic users would generate more revenue for this business.

Requirements

• Python (I am using v3.7)
• Pandas: for data manipulation
• Plotly: for visualisations*
• A note on Plotly: One could use matplotlib instead, but way more lines of code would be needed to make the plots look pretty, be annotated and offer interactivity. We will be creating plots that are easy to dive into and share with other people.

References/ Logic

If you search online for how to generate the funnel numbers, you would find answers like this, which basically suggest a succession of LEFT JOINs (in SQL lingo). To generate the single funnel plot from above using (postgre)SQL we could use this query:

This logic will be used as the foundation of our code for calculating the number of users performing each step in the funnel using pandas. What we will be doing differently is that at after each join we will be finding the minimum time that an event was performed for each user and filter the DataFrame for that. This will (hopefully) make more sense in the next section with visual aid.

The code for generating the funnel stats and the plot should tick off the following requirements:

• If a user is counted in any step, he/she should have also performed all of the previous steps
• For a user to be counted in any step, the time the user performed this step was after he/she performed the previous step
• Optional: step n should take place within a specified timeframe after step n-1
• Optional: the first step should take place between from_date and to_date (filtering is only done on the first event; more on this later)

The difficulty in funnel analysis, is that the user journey is not always a linear unidirectional path. For many of the events that you are tracking, the user can perform them at any given time. For example, even after purchasing an item, the user can go back and fill in or update some of his/her profile details.

In a funnel analysis, we are concerned in finding out who performed specific steps, whilst respecting the order/timeline with which they were taken.

Methodology to be implemented:

1. Define a list of events for the funnel analysis
2. For the first event, find the minimum time that a user performs the event
3. For any subsequent event:
   — Do a left join, joining the event DataFrames on the distinct_id column
   — For each user filter only events that took place after the minimum time in the previous event
   — For each user, find and filter only for the minimum time that the event was done
   — Move on to the next event and repeat all steps in (3)

1) Define a list of events

This is simply a list of strings, the order of which resembles the order of the events to appear in the funnel plot. In the example we are using in this whole section, this would look like:

2) For the first event, find the minimum time the event was done

First we need to create a values list to hold the number of users per step.
We will then loop through each event in the steps list, and:

• When dealing with the first event, simply filter for the users that performed the event and for the first time they did it
• For any subsequent event, perform the left join and filtering as described before.

Let’s define the values list and structure out the for loop. Note that we are also defining a dfs dictionary to hold all of the filtered DataFrames of each step.

Let’s now fill in the first part of the loop, dealing with the case of the first event:

dfs['Install'] would look like:

Note that at this stage, there would only be one row (install event) per user as we kept only the first install instance per user.

3) Left join for any subsequent event

Now, we can fill in the else part of the loop, dealing with any subsequent events.

For the second event, we need to filter the events DataFrame for that event and do a left join to the DataFrame that resulted from the previous step.

The output of the above looks like:

By default, ‘_x’ suffix is added to the first DataFrame in the pd.merge() method, which corresponds to the DataFrame of the first event, and ‘_y’ corresponds to the DataFrame for the second event.

Note that here there might be more than one row per user as we performed a left join. The number of rows would correspond to the number of SignUp events we have in this case for which the users also have an Install event.

Thus, we now need to filter only for instances when the second step happened after the first event. We can then keep only the minimum time for the second event for each user from the resulting DataFrame.

The output of the above will still have the same output structure, but with each user only appearing once (one row per user).

We now need to keep only the columns representing the current event, and overwrite dfs[step] with the merged DataFrame in order to be able to find the valid distinct users for the next step.

4) Convert the values list to a DataFrame

To get the funnel DataFrame we simply need to convert the values list into a DataFrame.

Note that we don’t really need to create a DataFrame at this point. We could instead pass the steps and values list to the plotly plotting function, but just doing it here for visual purposes.

The final DataFrame looks like:

Let’s now wrap everything up in a single function:

Thins we added to the final function:

• from_date & to_date : These can be used to filter the first event only for instances that it happened between these two dates. We only filter on the first event to allow time for users to take the subsequent actions; this very helpful when combining funnel plots with cohort analysis, as users that did the first event towards the end of a given cohort should be allowed to take following actions that overrun in the next cohort, so as to not incorrectly report numbers.
• step_interval : this is useful when we want to limit the time interval between subsequent events, i.e. only show people that performed event_2 within 2 hours after completing event_1. This interval should be a valid pd.Timedelta object.

Visualisation

Since plotly is so great, we will use it to generate a plotly funnel plot. To generate a single funnel (not a stacked) plot, all we would need is:

Before we wrap up the final function for plotting the funnel, let’s create a short function that will allow us to plot stacked funnels. The way to do this is to call the create_funnel_df in a for loop and populate a dictionary of funnel DataFrames. In the plotting function we will then iterate through this dictionary and generate and one trace for each of the DataFrames.

What this allows us to do is to generate a one funnel plot per entry in a specified column. Here we will be using the user_source column to break down the funnels depending on if the user is organic or non-organic.

Воронка конверсии пользователей

Это третья часть серии статей «Мобильная аналитика на Python», в которой рассказывается, как рассчитать ключевые показатели использования приложений с помощью одного лишь Python.

Фрагменты кода, представленные в каждом разделе, и репозиторий GitHub можно найти здесь.

Задача

Сегодня мы будем проводить анализ воронки и вычислять количество/процент пользователей, которые проходят по ее уровням, визуализируя всю конверсию в виде воронки.

Также мы немного расширим код, чтобы иметь возможность создавать сложенные воронки, в которых пользователи будут сгруппированы по определенным свойствам.

Зачем себя утруждать?

Анализ воронки имеет решающее значение для выявления узких мест на любом этапе пути пользователя. Обычно все сводится к ключевому событию, которое и приносит доход бизнесу. То есть, в наших интересах максимально увеличить число людей, выполняющих это действие.

У пользователей бывает множество значимых точек отсева. Визуализация их пути помогает понять, на какой области следует сосредоточиться, чтобы максимизировать конверсию из одной точки в другую.

Пример построения воронки с использованием фиктивных данных (числа – это количество отдельных пользователей, проходящих соответствующий шаг, а проценты – это процент пользователей от всех пользователей с предыдущего шага).

Что ясно видно из диаграммы выше, так это то, что недостаточно пользователей покупают товар. Кроме того, можно было бы улучшить процесс регистрации, чтобы на этом этапе отсеивалось меньше людей.

Обратите внимание, что максимизация конверсии на этапе непосредственно перед ключевым событием, приносящим доход, может иметь смысл не для всех компаний. Вы можете увеличить общую активность и вовлеченность пользователей, но в конце концов, если у вас много пользователей, которые изучают приложение, но не приносят вам доход, то вы, возможно, сосредоточились не на той области.

Ориентация на пользователей, которые приносят доход, является более стохастическим подходом, и именно поэтому мы будем строить сложенные воронки, которые позволят нам сравнить конверсии разных сегментов пользователей.

Диаграмма сложенной воронки с разбиением по источникам пользователей (органическим и неорганическим)

После изучения воронки выше, несмотря на большое количество неорганических пользователей (выделено синим), становится ясно, что конверсия органических на последних двух этапах выше, с окончательной конверсией 1% в точке покупки для органических пользователей и 0,2% для неорганических (слишком малый процент, чтобы его можно было увидеть на изображении выше. Позже мы сделаем эти графики интерактивными, и всю статистику можно будет визуализировать, наведением курсора на интересующий этап). Если общее число пользователей можно будет считать репрезентативным для всех пользователей, значит, органические пользователи будут приносить больший доход этому бизнесу.

Требования

Python 3 (у меня 3.7)

Pandas: для работы с данными

Plotly: для визуализации

Примечание для Plotly: Вместо него можно было бы использовать matplotlib, но тогда потребуется гораздо больше строк кода, чтобы диаграммы выглядели красиво, все было подписано и интерактивно. Мы будем создавать диаграммы, в которые легко погрузиться и которыми можно поделиться с другими.

Источники/логика

Если вы погуглите, как сгенерировать данные для воронки, то найдете ответы, подобные этому, где в основном предлагают последовательно использовать несколько LEFT JOIN (на SQL). Чтобы за раз сгенерировать данные для воронки с помощью (postgre)SQL, мы могли бы использовать следующий запрос:

Эту логику мы возьмем за основу при подсчете количества пользователей на каждом уровне воронки, но воспользуемся pandas . Что мы здесь изменим, так это то, что после каждого join мы будем находить минимальное время выполнения события для каждого пользователя и фильтровать для этого DataFrame . Надеюсь, в следующем разделе с наглядной реализацией вы увидите весь смысл.

Код для генерации статистики воронки и диаграммы должен соответствовать следующим требованиям:

Если пользователь учитывается на каком-либо уровне (шаге), то он также должен был пройти все предыдущие;

Для пользователя, который учитывается на любом уровне, время перехода на следующий уровень – это конец предыдущего.

Опционально: Шаг N должен выполняться в течение указанного периода времени после шага N-1.

Опционально: Первый шаг должен выполняться между from_date и to_date (фильтрация выполняется только для первого события, подробнее об этом позже).

Сложность анализа воронки заключается в том, что путь пользователя не всегда линейный и однозначный. Что характерно для многих отслеживаемых вами событий, пользователь может выполнить их в любой момент. Например, даже после покупки товара пользователь может вернуться и заполнить или обновить некоторые данные своего профиля.

При анализе воронки мы заинтересованы в том, чтобы выяснить, кто выполнил конкретные шаги, соблюдая при этом порядок/сроки, с которыми они были предприняты.

Методология, которую будем внедрять:

Определите список событий для анализа воронки.

Для первого события найдите минимальное время, за которое пользователь выполняет его.

Для любого последующего события:

Сделайте left join к DataFrame-ам в столбце distinct_id ;

Для каждого пользователя отфильтруйте только те события, которые произошли после проведения минимального времени на предыдущем шаге;

Для каждого пользователя найдите и отфильтруйте минимальное время прохождения события;

Переходите к следующему событию и повторите все шаги пункта 3.

Определим список всех событий

У нас есть просто список строк, порядок которых коррелирует с порядком событий, отображаемых на диаграмме воронки. Для примера, который мы используем во всем этом разделе, это будет выглядеть так:

2. Для первого события найдем минимальное время, за которое пользователь выполняет его

Для начала нам нужно создать список значений values для определения количества пользователей на каждом уровне.

Затем мы пройдемся по каждому событию в списке steps , и:

Для первого события просто отфильтруйте пользователей, которые прошли этот шаг, и которые сделали это в первый раз.

Для любого последующего события сделайте left join и фильтрацию, как описано выше.

Давайте определим список values и структурируем цикл for . Обратите внимание, что мы также определяем словарь dfs для хранения всех отфильтрованных DataFrame-ов каждого шага.

Теперь давайте заполним первую часть цикла, касающуюся первого события:

dfs[‘Install’] будет выглядеть так:

Обратите внимание, что на этом этапе у каждого пользователя будет только одна строка (событие установки), поскольку мы сохранили только первый экземпляр install для каждого пользователя.

3. Left join с каждым последующим событием

Теперь мы можем дописать часть else в цикле для работы с любыми последующими событиями.

Для второго события нам нужно отфильтровать DataFrame этого события и сделать left join с DataFrame-ом из предыдущего шага.

Результат выполнения кода выше будет таким:

«time_x» — время, когда пользователь выполнил первый шаг, а «time_y» — время, когда пользователь выполнил второй шаг.

По умолчанию суффикс «_x» добавляется к первому DataFrame-у в методе pd.merge() , который соответствует DataFrame-у первого события, а «_y» — второму.

Обратите внимание, что здесь может получаться более одной строки на пользователя, поскольку мы выполнили left join . Количество строк будет соответствовать количеству имеющихся событий SignUp в случае, если у пользователей уже есть событие Install .

Таким образом, теперь нам нужно отфильтровать только те случаи, в которых второй шаг произошел после первого события. Затем можно сохранить только минимальное время для второго события для каждого пользователя из результирующего DataFrame.

Результат выполнения кода выше по-прежнему будет иметь ту же структуру вывода, но теперь каждый пользователь будет встречаться всего один раз (по одной строке на пользователя).

Теперь нам нужно сохранить только столбцы, представляющие текущее событие, и перезаписать dfs[step] полученным DataFrame-ом, чтобы иметь возможность найти отдельных валидных пользователей для следующего шага.

4. Конвертация списка values в DataFrame

Чтобы получить DataFrame воронки, нам просто надо преобразовать список values в DataFrame.

Обратите внимание, что на данный момент нам действительно не нужно создавать DataFrame. Вместо этого мы могли бы передать списки steps и values в функцию отрисовки plotly, но сделаем это здесь для поддержания наглядности.

Итоговый DataFrame выглядит так:

Давайте теперь обернем все в одну функцию:

Моменты, которые мы добавили в итоговую функцию:

from_date и to_date : Могут использоваться для фильтрации первого события в случаях, когда оно произошло между этими двумя датами. Мы отфильтровываем только первое события, чтобы правильно посчитать время выполнения пользователями последующих действий. Механика очень полезна при объединении диаграмм воронок с анализом когорт, поскольку пользователям, которые выполнили первое событие ближе к концу данной когорты, должно быть разрешено выполнять следующие действия в следующей когорте, чтобы не выдавать неверные данные.

step_interval : Полезная вещь, если мы хотим ограничивать интервал времени между последующими событиями, то есть, например, показывать только тех людей, которые завершили event_2 в течение 2 часов после завершения event_1 . Этот интервал должен быть валидным pd.Timedelta объектом.

Визуализация

Поскольку plotly классный, мы воспользуемся им для создания диаграммы воронки. Для создания обычной (не сложенной) диаграммы все что нам понадобится, это:

Перед тем, как сделать итоговую функцию построения воронки, давайте сделаем небольшую функцию, которая позволит нам делать сложенные воронки. Хороший способ – вызвать create_funnel_df в цикле for и заполнить словарь DataFrame-ов воронки. В функции построения диаграммы мы пройдемся по этому словарю и сгенерируем по одной трассировке для каждого DataFrame-а.

Теперь мы можем создать диаграмму воронки для каждой записи в указанном столбце. Здесь мы будем использовать столбец user_source , чтобы разбить воронки в зависимости от того, является ли пользователь органическим или неорганическим.

Итоговая функция построения диаграммы будет выглядеть так:

А результат получится такой:

Мы сгенерировали его с помощью:

Здесь мы сохраняем диаграмму только в студии диаграмм plotly, так я ее сюда и встроил.