customeranalytics 0.1__py3-none-any.whl

customeranalytics/ml_process/clv_prediction.py

@@ -0,0 +1,301 @@
+import sys, os, inspect
+import pandas as pd
+import numpy as np
+import glob
+from clv.executor import CLV
+from sqlalchemy import create_engine, MetaData
+
+currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
+parentdir = os.path.dirname(currentdir)
+sys.path.insert(0, parentdir)
+
+from customeranalytics.configs import default_es_port, default_es_host, max_elasticsearch_bulk_insert_bytes, default_es_bulk_insert_chunk_size
+from customeranalytics.utils import *
+from customeranalytics.data_storage_configurations.query_es import QueryES
+from customeranalytics.data_storage_configurations.reports import Reports
+
+
+engine = create_engine('sqlite://///' + join(abspath_for_sample_data(), "web", 'db.sqlite3'), connect_args={'check_same_thread': False})
+metadata = MetaData()
+con = engine.connect()
+
+
+class CLVPrediction:
+    """
+    Customer Lifetime Value Prediction;
+    For more information pls check; https://github.com/caglanakpinar/clv_prediction
+
+
+    """
+    def __init__(self,
+                 temporary_export_path,
+                 host=None,
+                 port=None,
+                 time_period='weekly',
+                 download_index='downloads',
+                 order_index='orders'):
+        """
+        ******* ******** *****
+        Dimensional CLV Prediction:
+        Descriptive Statistics must be created individually for dimensions.
+        For instance, the Data set contains locations dimension.
+        In this case, each location of 'orders' and 'downloads' indexes must be created individually.
+        by using 'download_index' and 'order_index' dimension can be assigned in order to create the CLV Prediction.
+
+        download_index; downloads_location1 this will be the location dimension of
+                        parameters in order to query downloads indexes; 'location1'.
+        download_index; orders_location1 this will be the location dimension of
+                        parameters in order to query orders indexes; 'location1'.
+        ******* ******** *****
+        !!!
+
+        :param host: elasticsearch host
+        :param port: elasticsearch port
+        :param download_index: elasticsearch port
+        :param order_index: elasticsearch port
+        """
+        self.port = default_es_port if port is None else port
+        self.host = default_es_host if host is None else host
+        self.download_index = download_index
+        self.order_index = order_index
+        self.time_period = time_period
+        self.clv = None
+        self.query_es = QueryES(port=port, host=host)
+        self.path = temporary_export_path
+        self.temp_csv_file = join(temporary_export_path, "temp_data.csv")
+        self.temp_folder = join(temporary_export_path, "temp_purchase_amount_results", "*.csv")
+        self.results = join(temporary_export_path, "results_*.csv")
+        self.clv_fields = ["client", "session_start_date", "payment_amount", "dimension"]
+        self.result_query = "session_start_date == session_start_date and data_type != 'actual'"
+        self.result_columns = ['session_start_date', 'client', 'payment_amount']
+        self.clv_predictions = pd.DataFrame()
+        self.client_dimensions = pd.DataFrame()
+        self.collect_reports = Reports()
+        self.has_prev_clv = False
+
+    def get_customers_dimesions(self, _data):
+        _data["dimension"] = _data["dimension"].fillna("main")
+        if list(_data['dimension'].unique()) != 1:
+            _data_pv = _data.groupby(["client", "dimension"]).agg({"session_start_date": "count"}).reset_index().rename(
+                columns={"session_start_date": "order_count"})
+            _data_pv['order_seq_num'] = _data_pv.sort_values(
+                by=["client", "dimension", "order_count"], ascending=False).groupby(["client"]).cumcount() + 1
+            _data_pv = _data_pv.query("order_seq_num == 1")
+            _data_pv = _data_pv[["client", "dimension"]].groupby("client").agg({"dimension": "first"}).reset_index()
+            self.client_dimensions = pd.merge(_data.drop('dimension', axis=1), _data_pv, on='client', how='left')
+
+    def get_orders_data(self, end_date):
+        """
+        Purchased orders are collected from Orders Index.
+        Session_start_date, client, payment_amount are needed for initializing CLv Prediciton.
+        :param end_date: final date to start clv prediction
+        :return:
+        """
+        self.query_es = QueryES(port=self.port, host=self.host)
+        self.query_es.date_queries_builder({"session_start_date": {"lt": end_date}})
+        self.query_es.query_builder(fields=self.clv_fields,
+                                    boolean_queries=[{"term": {"actions.purchased": True}}])
+        _data = pd.DataFrame(self.query_es.get_data_from_es())
+        _data['session_start_date'] = _data['session_start_date'].apply(lambda x: str(convert_to_date(x)))
+        self.get_customers_dimesions(_data)
+        _data.query("session_start_date == session_start_date").to_csv(self.temp_csv_file, index=False)
+
+    def check_for_previous_clv_prediction(self):
+        """
+        check if the last clv prediction is applied in 7 days.
+        """
+        try:
+
+            _reports = self.collect_reports.collect_reports(self.port, self.host, 'main',
+                                                            query={"report_name": "clv_prediction"})
+            if len(_reports) != 0:
+                try:
+                    _directory = pd.read_sql("SELECT * FROM es_connection", con).to_dict('records')[-1]['directory']
+                    print(_directory)
+                    clv_report = pd.read_csv(join(_directory, "build_in_reports", "main", "daily_clv.csv"))
+                    if len(clv_report) != 0:
+                        clv_report = clv_report.query("data_type == 'prediction'")
+                        clv_report['date'] = clv_report['date'].apply(lambda x: convert_to_day(x))
+                        last_transaction_date = min(list(clv_report['date']))
+                        print(last_transaction_date)
+                except Exception as e:
+                    print(e)
+                    _reports['report_date'] = _reports['report_date'].apply(lambda x: convert_to_date(x))
+                    last_transaction_date = max(list(_reports['report_date']))
+
+                if abs(last_transaction_date - current_date_to_day()).total_seconds() / 60 / 60 / 24 < 7:
+                    print("clv predictions will be updated!!!!!")
+                    self.has_prev_clv = True
+        except: pass
+
+    def insert_into_reports_index(self, clv_predictions, time_period, date=None, index='orders'):
+        """
+        via query_es.py, each report can be inserted into the reports index with the given format.
+        {"id": unique report id,
+         "report_date": date or current date,
+         "report_name": "clv_prediction",
+         "index": "main",
+         "report_types": {"time_period": weekly, monthly, daily },
+         "data": segments.fillna(0.0).to_dict("records") -  dataframe to list of dictionary
+         }
+         !!! null values are assigned to 0.
+
+        :param segments: data set, data frame
+        :param index: dimensionality of data index orders_location1 ;  dimension = location1
+        """
+
+        iteration = int(len(clv_predictions) / default_es_bulk_insert_chunk_size) + 1
+        print("number of bulk iteration :", iteration)
+        print("bulk size :", default_es_bulk_insert_chunk_size)
+        for i in range(iteration):
+            _start = i * default_es_bulk_insert_chunk_size
+            _end = ((i+1) * default_es_bulk_insert_chunk_size) if i != (iteration - 1) else len(clv_predictions) + 1
+            _clv_predictions = clv_predictions.iloc[_start:_end]
+            _list_of_obj = [{"id": np.random.randint(200000000),
+                             "report_date": current_date_to_day().isoformat() if date is None else convert_to_day(
+                                 date).isoformat(),
+                             "report_name": "clv_prediction",
+                             "index": get_index_group(index),
+                             "report_types": {"time_period": time_period, "partition": i},
+                             "data": _clv_predictions.fillna(0.0).to_dict("records")}]
+            self.query_es.insert_data_to_index(_list_of_obj, index='reports')
+
+    def convert_time_period(self, period):
+        """
+        clv_prediction library takes time-period as week, day, month.
+        This converts the general time-period into the clv_prediction form.
+        :param period: weekly or daily or month.
+        :return: week or day or month
+        """
+        if period == 'weekly':
+            return 'week'
+        if period == 'daily':
+            return 'day'
+        if period == 'monthly':
+            return 'month'
+        if period == '6 months':
+            return '6*month'
+
+    def remove_temp_files(self):
+        """
+        Removing temp_data.csv, .csv files in temp_purchase_amount_results and results*.csv files
+        """
+        # remove temp_data.csv
+        try:
+            os.unlink(self.temp_csv_file)
+        except Exception as e:
+            print("no file is observed!!!")
+
+        # remove results*.csv files
+        for f in glob.glob(self.results):
+            print(f)
+            try:
+                os.unlink(f)
+            except Exception as e:
+                print(e)
+                print("no file is observed!!!")
+
+        # remove .csv files in temp_purchase_amount_results
+        for f in glob.glob(self.temp_folder):
+            try:
+                os.unlink(f)
+            except Exception as e:
+                print(e)
+                print("no file is observed!!!")
+
+    def execute_clv(self, start_date, job='train_prediction', time_period='6 months'):
+        """
+        1. train clv prediction models
+           For more details about models pls check; https://github.com/caglanakpinar/clv_prediction
+        2. predict users of feature payment amount via using built models.
+        3. use 'train_prediction' for the job argument which allows us to train and predict the results.
+           If time period is weekly and if there is a stored .json and .h5 trained models in last 7 days,
+           skips the train process and uses the latest trained model.
+        4. Each model and stored in the directory at elasticsearch folder. After it is used, it is removed.
+        5. If last stored clv prediction is applied before 7 days, it is not triggered for prediction again.
+
+        :param start_date: date of start for clv prediction
+        :param job: train or prediction
+        :param time_period: weekly, daily, monthly
+        """
+        start_date = str(current_date_to_day())[0:10] if start_date is None else start_date
+        self.check_for_previous_clv_prediction()
+        if not self.has_prev_clv:
+            self.get_orders_data(end_date=start_date)
+            self.clv = CLV(customer_indicator="client",
+                           amount_indicator="payment_amount",
+                           job=job,
+                           date=start_date,
+                           data_source='csv',
+                           data_query_path=self.temp_csv_file,
+                           time_period=self.convert_time_period(time_period),
+                           time_indicator="session_start_date",
+                           export_path=self.path)
+            self.clv.clv_prediction()
+            self.clv_predictions = self.clv.get_result_data().query(self.result_query)[self.result_columns]
+            self.clv_predictions = self.clv_predictions.rename(columns={"session_start_date": "date"})
+            self.clv_predictions['date'] = self.clv_predictions['date'].apply(lambda x: convert_to_iso_format(x))
+            self.add_dimensions()
+            self.clv_predictions = self.clv_predictions[['dimension', 'date', 'payment_amount', 'client']]
+            self.insert_into_reports_index(self.clv_predictions,
+                                           time_period=time_period,
+                                           date=start_date,
+                                           index=self.order_index)
+            del self.clv
+            del self.clv_predictions
+            self.clv = None
+            self.clv_predictions = pd.DataFrame()
+            self.remove_temp_files()
+
+    def add_dimensions(self):
+        _prediction_start_date = min(self.clv_predictions['date'])
+        if len(self.client_dimensions) != 0:
+            _clv_predictions_newcomers = self.clv_predictions.query("client == 'newcomers'")
+            print(_clv_predictions_newcomers.head())
+            self.clv_predictions = pd.merge(self.clv_predictions.query("client != 'newcomers'"),
+                                            self.client_dimensions[['client', 'dimension']], on="client", how="left")
+            # add newcomers of dimensions
+            _dimension_user_ratios = self.clv_predictions.groupby('dimension').agg(
+                {'client': lambda x: len(np.unique(x))}).reset_index().rename(columns={'client': 'ratio'})
+            _dimension_user_ratios['ratio'] = _dimension_user_ratios['ratio'] / len(
+                self.clv_predictions['client'].unique())
+            _clv_predictions_newcomers = _clv_predictions_newcomers.groupby("date").agg(
+                {"payment_amount": "sum"}).reset_index().rename(columns={'payment_amount': 'pa'})
+            _clv_predictions_newcomers['client'] = 'newcomers'
+            dfs = []
+            for _ratio in list(_dimension_user_ratios['ratio']):
+                _clv_predictions_newcomers['payment_amount'] = _clv_predictions_newcomers['pa'] * _ratio
+                dfs.append(_clv_predictions_newcomers)
+            self.clv_predictions = pd.concat([self.clv_predictions.query("client != 'newcomers'")] + dfs)
+        else: self.clv_predictions['dimension'] = 'main'
+        self.clv_predictions['dimension'] = self.clv_predictions['dimension'].apply(lambda x: str(x))
+        self.clv_predictions = self.clv_predictions.query("date > @_prediction_start_date")
+
+    def fetch(self, end_date=None, time_period='weekly'):
+        """
+        Collect CLV Prediction results with the given date.
+        :param end_date: final date to start clv prediction
+        :param time_period: weekly or daily or month.
+        :return:
+        """
+
+        boolean_queries, date_queries = [], []
+        boolean_queries = [{"term": {"report_name": "clv_prediction"}},
+                           {"term": {"report_types.time_period": time_period}},
+                           {"term": {"index": get_index_group(self.order_index)}}]
+
+        if end_date is not None:
+            date_queries = [{"range": {"report_date": {"lt": convert_to_iso_format(end_date)}}}]
+
+        self.query_es = QueryES(port=self.port,
+                                host=self.host)
+        self.query_es.query_builder(fields=None, _source=True,
+                                    date_queries=date_queries,
+                                    boolean_queries=boolean_queries)
+        _res = self.query_es.get_data_from_es(index="reports")
+        _data = pd.DataFrame()
+        if len(_res) != 0:
+            _data = pd.DataFrame(_res[0]['_source']['data'])
+            if end_date is not None:
+                _data[time_period] = _data["session_start_date"].apply(lambda x: convert_to_date(x))
+        return _data

customeranalytics/ml_process/customer_segmentation.py

@@ -0,0 +1,354 @@
+import numpy as np
+import pandas as pd
+import sys, os, inspect
+import h2o
+from h2o.estimators.kmeans import H2OKMeansEstimator
+from h2o.grid.grid_search import H2OGridSearch
+
+
+currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
+parentdir = os.path.dirname(currentdir)
+sys.path.insert(0, parentdir)
+
+from customeranalytics.configs import default_es_port, default_es_host
+from customeranalytics.utils import *
+from customeranalytics.data_storage_configurations.query_es import QueryES
+from customeranalytics.exploratory_analysis import query_exploratory_analysis, ea_configs
+
+
+class CustomerSegmentation:
+    """
+    Customer Segmentation is one of the crucial problems for Businesses that are mostly engaging with their buyers.
+    This relationship for some reason might differ from one customer to another one.
+    By using RFM (Recency - Frequency Monetary) each customer can be segmented by using Clustering Algorithms.
+
+    - Data Manipulation:
+        - It has been already applied on rfm.py. Collect data from reports index.
+        - Segment Each Metric individually by using KMeans with k = 5.
+          Why is k decided as 5?
+          - It is related to the Segmentation rule after assigning the segmentation process.
+          - There, Each cluster number named to a human-readable name rather than 1, 2, ..5.
+
+        - In order to optimize parameters of KMeans (except k). GRidSearch is applied.
+        - After Clustering Process has been done for R, F, and M, each cluster of average value sorted and
+          cluster labels (1, 2, 3, 4, 5) are reassigned in order. label 5 will be the highest, 1 will be the lowest.
+        - At the end, the user is the label in human-readable format;
+            "champions": {'r': [5], 'f': [5], 'm': [5]},
+            "loyal_customers": {'r': [3, 4, 5], 'f': [3, 4, 5], 'm': [5, 4, 3, 3]},
+            "potential loyalist": {'r': [5, 4, 3], 'f': [5, 4, 3], 'm': [4, 3, 2]},
+            "new customers": {'r': [5], 'f': [2, 1], 'm': [1, 2, 3, 4, 5]},
+            "promising": {'r': [3, 4], 'f': [1, 2], 'm': [1, 2]},
+            "need attention": {'r': [3, 2], 'f': [3, 2], 'm': [3, 2]},
+            "about to sleep": {'r': [3, 4], 'f': [1, 2], 'm': [1, 2]},
+            "at risk": {'r': [2], 'f': [5, 4, 3], 'm': [5, 4, 3]},
+            "can`t lose them": {'r': [1, 2], 'f': [5], 'm': [5]},
+            "hibernating": {'r': [2, 3], 'f': [2], 'm': [2]},
+            "lost": {'r': [1], 'f': [1, 2, 3, 4, 5], 'm': [1, 2, 3, 4, 5]}}
+
+    """
+    def __init__(self,
+                 host=None,
+                 port=None,
+                 download_index='downloads',
+                 order_index='orders'):
+        """
+        ******* ******** *****
+        Dimensional Customer Segmentation:
+        Descriptive Statistics must be created individually for dimensions.
+        For instance, the Data set contains locations dimension.
+        In this case, each location of 'orders' and 'downloads' indexes must be created individually.
+        by using 'download_index' and 'order_index' dimension can be assigned in order to create the Segmentations
+
+        download_index; downloads_location1 this will be the location dimension of
+                        parameters in order to query downloads indexes; 'location1'.
+        download_index; orders_location1 this will be the location dimension of
+                        parameters in order to query orders indexes; 'location1'.
+        ******* ******** *****
+        !!!
+
+        :param host: elasticsearch host
+        :param port: elasticsearch port
+        :param download_index: elasticsearch port
+        :param order_index: elasticsearch port
+        """
+        self.port = default_es_port if port is None else port
+        self.host = default_es_host if host is None else host
+        self.download_index = download_index
+        self.order_index = order_index
+        self.query_es = QueryES(port=port, host=host)
+        self.rfm = pd.DataFrame()
+        self.METRICS = ['recency', 'frequency', 'monetary']
+        self.METRIC_VALUES = {'recency': ['recency', 'rec', 'r'],
+                              'frequency': ['frequency', 'freq', 'f'],
+                              'monetary': ['monetary', 'mon', 'm']
+                              }
+        self.Z_VALUES = [-1.96, 1.96]  # 95% OF CONFIDENCE
+        self.clustering_parameters = {'split_ratio': 0.8, 'seed': 1234, 'k': 5,
+                                      'hyper_params': {'standardize': [True, False],
+                                                       'init': ['Random', 'Furthest', 'PlusPlus']},
+                                      'search_criteria': {'strategy': "Cartesian"}
+                                      }
+        self.accepted_minimum_prob = 0.05
+        self.frequency_segments = {}
+        self.recency_segments = {}
+        self.monetary_segments = {}
+        self.customer_segments = {"champions": {'r': [5], 'f': [5], 'm': [5]},
+                                  "loyal customers": {'r': [4, 5], 'f': [4, 5], 'm': [5, 4, 3, 2, 1]},
+                                  "potential loyalist": {'r': [5, 4, 3], 'f': [5, 4, 3], 'm': [4, 3, 2]},
+                                  "new customers": {'r': [5], 'f': [2, 1], 'm': [1, 2, 3, 4, 5]},
+                                  "promising": {'r': [3, 4], 'f': [1, 2], 'm': [1, 2]},
+                                  "need attention": {'r': [3, 2], 'f': [3, 2], 'm': [3, 2]},
+                                  "about to sleep": {'r': [3, 4], 'f': [1, 2], 'm': [1, 2]},
+                                  "at risk": {'r': [2], 'f': [5, 4, 3], 'm': [5, 4, 3]},
+                                  "can`t lose them": {'r': [1, 2], 'f': [5], 'm': [5]},
+                                  "hibernating": {'r': [2, 3], 'f': [2], 'm': [2]},
+                                  "lost": {'r': [1], 'f': [1, 2, 3, 4, 5], 'm': [1, 2, 3, 4, 5]}}
+        self.segments_numerics = {}
+        self.detected_segments = []
+        self.insert_columns = ["client", "recency_segment", "frequency_segment",
+                               "monetary_segment", "segments", "segments_numeric"]
+
+    def get_rfm(self, date):
+        """
+        RFM values for segmentation can be fetched from the reports index with related dimensions.
+        """
+        ea_configs['rfm']['order_index'] = self.order_index
+        _total_cols, _counter = 0, 0
+        while len(set(self.rfm.columns) & set(self.METRICS)) != 3:
+            self.rfm = query_exploratory_analysis(ea_configs, {"start_date": date}, "rfm")
+            if _counter >= 10:
+                _total_cols = 3
+            else:
+                _total_cols = len(set(self.rfm.columns) & set(self.METRICS))
+            _counter += 1
+
+    def segmentation(self, data, metric):
+        """
+        Each RFM segmentation will be k = 1,.. , 5
+        Step of Clustering Process;
+            1.  Convert rfm data-frame into the H2O data-frame
+            2.  Split data for train and validation.
+            3.  Create KMeans process.
+            4.  Create GridSearch for KMeans parameters. These are;
+                a.  standardize;  standardize the numeric columns to have a mean of zero and unit variance. Standardization is highly recommended;
+                b.  split ratio; train validation split ratio, the lower ratio can decrease Underfitting Problem
+                c.  init; 'Random', 'Furthest', 'PlusPlus'
+                d.  search criteria - strategy;
+        These segments are later on CustomerSegmentation will be sorted according to theirs.
+        :param data: rfm data-frame with columns recency or monetary or frequency
+        :param metric: recency or monetary or frequency
+        :return:
+        """
+        h2o.init()  # initialize the H2O environment
+        rfm_data = h2o.H2OFrame(data)  # convert pandas data-frame to H2O data-frame
+        # split train and test data
+        train, valid = rfm_data.split_frame(ratios=[self.clustering_parameters['split_ratio']],
+                                            seed=self.clustering_parameters['seed'])
+        # build KMeans algorithm
+        rfm_kmeans = H2OKMeansEstimator(k=self.clustering_parameters['k'],
+                                        seed=self.clustering_parameters['seed'],
+                                        max_iterations=int(len(data) / 2))
+        rfm_kmeans.train(x=metric, training_frame=train, validation_frame=valid)
+        # grid search for KMeans parameters
+        grid = H2OGridSearch(model=rfm_kmeans, hyper_params=self.clustering_parameters['hyper_params'],
+                             search_criteria=self.clustering_parameters['search_criteria'])
+        # train using the grid
+        grid.train(x=metric, training_frame=train, validation_frame=valid)
+        # sort the grid models by total within cluster sum-of-square error.
+        sorted_grid = grid.get_grid(sort_by='tot_withinss', decreasing=False)
+        prediction = sorted_grid[0].predict(rfm_data)
+        data = rfm_data.concat(prediction, axis=1)[[metric, 'predict']].as_data_frame(use_pandas=True)
+        data = data.rename(columns={'predict': metric + '_segment'})
+        # assign segments for each metric (Recency - Monetary  - Frequency)
+        data[metric + '_segment'] = data[metric + '_segment'].apply(lambda x: x + 1)
+        return data
+
+    def current_day_r_f_m_clustering(self):
+        """
+        combine segmented values to the recent rfm data frame. After concatenation;
+
+                  client	frequency	recency	monetary	recency_segment	frequency_segment	monetary_segment
+        6115	u_174194	0.0	        1663	32.8500	    2	            2	                3
+        10060	u_220840	1.0	        342	    22.4700	    4	            2	                4
+        """
+        for metric in self.METRICS:
+            self.rfm = pd.concat([self.rfm, self.segmentation(self.rfm[[metric]], metric).drop(metric, axis=1)], axis=1)
+
+    def get_frequency_segments(self):
+        """
+        Each segmented label is assigned as unsorted format.
+        Here finding the cluster centroid for frequency clusters (it is calculated via average at this process).
+        e.g. centroids - labels pairs  7.2 - 5, 4.2 - 2, 30.2 - 4, 1.3 - 3, 44 - 1,
+             sorted_labels;
+             previous_labels  sorted_labels centroids
+             3                1             1.3
+             2                2             4.2
+             5                3             7.2
+             4                4             30.2
+             1                5             44
+        """
+        for i in self.rfm.groupby("frequency_segment").agg(
+                                {"frequency": "mean"}).reset_index().sort_values(
+                                by='frequency', ascending=True).reset_index(drop=True).reset_index().to_dict('records'):
+            self.frequency_segments[i['frequency_segment']] = 5 - i['index']
+
+    def get_recency_segments(self):
+        """
+        Each segmented label is assigned as unsorted format.
+        Here finding the cluster centroid for recency clusters (it is calculated via average at this process).
+        e.g. centroids - labels pairs  7.2 - 5, 4.2 - 2, 30.2 - 4, 1.3 - 3, 44 - 1,
+             sorted_labels;
+             previous_labels  sorted_labels centroids
+             3                1             1.3
+             2                2             4.2
+             5                3             7.2
+             4                4             30.2
+             1                5             44
+
+        """
+        for i in self.rfm.groupby("recency_segment").agg(
+                                {"recency": "mean"}).reset_index().sort_values(
+                                by='recency', ascending=True).reset_index(drop=True).reset_index().to_dict('records'):
+            self.recency_segments[i['recency_segment']] = 5 - i['index']
+
+    def get_segments_numeric(self):
+        """
+        format; {"champions": 0, ..... , "can`t lose them": 8}
+        """
+        self.segments_numerics = {s[0]: s[1] for s in zip(list(self.customer_segments.keys()) + ['others'],
+                                                          list(range(len(list(self.customer_segments.keys()))+1)))}
+
+    def get_monetary_segments(self):
+        """
+        Each segmented label is assigned as unsorted format.
+        Here finding the cluster centroid for monetary clusters (it is calculated via average at this process).
+        e.g. centroids - labels pairs  7.2 - 5, 4.2 - 2, 30.2 - 4, 1.3 - 3, 44 - 1,
+             sorted_labels;
+             previous_labels  sorted_labels centroids
+             3                1             1.3
+             2                2             4.2
+             5                3             7.2
+             4                4             30.2
+             1                5             44
+
+        """
+        for i in self.rfm.groupby("monetary_segment").agg(
+                                {"monetary": "mean"}).reset_index().sort_values(
+                                by='monetary', ascending=True).reset_index(drop=True).reset_index().to_dict('records'):
+            self.monetary_segments[i['monetary_segment']] = 5 - i['index']
+
+    def combine_segments(self):
+        """
+        apply sorted segments
+        """
+        self.rfm['frequency_segment'] = self.rfm['frequency_segment'].apply(lambda x: self.frequency_segments[x])
+        self.rfm['recency_segment'] = self.rfm['recency_segment'].apply(lambda x: self.recency_segments[x])
+        self.rfm['monetary_segment'] = self.rfm['monetary_segment'].apply(lambda x: self.monetary_segments[x])
+
+    def detect_customer_segments(self):
+        """
+        Human Readable Form Of Segments;
+        After the segmentation process, There will be 5 * 5 * 5 = 125 individual segments will be created.
+        e.g. 1 - 3 - 5 (r - f - m)
+        Now, another topic is how segmentation outputs can be converted to clearly understandable segments.
+        By searching on articles about RFM segmentation, one the usual segments are;
+            - champions
+            - loyal_customers
+            - potential loyalist
+            - new customers
+            - promising
+            - need attention
+            - about to sleep
+            - at risk
+            - can`t lose them
+            - hibernating
+            - lost
+        Each segment of label ranges are assigned to the variable 'self.customer_segments'.
+        """
+        total_clients = list(self.rfm['client'].unique())
+        for s in self.customer_segments:
+            _segment_clients = list(self.rfm[(self.rfm['recency_segment'].isin(self.customer_segments[s]['r'])) &
+                                             (self.rfm['frequency_segment'].isin(self.customer_segments[s]['f'])) &
+                                             (self.rfm['monetary_segment'].isin(self.customer_segments[s]['m'])) & (
+                                              self.rfm['client'].isin(total_clients))]['client'])
+            self.detected_segments += list(zip(_segment_clients, (len(_segment_clients) * [s])))
+            total_clients = list(set(total_clients) - set(_segment_clients))
+
+    def insert_into_reports_index(self, segments, date=None, index='orders'):
+        """
+        via query_es.py, each report can be inserted into the reports index with the given format.
+        {"id": unique report id,
+         "report_date": date or current date,
+         "report_name": "segmentation",
+         "index": "main",
+         "report_types": {},
+         "data": segments.fillna(0.0).to_dict("records") -  dataframe to list of dictionary
+         }
+         !!! null values are assigned to 0.
+
+        :param segments: data set, data frame
+        :param index: dimensionality of data index orders_location1 ;  dimension = location1
+        """
+        list_of_obj = [{"id": np.random.randint(200000000),
+                        "report_date": current_date_to_day().isoformat() if date is None else date,
+                        "report_name": "segmentation",
+                        "index": get_index_group(index),
+                        "report_types": {},
+                        "data": segments.fillna(0.0).to_dict("records")}]
+        self.query_es.insert_data_to_index(list_of_obj, index='reports')
+
+    def execute_customer_segment(self, start_date=None):
+        """
+        Process of the Customer Segmentation
+            1.  fetch rfm calculated values from reports index.
+            2.  create KMeans Segmentation.
+            3.  sort labels related to centroids for R, F, and M individually.
+            4.  combine sorted labels.
+            6.  assign human-readable segments instead of 1, 2, ..5 labels.
+            7.  insert human-readable segments and number labels of each segment into the reports index.
+                reports index must be from right dimensional, related orders_index.
+
+        :param start_date: date of reporting date
+        :return:
+        """
+        self.get_rfm(date=start_date)
+        self.current_day_r_f_m_clustering()
+        self.get_frequency_segments()
+        self.get_recency_segments()
+        self.get_monetary_segments()
+        self.combine_segments()
+        self.detect_customer_segments()
+        self.get_segments_numeric()
+
+        self.rfm = pd.merge(self.rfm,
+                            pd.DataFrame(self.detected_segments).rename(columns={0: "client", 1: "segments"}),
+                            on='client', how='left')
+        self.rfm['segments'] = self.rfm['segments'].fillna('others')
+        self.rfm['segments_numeric'] = self.rfm['segments'].apply(lambda x: self.segments_numerics[x])
+
+        self.insert_into_reports_index(self.rfm[self.insert_columns], date=start_date, index=self.order_index)
+        h2o.shutdown(prompt=False)
+
+    def fetch(self, start_date=None):
+        """
+        Collect Customer segmentation results with the given date.
+        :param start_date: customer_segmentation first date
+        :return:
+        """
+        boolean_queries, date_queries = [], []
+        boolean_queries = [{"term": {"report_name": "segmentation"}},
+                           {"term": {"index": get_index_group(self.order_index)}}]
+
+        if start_date is not None:
+            date_queries = [{"range": {"report_date": {"gte": convert_to_iso_format(start_date)}}}]
+
+        self.query_es = QueryES(port=self.port,
+                                host=self.host)
+        self.query_es.query_builder(fields=None, _source=True,
+                                    date_queries=date_queries,
+                                    boolean_queries=boolean_queries)
+        _res = self.query_es.get_data_from_es(index="reports")
+        _data = pd.DataFrame()
+        if len(_res) != 0:
+            _data = pd.DataFrame(_res[-1]['_source']['data'])
+        return _data