1. Reproducir el procedimiento desarrollado por el profesor, en un solo programa.

1. # import libraries
2. import pandas as pd
3. import numpy as np
4. import sys
5. import matplotlib.pyplot as plt
6. from sklearn.cluster import KMeans

7. def order_cluster(cluster_field_name, target_field_name,df,ascending):

8. new_cluster_field_name = 'new_' + cluster_field_name
9. df_new = df.groupby(cluster_field_name)[target_field_name].mean().reset_index()
10. df_new =
df_new.sort_values(by=target_field_name,ascending=ascending).reset_index(drop=True)
11. df_new['index'] = df_new.index
12. df_final = pd.merge(df,df_new[[cluster_field_name,'index']], on=cluster_field_name)
13. df_final = df_final.drop([cluster_field_name],axis=1)
14. df_final = df_final.rename(columns={"index":cluster_field_name})
15. return df_final

16. # lee los datos y crea

17. #Asigna a tx_data toda las filas y columnas del archivo customer_segmenation
18. tx_data = pd.read_csv('./data/customer_segmentation.csv', encoding='cp1252')
19. # convirtiendo el tipo de dato del campo InvoiceDate de string a datetime (fecha mas hora)
20. tx_data['InvoiceDate'] = pd.to_datetime(tx_data['InvoiceDate'])
21. # creando el campo InvoiceYearMonth para reporte y visualizacion al final de la columna
22. tx_data['InvoiceYearMonth'] = tx_data['InvoiceDate'].map(lambda date: 100*date.year +
date.month)
23. # se trabaja solo con los datos de 'United Kingdom'
24. tx_uk = tx_data.query("Country=='United Kingdom'").reset_index(drop=True)

25. # creando una dataframe generico para capturar el CustomerID y nuevos escores de
segmentación# creando una dataframe generico para capturar el CustomerID y nuevos
escores de segmentación, cada fila muestra un CustomerID distinto
26. tx_user = pd.DataFrame(tx_data['CustomerID'].unique())
27. #Asigna en la primera fila el titulo de la columna--
28. tx_user.columns = ['CustomerID']

29. # 3. Recency ----------------------

30. # calcula la fecha máxima de compra por cada cliente de united kingdom, ademas coloca
los titulos a cada columna y la numeracion a la izquierda que era de origen
31. #ordenado por CustomerID
32. tx_max_purchase = tx_uk.groupby('CustomerID').InvoiceDate.max().reset_index()
33. #Cambia los titulos de las columnas a CustomerID y MaxPurchaseDate
34. tx_max_purchase.columns = ['CustomerID','MaxPurchaseDate']
35. # Compara la fecha de la última transacción por cada cliente, resta la fecha maxima total
menos la fecha de compra de cada cliente
36. tx_max_purchase['Recency'] = (tx_max_purchase['MaxPurchaseDate'].max() -
tx_max_purchase['MaxPurchaseDate']).dt.days
37. #Une la tabla tx_user con la tabla tx_max_purchase de manera que empezamos por la
columna CustomerID de la tabla tx_user
38. #Se muestra las columnas CustomerID y Recency
39. tx_user = pd.merge(tx_user, tx_max_purchase[['CustomerID','Recency']],
on='CustomerID')

40. #Eliminando de la tabla tx_user aquellos clientes que se encuentren por encima del 98% su
recency
41. #tx_user = tx_user[tx_user['Recency']<tx_user['Recency'].quantile(0.98)]
42. #print(tx_user)

43. # construye 4 grupos para frecuencia y adiciona a tx_user

44. kmeans = KMeans(n_clusters=4)
45. #Ingresa unna columna donde se indica el numero de grupo asignado
46. tx_user['RecencyCluster'] = kmeans.fit_predict(tx_user[['Recency']])
47. # ordena los grupos por RecencyCluster, despues por Recency de la tabla tx_user, y al final
cambia el RecencyCluster en forma descendente debido a false
48. tx_user = order_cluster('RecencyCluster', 'Recency',tx_user,False)

49. # 4. Frecuencia
50. #Asigna a la dataframe tx_frequency la cantidad de veces que cada cliente de united
kingdom ha realizado una transaccion por dia, ordenado por CustomerID
51. tx_frequency = tx_uk.groupby('CustomerID').InvoiceDate.count().reset_index()
52. #Cambia el nombre de las columnas a CustomerID y Frequency
53. tx_frequency.columns = ['CustomerID','Frequency']
54. # une ta tabla tx_user con la tabla tx_frequency cuyo punto en comun es CustomerID,
ordenado por CustomerID de tx_user
55. tx_user = pd.merge(tx_user, tx_frequency, on='CustomerID')
56. #Eliminando de la tabla tx_user aquellos clientes que se encuentren por encima del 98% su
frecuencia
57. #tx_user = tx_user[tx_user['Frequency']<tx_user['Frequency'].quantile(0.98)]
58. # construye 4 grupos para frecuencia y adiciona a tx_user
59. kmeans=KMeans(n_clusters=4)
60. #Ingresa unna columna FrequencyCluster a la tabla tx_user donde se indica el numero de
grupo asignado
61. tx_user['FrequencyCluster']=kmeans.fit_predict(tx_user[['Frequency']])
62. # ordena los grupos por FrequencyCluster, despues por Frequency de la tabla tx_user, y al
final cambia la Frequency en forma ascendete debido al true
63. tx_user = order_cluster('FrequencyCluster', 'Frequency', tx_user, True )

64. # 5. Revenue
65. # calcula el ingreso por cada cliente, multiplicando el precio unitario por la cantidad
66. tx_uk['Revenue'] = tx_uk['UnitPrice'] * tx_uk['Quantity']
67. #Agrupa la columna CustomerID con la columna ingresos agrupados por cliente y la suma
de sus ingresos del pais United Kingdom
68. tx_revenue = tx_uk.groupby('CustomerID').Revenue.sum().reset_index()
69. # pasa estos datos a tx_user, combinando tx_user con tx_revenue siguiendo el orden de
tx_user por CustomerID
70. tx_user = pd.merge(tx_user, tx_revenue, on='CustomerID')
71. #Eliminando de la tabla tx_user aquellos clientes que se encuentren por encima del 98% su
revenue
72. #tx_user = tx_user[tx_user['Revenue']<tx_user['Revenue'].quantile(0.98)]

73. # construye 4 grupos para frecuencia y adiciona a tx_user

74. kmeans = KMeans(n_clusters=4)
75. #Ingresa unna columna RevenueCluster a la tabla tx_user donde se indica el numero de
grupo asignado
76. tx_user['RevenueCluster'] = kmeans.fit_predict(tx_user[['Revenue']])
77. # ordena los grupos por RevenueCluster, despues por Revenue de la tabla tx_user, y al
final cambia la columna Revenue en forma ascendete debido al true
78. tx_user = order_cluster('RevenueCluster', 'Revenue',tx_user,True)
79. #imprime la tabla tx_user agrupados segun las agrupaciones de los ingresos
80. print(tx_user.head().to_string())

81. # se construye 4 grupos para los clusters identificados

82. kmeans = KMeans(n_clusters=4)
83. #Ingresa unna columna WCCluster a la tabla tx_user donde se agrupa segun su grupo de
recency, grupo de frecuencia y grupo de ingreso
84. #print(tx_user[['RecencyCluster', 'FrequencyCluster','RevenueCluster']])

85. tx_user['VVCCluster'] = kmeans.fit_predict(tx_user[['RecencyCluster',

'FrequencyCluster','RevenueCluster']])
86. #Imprime la tabla tx_user donde se observa los 05 primeros clientes de la lista , que se ve
su recency, frequency y revenue y su grupo respectivo ademas se agrego una columna de
WCCluster
87. print(tx_user.head().to_string())
88. #Imprime segun el grupo de WCCluster su descripcion de cada columna Recency cluster,
FrequencyCluster y RevenueCluster
89. print(tx_user.groupby('VVCCluster')[['RecencyCluster',
'FrequencyCluster','RevenueCluster']].describe().to_string())

90. #Realiza el ploteo de la ventana figura

91. fig = plt.figure()

92. #Realiza un garfico tridimensional para que se pueda signar los datos
93. ax = fig.add_subplot(111, projection='3d')

94. #Realiza la asignacion a x de los valores de RecencyCluster

95. x = np.array(tx_user['RecencyCluster'])
96. #Realiza la asignacion a x de los valores de FrequencyCluster
97. y = np.array(tx_user['FrequencyCluster'])
98. #Realiza la asignacion a x de los valores de RevenueCluster
99. z = np.array(tx_user['RevenueCluster'])

100. #Coloca el titulo del grafico tridimensional

101. ax.set_title("Valor de Vida de los Clientes")
102. #Coloca la etiqueta del eje RecencyCluster
103. ax.set_xlabel("RecencyCluster")
104. #Coloca la etiqueta del eje FrequencyCluster
105. ax.set_ylabel("FrequencyCluster")
106. #Coloca la etiqueta del eje RevenueCluster
107. ax.set_zlabel("RevenueCluster")

108. #Realiza la colocacion de los datos tx_user[WCCluster] en el grafico tridimensional,

donde aquellos puntos donde tiene mas coincidencia se va a visualizar con mayor color y
encerrado en cuadrado
109. ax.scatter(x,y,z, marker="s", c=tx_user["VVCCluster"], s=40, cmap="RdBu")

110. plt.show()

CustomerID Recency RecencyCluster Frequency FrequencyCluster Revenue

RevenueCluster
0 17850.0 301 0 312 1 5288.63 1
1 14688.0 7 3 359 1 5107.38 1
2 13767.0 1 3 399 1 16945.71 1
3 15513.0 30 3 314 1 14520.08 1
4 14849.0 21 3 392 1 7904.28 1
CustomerID Recency RecencyCluster Frequency FrequencyCluster Revenue
RevenueCluster VVCCluster
0 17850.0 301 0 312 1 5288.63 1 1
1 14688.0 7 3 359 1 5107.38 1 0
2 13767.0 1 3 399 1 16945.71 1 0
3 15513.0 30 3 314 1 14520.08 1 0
4 14849.0 21 3 392 1 7904.28 1 0
RecencyCluster FrequencyCluster
RevenueCluster
 count mean std min 25% 50% 75% max count mean std
min 25% 50% 75% max count mean std min 25% 50% 75% max
VVCCluster
0 422.0 2.990521 0.097011 2.0 3.0 3.0 3.0 3.0 422.0 1.049763
0.308066 0.0 1.0 1.0 1.0 3.0 422.0 0.516588 0.638034 0.0 0.0 0.0 1.0 3.0
1 1046.0 0.543021 0.498384 0.0 0.0 1.0 1.0 1.0 1046.0 0.007648
0.087160 0.0 0.0 0.0 0.0 1.0 1046.0 0.005736 0.075556 0.0 0.0 0.0 0.0 1.0
2 950.0 2.000000 0.000000 2.0 2.0 2.0 2.0 2.0 950.0 0.032632
0.177764 0.0 0.0 0.0 0.0 1.0 950.0 0.009474 0.096922 0.0 0.0 0.0 0.0 1.0
3 1532.0 3.000000 0.000000 3.0 3.0 3.0 3.0 3.0 1532.0 0.000000
0.000000 0.0 0.0 0.0 0.0 0.0 1532.0 0.039817 0.195593 0.0 0.0 0.0 0.0 1.0

2. Explique paso a paso, qué es lo que está haciendo el procedimiento, apóyese de la

impresión de los resultados, intermedio.

1. # import libraries
2. import pandas as pd
3. import numpy as np
4. import sys
5. import matplotlib.pyplot as plt
6. from sklearn.cluster import KMeans
7.
8. def order_cluster(cluster_field_name, target_field_name,df,ascending):
9. new_cluster_field_name = 'new_' + cluster_field_name
10. df_new = df.groupby(cluster_field_name)[target_field_name].mean().reset_index()
11. df_new =
df_new.sort_values(by=target_field_name,ascending=ascending).reset_index(drop=True)
12. df_new['index'] = df_new.index
13. df_final = pd.merge(df,df_new[[cluster_field_name,'index']], on=cluster_field_name)
14. df_final = df_final.drop([cluster_field_name],axis=1)
15. df_final = df_final.rename(columns={"index":cluster_field_name})
16. return df_final
17.
18. # lee los datos y crea
19. #Asigna a tx_data toda las filas y columnas del archivo customer_segmenation
20. tx_data = pd.read_csv('./data/customer_segmentation.csv', encoding='cp1252')
21. # convirtiendo el tipo de dato del campo InvoiceDate de string a datetime (fecha mas
hora)
22. tx_data['InvoiceDate'] = pd.to_datetime(tx_data['InvoiceDate'])
23. # creando el campo InvoiceYearMonth para reporte y visualizacion al final de la columna
24. tx_data['InvoiceYearMonth'] = tx_data['InvoiceDate'].map(lambda date: 100*date.year +
date.month)
25. # se trabaja solo con los datos de 'United Kingdom'
26. tx_uk = tx_data.query("Country=='United Kingdom'").reset_index(drop=True)
27.
28. # creando una dataframe generico para capturar el CustomerID y nuevos escores de
segmentación
29. # creando una dataframe generico para capturar el CustomerID y nuevos escores de
segmentación, cada fila muestra un CustomerID distinto
30. tx_user = pd.DataFrame(tx_data['CustomerID'].unique())
31. #Asigna en la primera fila el titulo de la columna--
32. tx_user.columns = ['CustomerID']
33. # 3. Recency ----------------------
34. # calcula la fecha máxima de compra por cada cliente de united kingdom, ademas coloca
los titulos a cada columna y la numeracion a la izquierda que era de origen
35. #ordenado por CustomerID
36. tx_max_purchase = tx_uk.groupby('CustomerID').InvoiceDate.max().reset_index()
37. #Cambia los titulos de las columnas a CustomerID y MaxPurchaseDate
38. tx_max_purchase.columns = ['CustomerID','MaxPurchaseDate']
39. # Compara la fecha de la última transacción por cada cliente, resta la fecha maxima total
menos la fecha de compra de cada cliente
40. tx_max_purchase['Recency'] = (tx_max_purchase['MaxPurchaseDate'].max() -
tx_max_purchase['MaxPurchaseDate']).dt.days
41. #Une la tabla tx_user con la tabla tx_max_purchase de manera que empezamos por la
columna CustomerID de la tabla tx_user
42. #Se muestra las columnas CustomerID y Recency
43. tx_user = pd.merge(tx_user, tx_max_purchase[['CustomerID','Recency']],
on='CustomerID')
44.
45.
46. #Eliminando de la tabla tx_user aquellos clientes que se encuentren por encima del 98%
su recency
47. #tx_user = tx_user[tx_user['Recency']<tx_user['Recency'].quantile(0.98)]
48. #print(tx_user)
49.
50. # construye 4 grupos para frecuencia y adiciona a tx_user
51. kmeans = KMeans(n_clusters=4)
52. #Ingresa unna columna donde se indica el numero de grupo asignado
53. tx_user['RecencyCluster'] = kmeans.fit_predict(tx_user[['Recency']])
54. # ordena los grupos por RecencyCluster, despues por Recency de la tabla tx_user, y al
final cambia el RecencyCluster en forma descendente debido a false
55. tx_user = order_cluster('RecencyCluster', 'Recency',tx_user,False)
56.
57.
58. # 4. Frecuencia
59. #Asigna a la dataframe tx_frequency la cantidad de veces que cada cliente de united
kingdom ha realizado una transaccion por dia, ordenado por CustomerID
60. tx_frequency = tx_uk.groupby('CustomerID').InvoiceDate.count().reset_index()
61. #Cambia el nombre de las columnas a CustomerID y Frequency
62. tx_frequency.columns = ['CustomerID','Frequency']
63. # une la tabla tx_user con la tabla tx_frequency cuyo punto en comun es CustomerID,
ordenado por CustomerID de tx_user
64. tx_user = pd.merge(tx_user, tx_frequency, on='CustomerID')
65. #Eliminando de la tabla tx_user aquellos clientes que se encuentren por encima del 98%
su frecuencia
66. #tx_user = tx_user[tx_user['Frequency']<tx_user['Frequency'].quantile(0.98)]
67. # construye 4 grupos para frecuencia y adiciona a tx_user
68. kmeans=KMeans(n_clusters=4)
69. #Ingresa unna columna FrequencyCluster a la tabla tx_user donde se indica el numero de
grupo asignado
70. tx_user['FrequencyCluster']=kmeans.fit_predict(tx_user[['Frequency']])
71. # ordena los grupos por FrequencyCluster, despues por Frequency de la tabla tx_user, y
al final cambia la Frequency en forma ascendete debido al true
72. tx_user = order_cluster('FrequencyCluster', 'Frequency', tx_user, True )
73.
74.
75. # 5. Revenue
76. # calcula el ingreso por cada cliente, multiplicando el precio unitario por la cantidad
77. tx_uk['Revenue'] = tx_uk['UnitPrice'] * tx_uk['Quantity']
78. #Agrupa la columna CustomerID con la columna ingresos agrupados por cliente y la suma
de sus ingresos del pais United Kingdom
79. tx_revenue = tx_uk.groupby('CustomerID').Revenue.sum().reset_index()
80. # pasa estos datos a tx_user, combinando tx_user con tx_revenue siguiendo el orden de
tx_user por CustomerID
81. tx_user = pd.merge(tx_user, tx_revenue, on='CustomerID')
82. #Eliminando de la tabla tx_user aquellos clientes que se encuentren por encima del 98%
su revenue
83. #tx_user = tx_user[tx_user['Revenue']<tx_user['Revenue'].quantile(0.98)]
84.
85. # construye 4 grupos para frecuencia y adiciona a tx_user
86. kmeans = KMeans(n_clusters=4)
87. #Ingresa unna columna RevenueCluster a la tabla tx_user donde se indica el numero de
grupo asignado
88. tx_user['RevenueCluster'] = kmeans.fit_predict(tx_user[['Revenue']])
89. # ordena los grupos por RevenueCluster, despues por Revenue de la tabla tx_user, y al
final cambia la columna Revenue en forma ascendete debido al true
90. tx_user = order_cluster('RevenueCluster', 'Revenue',tx_user,True)
91. #imprime la tabla tx_user agrupados segun las agrupaciones de los ingresos
92. print(tx_user.head().to_string())
93.
94. # se construye 4 grupos para los clusters identificados
95. kmeans = KMeans(n_clusters=4)
96. #Ingresa unna columna WCCluster a la tabla tx_user donde se agrupa segun su grupo de
recency, grupo de frecuencia y grupo de ingreso
97. #print(tx_user[['RecencyCluster', 'FrequencyCluster','RevenueCluster']])
98.
99. tx_user['VVCCluster'] = kmeans.fit_predict(tx_user[['RecencyCluster',
'FrequencyCluster','RevenueCluster']])
100. #Imprime la tabla tx_user donde se observa los 05 primeros clientes de la lista , que
se ve su recency, frequency y revenue y su grupo respectivo ademas se agrego una
columna de WCCluster
101. print(tx_user.head().to_string())
102. #Imprime segun el grupo de WCCluster su descripcion de cada columna Recency
cluster, FrequencyCluster y RevenueCluster
103. print(tx_user.groupby('VVCCluster')[['RecencyCluster',
'FrequencyCluster','RevenueCluster']].describe().to_string())
104.
105.
106.
107. #Realiza el ploteo de la ventana figura
108. fig = plt.figure()
109.
110. #Realiza un garfico tridimensional para que se pueda signar los datos
111. ax = fig.add_subplot(111, projection='3d')
112.
113. #Realiza la asignacion a x de los valores de RecencyCluster
114. x = np.array(tx_user['RecencyCluster'])
115. #Realiza la asignacion a x de los valores de FrequencyCluster
116. y = np.array(tx_user['FrequencyCluster'])
117. #Realiza la asignacion a x de los valores de RevenueCluster
118. z = np.array(tx_user['RevenueCluster'])
119.
120. #Coloca el titulo del grafico tridimensional
121. ax.set_title("Valor de Vida de los Clientes")
122. #Coloca la etiqueta del eje RecencyCluster
123. ax.set_xlabel("RecencyCluster")
124. #Coloca la etiqueta del eje FrequencyCluster
125. ax.set_ylabel("FrequencyCluster")
126. #Coloca la etiqueta del eje RevenueCluster
127. ax.set_zlabel("RevenueCluster")
128.
129.
130. #Realiza la colocacion de los datos tx_user[WCCluster] en el grafico tridimensional,
donde aquellos puntos donde tiene mas coincidencia se va a visualizar con mayor color y
encerrado en cuadrado
131. ax.scatter(x,y,z, marker="s", c=tx_user["VVCCluster"], s=40, cmap="RdBu")
132.
133. plt.show()

3. Eliminar las instrucciones que sirven para imprimir los resultados.

1. # import libraries
2. import pandas as pd
3. import numpy as np
4. import sys
5. import matplotlib.pyplot as plt
6. from sklearn.cluster import KMeans
7.
8. def order_cluster(cluster_field_name, target_field_name,df,ascending):
9. new_cluster_field_name = 'new_' + cluster_field_name
10. df_new = df.groupby(cluster_field_name)[target_field_name].mean().reset_index()
11. df_new =
df_new.sort_values(by=target_field_name,ascending=ascending).reset_index(drop=True)
12. df_new['index'] = df_new.index
13. df_final = pd.merge(df,df_new[[cluster_field_name,'index']], on=cluster_field_name)
14. df_final = df_final.drop([cluster_field_name],axis=1)
15. df_final = df_final.rename(columns={"index":cluster_field_name})
16. return df_final
17.
18. # lee los datos y crea
19. #Asigna a tx_data toda las filas y columnas del archivo customer_segmenation
20. tx_data = pd.read_csv('./data/customer_segmentation.csv', encoding='cp1252')
21. # convirtiendo el tipo de dato del campo InvoiceDate de string a datetime (fecha mas
hora)
22. tx_data['InvoiceDate'] = pd.to_datetime(tx_data['InvoiceDate'])
23. # creando el campo InvoiceYearMonth para reporte y visualizacion al final de la columna
24. tx_data['InvoiceYearMonth'] = tx_data['InvoiceDate'].map(lambda date: 100*date.year +
date.month)
25. # se trabaja solo con los datos de 'United Kingdom'
26. tx_uk = tx_data.query("Country=='United Kingdom'").reset_index(drop=True)
27.
28. # creando una dataframe generico para capturar el CustomerID y nuevos escores de
segmentación
29. # creando una dataframe generico para capturar el CustomerID y nuevos escores de
segmentación, cada fila muestra un CustomerID distinto
30. tx_user = pd.DataFrame(tx_data['CustomerID'].unique())
31. #Asigna en la primera fila el titulo de la columna--
32. tx_user.columns = ['CustomerID']
33. # 3. Recency ----------------------
34. # calcula la fecha máxima de compra por cada cliente de united kingdom, ademas coloca
los titulos a cada columna y la numeracion a la izquierda que era de origen
35. #ordenado por CustomerID
36. tx_max_purchase = tx_uk.groupby('CustomerID').InvoiceDate.max().reset_index()
37. #Cambia los titulos de las columnas a CustomerID y MaxPurchaseDate
38. tx_max_purchase.columns = ['CustomerID','MaxPurchaseDate']
39. # Compara la fecha de la última transacción por cada cliente, resta la fecha maxima total
menos la fecha de compra de cada cliente
40. tx_max_purchase['Recency'] = (tx_max_purchase['MaxPurchaseDate'].max() -
tx_max_purchase['MaxPurchaseDate']).dt.days
41. #Une la tabla tx_user con la tabla tx_max_purchase de manera que empezamos por la
columna CustomerID de la tabla tx_user
42. #Se muestra las columnas CustomerID y Recency
43. tx_user = pd.merge(tx_user, tx_max_purchase[['CustomerID','Recency']],
on='CustomerID')
44.
45.
46. #Eliminando de la tabla tx_user aquellos clientes que se encuentren por encima del 98%
su recency
47. #tx_user = tx_user[tx_user['Recency']<tx_user['Recency'].quantile(0.98)]
48. #print(tx_user)
49.
50. # construye 4 grupos para frecuencia y adiciona a tx_user
51. kmeans = KMeans(n_clusters=4)
52. #Ingresa unna columna donde se indica el numero de grupo asignado
53. tx_user['RecencyCluster'] = kmeans.fit_predict(tx_user[['Recency']])
54. # ordena los grupos por RecencyCluster, despues por Recency de la tabla tx_user, y al
final cambia el RecencyCluster en forma descendente debido a false
55. tx_user = order_cluster('RecencyCluster', 'Recency',tx_user,False)
56.
57.
58. # 4. Frecuencia
59. #Asigna a la dataframe tx_frequency la cantidad de veces que cada cliente de united
kingdom ha realizado una transaccion por dia, ordenado por CustomerID
60. tx_frequency = tx_uk.groupby('CustomerID').InvoiceDate.count().reset_index()
61. #Cambia el nombre de las columnas a CustomerID y Frequency
62. tx_frequency.columns = ['CustomerID','Frequency']
63. # une la tabla tx_user con la tabla tx_frequency cuyo punto en comun es CustomerID,
ordenado por CustomerID de tx_user
64. tx_user = pd.merge(tx_user, tx_frequency, on='CustomerID')
65. #Eliminando de la tabla tx_user aquellos clientes que se encuentren por encima del 98%
su frecuencia
66. #tx_user = tx_user[tx_user['Frequency']<tx_user['Frequency'].quantile(0.98)]
67. # construye 4 grupos para frecuencia y adiciona a tx_user
68. kmeans=KMeans(n_clusters=4)
69. #Ingresa unna columna FrequencyCluster a la tabla tx_user donde se indica el numero de
grupo asignado
70. tx_user['FrequencyCluster']=kmeans.fit_predict(tx_user[['Frequency']])
71. # ordena los grupos por FrequencyCluster, despues por Frequency de la tabla tx_user, y
al final cambia la Frequency en forma ascendete debido al true
72. tx_user = order_cluster('FrequencyCluster', 'Frequency', tx_user, True )
73.
74.
75. # 5. Revenue
76. # calcula el ingreso por cada cliente, multiplicando el precio unitario por la cantidad
77. tx_uk['Revenue'] = tx_uk['UnitPrice'] * tx_uk['Quantity']
78. #Agrupa la columna CustomerID con la columna ingresos agrupados por cliente y la suma
de sus ingresos del pais United Kingdom
79. tx_revenue = tx_uk.groupby('CustomerID').Revenue.sum().reset_index()
80. # pasa estos datos a tx_user, combinando tx_user con tx_revenue siguiendo el orden de
tx_user por CustomerID
81. tx_user = pd.merge(tx_user, tx_revenue, on='CustomerID')
82. #Eliminando de la tabla tx_user aquellos clientes que se encuentren por encima del 98%
su revenue
83. #tx_user = tx_user[tx_user['Revenue']<tx_user['Revenue'].quantile(0.98)]
84.
85. # construye 4 grupos para frecuencia y adiciona a tx_user
86. kmeans = KMeans(n_clusters=4)
87. #Ingresa unna columna RevenueCluster a la tabla tx_user donde se indica el numero de
grupo asignado
88. tx_user['RevenueCluster'] = kmeans.fit_predict(tx_user[['Revenue']])
89. # ordena los grupos por RevenueCluster, despues por Revenue de la tabla tx_user, y al
final cambia la columna Revenue en forma ascendete debido al true
90. tx_user = order_cluster('RevenueCluster', 'Revenue',tx_user,True)
91. #imprime la tabla tx_user agrupados segun las agrupaciones de los ingresos
92. #print(tx_user.head().to_string())
93.
94. # se construye 4 grupos para los clusters identificados
95. kmeans = KMeans(n_clusters=4)
96. #Ingresa unna columna WCCluster a la tabla tx_user donde se agrupa segun su grupo de
recency, grupo de frecuencia y grupo de ingreso
97. #print(tx_user[['RecencyCluster', 'FrequencyCluster','RevenueCluster']])
98.
99. tx_user['VVCCluster'] = kmeans.fit_predict(tx_user[['RecencyCluster',
'FrequencyCluster','RevenueCluster']])
100. #Imprime la tabla tx_user donde se observa los 05 primeros clientes de la lista , que
se ve su recency, frequency y revenue y su grupo respectivo ademas se agrego una
columna de WCCluster
101. #print(tx_user.head().to_string())
102. #Imprime segun el grupo de WCCluster su descripcion de cada columna Recency
cluster, FrequencyCluster y RevenueCluster
103. #print(tx_user.groupby('VVCCluster')[['RecencyCluster',
'FrequencyCluster','RevenueCluster']].describe().to_string())
104.
105.
106.
107. #Realiza el ploteo de la ventana figura
108. fig = plt.figure()
109.
110. #Realiza un garfico tridimensional para que se pueda signar los datos
111. ax = fig.add_subplot(111, projection='3d')
112.
113. #Realiza la asignacion a x de los valores de RecencyCluster
114. x = np.array(tx_user['RecencyCluster'])
115. #Realiza la asignacion a x de los valores de FrequencyCluster
116. y = np.array(tx_user['FrequencyCluster'])
117. #Realiza la asignacion a x de los valores de RevenueCluster
118. z = np.array(tx_user['RevenueCluster'])
119.
120. #Coloca el titulo del grafico tridimensional
121. ax.set_title("Valor de Vida de los Clientes")
122. #Coloca la etiqueta del eje RecencyCluster
123. ax.set_xlabel("RecencyCluster")
124. #Coloca la etiqueta del eje FrequencyCluster
125. ax.set_ylabel("FrequencyCluster")
126. #Coloca la etiqueta del eje RevenueCluster
127. ax.set_zlabel("RevenueCluster")
128.
129.
130. #Realiza la colocacion de los datos tx_user[WCCluster] en el grafico tridimensional,
donde aquellos puntos donde tiene mas coincidencia se va a visualizar con mayor color y
encerrado en cuadrado
131. ax.scatter(x,y,z, marker="s", c=tx_user["VVCCluster"], s=40, cmap="RdBu")
132.
133. plt.show()

4. Analizar la influencia de los valores extremos en la formación de los grupos.

tx_user = tx_user[tx_user['Revenue']<tx_user['Revenue'].quantile(0.98)]
 Antes de Eliminar de la tabla tx_user aquellos clientes que se encuentren por encima del
98% su revenue

Después de Eliminar de la tabla tx_user aquellos clientes que se encuentren por encima del
98% su revenue (Aumenta la dispersión en el eje de revenue)

5. Para el ejercicio 10, determine la cantidad de grupos VVC apropiado.

Un buen grupo es aquel que tiene sus integrantes cohesionados.

Agregamos estas acciones para ordenar VVCCluster

#Ordenando tx_user en funcion de CustomerID y de VVCluster
tx_user = order_cluster('CustomerID', 'VVCCluster',tx_user,True)
#Imprime tx_user agrupandolo por VVCCluster y CustomerID colocando su descripcion
print(tx_user.groupby('VVCCluster')['CustomerID'].describe().to_string())
Grupo de 02

count mean std min 25% 50% 75% max

VVCCluster
0 2904.0 1451.5 838.456916 0.0 725.75 1451.5 2177.25 2903.0
1 1046.0 3426.5 302.098494 2904.0 3165.25 3426.5 3687.75 3949.0

Grupo de 03

count mean std min 25% 50% 75% max

VVCCluster
0 1950.0 974.5 563.060832 0.0 487.25 974.5 1461.75 1949.0
1 1046.0 2472.5 302.098494 1950.0 2211.25 2472.5 2733.75 2995.0
2 954.0 3472.5 275.540378 2996.0 3234.25 3472.5 3710.75 3949.0

Grupo de 04

count mean std min 25% 50% 75% max

VVCCluster
0 1532.0 765.5 442.394620 0.0 382.75 765.5 1148.25 1531.0
1 1046.0 2054.5 302.098494 1532.0 1793.25 2054.5 2315.75 2577.0
2 950.0 3052.5 274.385677 2578.0 2815.25 3052.5 3289.75 3527.0
3 422.0 3738.5 121.965159 3528.0 3633.25 3738.5 3843.75 3949.0

Grupo de 05

count mean std min 25% 50% 75% max

VVCCluster
0 1532.0 765.5 442.394620 0.0 382.75 765.5 1148.25 1531.0
1 568.0 1815.5 164.111751 1532.0 1673.75 1815.5 1957.25 2099.0
2 950.0 2574.5 274.385677 2100.0 2337.25 2574.5 2811.75 3049.0
3 478.0 3288.5 138.130976 3050.0 3169.25 3288.5 3407.75 3527.0
4 422.0 3738.5 121.965159 3528.0 3633.25 3738.5 3843.75 3949.0

Grupo de 06

count mean std min 25% 50% 75% max

VVCCluster
0 266.0 132.5 76.931788 0.0 66.25 132.5 198.75 265.0
1 568.0 549.5 164.111751 266.0 407.75 549.5 691.25 833.0
2 1532.0 1599.5 442.394620 834.0 1216.75 1599.5 1982.25 2365.0
3 919.0 2825.0 265.436747 2366.0 2595.50 2825.0 3054.50 3284.0
4 478.0 3523.5 138.130976 3285.0 3404.25 3523.5 3642.75 3762.0
5 187.0 3856.0 54.126395 3763.0 3809.50 3856.0 3902.50 3949.0
Grupo de 07

count mean std min 25% 50% 75% max

VVCCluster
0 950.0 474.5 274.385677 0.0 237.25 474.5 711.75 949.0
1 1471.0 1685.0 424.785436 950.0 1317.50 1685.0 2052.50 2420.0
2 478.0 2659.5 138.130976 2421.0 2540.25 2659.5 2778.75 2898.0
3 180.0 2988.5 52.105662 2899.0 2943.75 2988.5 3033.25 3078.0
4 568.0 3362.5 164.111751 3079.0 3220.75 3362.5 3504.25 3646.0
5 235.0 3764.0 67.982841 3647.0 3705.50 3764.0 3822.50 3881.0
6 68.0 3915.5 19.773720 3882.0 3898.75 3915.5 3932.25 3949.0

Grupo de 08

count mean std min 25% 50% 75% max

VVCCluster
0 1471.0 735.0 424.785436 0.0 367.50 735.0 1102.50 1470.0
1 568.0 1754.5 164.111751 1471.0 1612.75 1754.5 1896.25 2038.0
2 919.0 2498.0 265.436747 2039.0 2268.50 2498.0 2727.50 2957.0
3 478.0 3196.5 138.130976 2958.0 3077.25 3196.5 3315.75 3435.0
4 235.0 3553.0 67.982841 3436.0 3494.50 3553.0 3611.50 3670.0
5 180.0 3760.5 52.105662 3671.0 3715.75 3760.5 3805.25 3850.0
6 68.0 3884.5 19.773720 3851.0 3867.75 3884.5 3901.25 3918.0
7 31.0 3934.0 9.092121 3919.0 3926.50 3934.0 3941.50 3949.0
Grupo de 09

count mean std min 25% 50% 75% max

VVCCluster
0 919.0 459.0 265.436747 0.0 229.50 459.0 688.50 918.0
1 1471.0 1654.0 424.785436 919.0 1286.50 1654.0 2021.50 2389.0
2 568.0 2673.5 164.111751 2390.0 2531.75 2673.5 2815.25 2957.0
3 157.0 3036.0 45.466105 2958.0 2997.00 3036.0 3075.00 3114.0
4 478.0 3353.5 138.130976 3115.0 3234.25 3353.5 3472.75 3592.0
5 235.0 3710.0 67.982841 3593.0 3651.50 3710.0 3768.50 3827.0
6 68.0 3861.5 19.773720 3828.0 3844.75 3861.5 3878.25 3895.0
7 23.0 3907.0 6.782330 3896.0 3901.50 3907.0 3912.50 3918.0
8 31.0 3934.0 9.092121 3919.0 3926.50 3934.0 3941.50 3949.0

Grupo de 10

count mean std min 25% 50% 75% max

VVCCluster
0 1471.0 735.0 424.785436 0.0 367.50 735.0 1102.50 1470.0
1 568.0 1754.5 164.111751 1471.0 1612.75 1754.5 1896.25 2038.0
2 919.0 2498.0 265.436747 2039.0 2268.50 2498.0 2727.50 2957.0
3 478.0 3196.5 138.130976 2958.0 3077.25 3196.5 3315.75 3435.0
4 236.0 3553.5 68.271517 3436.0 3494.75 3553.5 3612.25 3671.0
5 21.0 3682.0 6.204837 3672.0 3677.00 3682.0 3687.00 3692.0
6 142.0 3763.5 41.135953 3693.0 3728.25 3763.5 3798.75 3834.0
7 61.0 3865.0 17.752934 3835.0 3850.00 3865.0 3880.00 3895.0
8 31.0 3911.0 9.092121 3896.0 3903.50 3911.0 3918.50 3926.0
9 23.0 3938.0 6.782330 3927.0 3932.50 3938.0 3943.50 3949.0
 Se puede elegir el grupo 06 o el grupo 07, ya que presenta mayor dispersión y mayor
promedio de clientes.

6. Haciendo un análisis manual, determine el orden de los grupos VVC, es decir qué grupo
VVC es el de mayor rendimiento y cuál el de menor rendimiento (se trata de identificar los
criterios).
El grupo VVC esta formado por los criterios de Recency, Frequency y Revenue, demanera que
el que tenga mayor rendimiento será aquel que tenga menor Recency (Fecha de la ultima
transacción de los clientes menos la fecha de transacción de cada cliente), mayor Frequency
(cantidad de veces que va cada cliente), y mayor revenue(suma de ingresos de cada cliente),
cuyo grado de importancia seria primero Revenue, después Frequency y por ultimo Recency
Se toma el de grupo de 06 por tener mayor dispersión y se ordena los grupos de VVCCluster en
función a los revenue, y se elige aquellos que tenga mayor revenue como mayor rendimiento y
aquellos que tengan menor revenue menor rendimiento

Mayor rendimiento
Grupo 05 VVCCluster
Promedio 3786 Revenue
Promedio 317 Frequency
Promedio 14 Recency

Menor rendimiento
Grupo 0 VVCCluster
Promedio 123.5 Revenue
Promedio 451 Frequency
Promedio 123.5 Recency

count mean std min 25% 50% 75% max count mean std
min 25% 50% 75% max count mean std min 25% 50% 75% max
VVCCluster
0 248.0 11.229839 13.325252 0.0 2.00 7.0 16.0 86.0 248.0 451.713710
722.969446 4.0 173.5 298.0 452.00 7983.0 248.0 123.500000 71.735626 0.0 61.75
123.5 185.25 247.0
1 570.0 184.436842 31.856230 131.0 156.00 184.0 211.0 244.0 570.0 34.861404
44.400479 1.0 10.0 22.0 40.75 548.0 570.0 559.164912 284.451251 248.0 390.25
532.5 674.75 3204.0
2 1471.0 19.223657 13.180469 0.0 8.00 18.0 30.0 47.0 1471.0 64.579878
47.664548 1.0 26.0 53.0 97.00 190.0 1471.0 1537.843644 426.949963 801.0 1169.50
1537.0 1905.50 3064.0
3 948.0 77.609705 22.762434 48.0 59.00 72.0 93.0 130.0 948.0 51.995781
54.268642 1.0 15.0 32.0 69.00 378.0 948.0 2732.456751 284.184071 942.0 2498.75
2736.5 2972.25 3210.0
4 478.0 304.393305 41.183489 245.0 266.25 300.0 336.0 373.0 478.0 23.374477
29.688388 1.0 7.0 15.0 28.75 312.0 478.0 3415.280335 198.470728 2263.0 3312.25
3430.5 3548.75 3668.0
5 235.0 14.080851 12.446718 0.0 3.50 10.0 23.0 47.0 235.0 317.106383
140.129555 191.0 217.0 264.0 367.50 981.0 235.0 3786.000000 67.982841 3669.0
3727.50 3786.0 3844.50 3903.0

# se construye 4 grupos para los clusters identificados

kmeans = KMeans(n_clusters=6)
#Ingresa unna columna WCCluster a la tabla tx_user donde se agrupa segun su grupo de
recency, grupo de frecuencia y grupo de ingreso
#print(tx_user[['RecencyCluster', 'FrequencyCluster','RevenueCluster']])

tx_user['VVCCluster'] = kmeans.fit_predict(tx_user[['RecencyCluster',
'FrequencyCluster','RevenueCluster']])
#Imprime la tabla tx_user donde se observa los 05 primeros clientes de la lista , que se ve su
recency, frequency y revenue y su grupo respectivo ademas se agrego una columna de
WCCluster
print(tx_user.head().to_string())
#Imprime segun el grupo de WCCluster su descripcion de cada columna Recency cluster,
FrequencyCluster y RevenueCluster
print(tx_user.groupby('VVCCluster')[['RecencyCluster',
'FrequencyCluster','RevenueCluster']].describe().to_string())

#Ordenando tx_user en funcion de CustomerID y de VVCluster

#tx_user = order_cluster('CustomerID', 'VVCCluster',tx_user,True)
#Imprime tx_user agrupandolo por VVCCluster y CustomerID colocando su descripcion
#print(tx_user.groupby('VVCCluster')['CustomerID'].describe().to_string())

tx_user = order_cluster('Revenue', 'VVCCluster',tx_user,True)

#print(tx_user.groupby('VVCCluster')['Revenue'].describe().to_string())
print(tx_user.groupby('VVCCluster')[['Recency', 'Frequency','Revenue']].describe().to_string())

7. Diga cuántos clientes tiene la empresa en cada grupo VVC.

En cada grupoVVCCluster tiene
Grupo 0 : 248 Clientes
Grupo 1: 570 Clientes
Grupo 2: 1471 Clientes
Grupo 3: 948 Clientes
Grupo 4: 478 Clientes
Grupo 5: 235 Clientes

count mean std min 25% 50% 75% max count mean std
min 25% 50% 75% max count mean std min 25% 50% 75% max
VVCCluster
0 248.0 11.229839 13.325252 0.0 2.00 7.0 16.0 86.0 248.0 451.713710
722.969446 4.0 173.5 298.0 452.00 7983.0 248.0 123.500000 71.735626 0.0 61.75
123.5 185.25 247.0
1 570.0 184.436842 31.856230 131.0 156.00 184.0 211.0 244.0 570.0 34.861404
44.400479 1.0 10.0 22.0 40.75 548.0 570.0 559.164912 284.451251 248.0 390.25
532.5 674.75 3204.0
2 1471.0 19.223657 13.180469 0.0 8.00 18.0 30.0 47.0 1471.0 64.579878
47.664548 1.0 26.0 53.0 97.00 190.0 1471.0 1537.843644 426.949963 801.0 1169.50
1537.0 1905.50 3064.0
3 948.0 77.609705 22.762434 48.0 59.00 72.0 93.0 130.0 948.0 51.995781
54.268642 1.0 15.0 32.0 69.00 378.0 948.0 2732.456751 284.184071 942.0 2498.75
2736.5 2972.25 3210.0
4 478.0 304.393305 41.183489 245.0 266.25 300.0 336.0 373.0 478.0 23.374477
29.688388 1.0 7.0 15.0 28.75 312.0 478.0 3415.280335 198.470728 2263.0 3312.25
3430.5 3548.75 3668.0
5 235.0 14.080851 12.446718 0.0 3.50 10.0 23.0 47.0 235.0 317.106383
140.129555 191.0 217.0 264.0 367.50 981.0 235.0 3786.000000 67.982841 3669.0
3727.50 3786.0 3844.50 3903.0

# import libraries
import pandas as pd
import numpy as np
import sys
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

def order_cluster(cluster_field_name, target_field_name,df,ascending):

new_cluster_field_name = 'new_' + cluster_field_name
df_new = df.groupby(cluster_field_name)[target_field_name].mean().reset_index()
df_new =
df_new.sort_values(by=target_field_name,ascending=ascending).reset_index(drop=True)
df_new['index'] = df_new.index
df_final = pd.merge(df,df_new[[cluster_field_name,'index']], on=cluster_field_name)
df_final = df_final.drop([cluster_field_name],axis=1)
df_final = df_final.rename(columns={"index":cluster_field_name})
return df_final

# lee los datos y crea

#Asigna a tx_data toda las filas y columnas del archivo customer_segmenation
tx_data = pd.read_csv('./data/customer_segmentation.csv', encoding='cp1252')
# convirtiendo el tipo de dato del campo InvoiceDate de string a datetime (fecha mas hora)
tx_data['InvoiceDate'] = pd.to_datetime(tx_data['InvoiceDate'])
# creando el campo InvoiceYearMonth para reporte y visualizacion al final de la columna
tx_data['InvoiceYearMonth'] = tx_data['InvoiceDate'].map(lambda date: 100*date.year +
date.month)
# se trabaja solo con los datos de 'United Kingdom'
tx_uk = tx_data.query("Country=='United Kingdom'").reset_index(drop=True)

# creando una dataframe generico para capturar el CustomerID y nuevos escores de

segmentación# creando una dataframe generico para capturar el CustomerID y nuevos escores
de segmentación, cada fila muestra un CustomerID distinto
tx_user = pd.DataFrame(tx_data['CustomerID'].unique())
#Asigna en la primera fila el titulo de la columna--
tx_user.columns = ['CustomerID']

# 3. Recency ----------------------
# calcula la fecha máxima de compra por cada cliente de united kingdom, ademas coloca los
titulos a cada columna y la numeracion a la izquierda que era de origen
#ordenado por CustomerID
tx_max_purchase = tx_uk.groupby('CustomerID').InvoiceDate.max().reset_index()
#Cambia los titulos de las columnas a CustomerID y MaxPurchaseDate
tx_max_purchase.columns = ['CustomerID','MaxPurchaseDate']
# Compara la fecha de la última transacción por cada cliente, resta la fecha maxima total
menos la fecha de compra de cada cliente
tx_max_purchase['Recency'] = (tx_max_purchase['MaxPurchaseDate'].max() -
tx_max_purchase['MaxPurchaseDate']).dt.days
#Une la tabla tx_user con la tabla tx_max_purchase de manera que empezamos por la
columna CustomerID de la tabla tx_user
#Se muestra las columnas CustomerID y Recency
tx_user = pd.merge(tx_user, tx_max_purchase[['CustomerID','Recency']], on='CustomerID')

#Eliminando de la tabla tx_user aquellos clientes que se encuentren por encima del 98% su
recency
#tx_user = tx_user[tx_user['Recency']<tx_user['Recency'].quantile(0.98)]
#print(tx_user)

# construye 4 grupos para frecuencia y adiciona a tx_user

kmeans = KMeans(n_clusters=4)
#Ingresa unna columna donde se indica el numero de grupo asignado
tx_user['RecencyCluster'] = kmeans.fit_predict(tx_user[['Recency']])
# ordena los grupos por RecencyCluster, despues por Recency de la tabla tx_user, y al final
cambia el RecencyCluster en forma descendente debido a false
tx_user = order_cluster('RecencyCluster', 'Recency',tx_user,False)

# 4. Frecuencia
#Asigna a la dataframe tx_frequency la cantidad de veces que cada cliente de united kingdom
ha realizado una transaccion por dia, ordenado por CustomerID
tx_frequency = tx_uk.groupby('CustomerID').InvoiceDate.count().reset_index()
#Cambia el nombre de las columnas a CustomerID y Frequency
tx_frequency.columns = ['CustomerID','Frequency']
# une ta tabla tx_user con la tabla tx_frequency cuyo punto en comun es CustomerID,
ordenado por CustomerID de tx_user
tx_user = pd.merge(tx_user, tx_frequency, on='CustomerID')
#Eliminando de la tabla tx_user aquellos clientes que se encuentren por encima del 98% su
frecuencia
#tx_user = tx_user[tx_user['Frequency']<tx_user['Frequency'].quantile(0.98)]
# construye 4 grupos para frecuencia y adiciona a tx_user
kmeans=KMeans(n_clusters=4)
#Ingresa unna columna FrequencyCluster a la tabla tx_user donde se indica el numero de
grupo asignado
tx_user['FrequencyCluster']=kmeans.fit_predict(tx_user[['Frequency']])
# ordena los grupos por FrequencyCluster, despues por Frequency de la tabla tx_user, y al final
cambia la Frequency en forma ascendete debido al true
tx_user = order_cluster('FrequencyCluster', 'Frequency', tx_user, True )

# 5. Revenue
# calcula el ingreso por cada cliente, multiplicando el precio unitario por la cantidad
tx_uk['Revenue'] = tx_uk['UnitPrice'] * tx_uk['Quantity']
#Agrupa la columna CustomerID con la columna ingresos agrupados por cliente y la suma de
sus ingresos del pais United Kingdom
tx_revenue = tx_uk.groupby('CustomerID').Revenue.sum().reset_index()
# pasa estos datos a tx_user, combinando tx_user con tx_revenue siguiendo el orden de
tx_user por CustomerID
tx_user = pd.merge(tx_user, tx_revenue, on='CustomerID')
#Eliminando de la tabla tx_user aquellos clientes que se encuentren por encima del 98% su
revenue
#tx_user = tx_user[tx_user['Revenue']<tx_user['Revenue'].quantile(0.98)]

# construye 4 grupos para frecuencia y adiciona a tx_user

kmeans = KMeans(n_clusters=4)
#Ingresa unna columna RevenueCluster a la tabla tx_user donde se indica el numero de grupo
asignado
tx_user['RevenueCluster'] = kmeans.fit_predict(tx_user[['Revenue']])
# ordena los grupos por RevenueCluster, despues por Revenue de la tabla tx_user, y al final
cambia la columna Revenue en forma ascendete debido al true
tx_user = order_cluster('RevenueCluster', 'Revenue',tx_user,True)
#imprime la tabla tx_user agrupados segun las agrupaciones de los ingresos
print(tx_user.head().to_string())

# se construye 4 grupos para los clusters identificados

kmeans = KMeans(n_clusters=6)
#Ingresa unna columna WCCluster a la tabla tx_user donde se agrupa segun su grupo de
recency, grupo de frecuencia y grupo de ingreso
#print(tx_user[['RecencyCluster', 'FrequencyCluster','RevenueCluster']])

tx_user['VVCCluster'] = kmeans.fit_predict(tx_user[['RecencyCluster',
'FrequencyCluster','RevenueCluster']])
#Imprime la tabla tx_user donde se observa los 05 primeros clientes de la lista , que se ve su
recency, frequency y revenue y su grupo respectivo ademas se agrego una columna de
WCCluster
print(tx_user.head().to_string())
#Imprime segun el grupo de WCCluster su descripcion de cada columna Recency cluster,
FrequencyCluster y RevenueCluster
print(tx_user.groupby('VVCCluster')[['RecencyCluster',
'FrequencyCluster','RevenueCluster']].describe().to_string())

#Ordenando tx_user en funcion de CustomerID y de VVCluster

#tx_user = order_cluster('CustomerID', 'VVCCluster',tx_user,True)
#Imprime tx_user agrupandolo por VVCCluster y CustomerID colocando su descripcion
#print(tx_user.groupby('VVCCluster')['CustomerID'].describe().to_string())

tx_user = order_cluster('Revenue', 'VVCCluster',tx_user,True)

#print(tx_user.groupby('VVCCluster')['Revenue'].describe().to_string())
print(tx_user.groupby('VVCCluster')[['Recency', 'Frequency','Revenue']].describe().to_string())

#Realiza el ploteo de la ventana figura

fig = plt.figure()

#Realiza un garfico tridimensional para que se pueda signar los datos

ax = fig.add_subplot(111, projection='3d')

#Realiza la asignacion a x de los valores de RecencyCluster

x = np.array(tx_user['RecencyCluster'])
#Realiza la asignacion a x de los valores de FrequencyCluster
y = np.array(tx_user['FrequencyCluster'])
#Realiza la asignacion a x de los valores de RevenueCluster
z = np.array(tx_user['RevenueCluster'])

#Coloca el titulo del grafico tridimensional

ax.set_title("Valor de Vida de los Clientes")
#Coloca la etiqueta del eje RecencyCluster
ax.set_xlabel("RecencyCluster")
#Coloca la etiqueta del eje FrequencyCluster
ax.set_ylabel("FrequencyCluster")
#Coloca la etiqueta del eje RevenueCluster
ax.set_zlabel("RevenueCluster")

#Realiza la colocacion de los datos tx_user[WCCluster] en el grafico tridimensional, donde

aquellos puntos donde tiene mas coincidencia se va a visualizar con mayor color y encerrado
en cuadrado
ax.scatter(x,y,z, marker="s", c=tx_user["VVCCluster"], s=40, cmap="RdBu")

plt.show()

8. Prepare un breve Dx de la empresa usando estos resultados.

La empresa tiene 3950 clientes en el país de UnitedKingdom los cuales 235 clientes tienen
mayor rendimiento que nos genera ingresos de 3786 en promedio y frecuencia de 317 con un
recency de 14 dias
Los de menor rendimiento generan ingresos de 123.5 en promedio con una frecuencia de 451
y un recenty de 123.5 dias