<jupyter_start><jupyter_text>Facebook Live Sellers in Thailand Data Set Author: <NAME> E-mail: <EMAIL>Para este projeto foi utilizado o arquivo "heart.csv" que representa o conjunto de dados de treinamentoCaracterísticas do dataset:    Facebook pages of 10 Thai fashion and cosmetics retail sellers. Posts of a different nature (video, photos, statuses, and links). Engagement metrics consist of comments, shares, and reactions.    The variability of consumer engagement is analysed through a Principal Component Analysis, highlighting the changes induced by the use of Facebook Live. The seasonal component is analysed through a study of the averages of the different engagement metrics for different time-frames (hourly, daily and monthly). Finally, we identify statistical outlier posts, that are qualitatively analyzed further, in terms of their selling approach and activities.    Fonte dos dados: https://archive.ics.uci.edu/ml/datasets/Facebook+Live+Sellers+in+Thailand    Creators:                     1. <NAME>            Para navegar pelas diversas partes que compõe este projeto use os links a seguir    Iniciando o projeto    Carrega os dados e faz uma breve limpeza    Transforma os dados    Aplica uma escala aos dados    Executa o algoritmo Optics 1. Iniciando o projetoNa célula abaixo são feitos as declarações de importação das bibliotecas utilizadas<jupyter_code>import pandas as pd

import numpy as np

from sklearn.preprocessing import LabelEncoder, OneHotEncoder, RobustScaler
from sklearn.cluster import OPTICS, cluster_optics_dbscan

import matplotlib.gridspec as gridspec
import matplotlib.pyplot as plt

import seaborn as sns<jupyter_output><empty_output><jupyter_text>2. Carrega os dados e faz uma breve limpezaA descrição das células é elencado na seguinte sequência    Carrega os dados para uma dataframe Pandas e visualiza seu cabeçalho    Verifica as dimensões do dataframe    Elimina colunas desnecessárias    Verifica os registros duplicados    Elimina os registros duplicados    Veririca se existe valores nulos    Verifica algumas informações das colunas do dataframe    Separa somente as colunas que serão utilizadas no processo de ML e armazena em X<jupyter_code>df_live = pd.read_csv('live.csv')
df_live.head()
df_live.shape
df_live.drop('Column1', axis=1, inplace=True)
df_live.drop('Column2', axis=1, inplace=True)
df_live.drop('Column3', axis=1, inplace=True)
df_live.drop('Column4', axis=1, inplace=True)
df_live.head()
sum(df_live.duplicated())
df_live.drop_duplicates(inplace=True)
df_live.isnull().sum().any()
df_live.info()
X=df_live[['status_type', 'num_reactions', 'num_comments', 'num_shares', 'num_likes', 
           'num_loves', 'num_wows', 'num_hahas', 'num_sads', 'num_angrys']]
X.head()<jupyter_output><empty_output><jupyter_text>3. Transforma os dadosA descrição das células é elencado na seguinte sequência    Codifica a coluna status_type usando LabelEncoder e adiciona ao dataframe X uma nova coluna chamada status_type_coded    Visualiza o cabeçalho do dataframe    Visualiza as classes codificadas po LabelEncoder    Codifica a coluna status_type usando OneHoteEncoder    adiciona ao dataframe X uma nova coluna chamada status_type_link    Visualiza o cabeçalho do dataframe    adiciona ao dataframe X uma nova coluna chamada status_type_photo    Visualiza o cabeçalho do dataframe    adiciona ao dataframe X uma nova coluna chamada status_type_status    Visualiza o cabeçalho do dataframe    adiciona ao dataframe X uma nova coluna chamada status_type_video    Visualiza o cabeçalho do dataframe<jupyter_code>le_status_type = LabelEncoder()
le_status_type.fit(X.status_type)
status_type_encoder = le_status_type.transform(X.status_type)
X.loc[X['status_type'] == X.status_type, 'status_type_coded'] = status_type_encoder[:]
X.head()
le_status_type.classes_
ohe = OneHotEncoder(categories='auto')
X_ohe = ohe.fit_transform(X).toarray()
print(X_ohe)
X.loc[X['status_type'] == X.status_type, 'status_type_link'] = X_ohe[:,0]
X.head()
X.loc[X['status_type'] == X.status_type, 'status_type_photo'] = X_ohe[:,1]
X.head()
X.loc[X['status_type'] == X.status_type, 'status_type_status'] = X_ohe[:,2]
X.head()
X.loc[X['status_type'] == X.status_type, 'status_type_video'] = X_ohe[:,3]
X.head()<jupyter_output><empty_output><jupyter_text>4. Aplica uma escala aos dadosA descrição das células é elencado na seguinte sequência    Cria um cópia do dataframe X chamada X_work com somente as colunas que serão usadas no processo de ML    Visualiza o cabeçalho do dataframe    Coloca os dados em escala usando RobustScaler e armazena em data_scaled    Transforma o vetor de dados obtidos após a conversação em um DataFrame do Pandas em seguida visualiza o cabeçalho<jupyter_code>X_work = X[['num_reactions', 'num_comments', 'num_shares', 'num_likes', 'num_loves', 'num_wows', 'num_hahas', 
              'num_sads', 'num_angrys', 'status_type_link', 'status_type_photo', 'status_type_status', 'status_type_video']]
X_work.head()
rs = RobustScaler(copy=True, quantile_range=(30.0, 70.0), with_centering=True, with_scaling=True)
data_scaled = rs.fit_transform(X_work)
X_scaled = pd.DataFrame(data_scaled, columns=X_work.columns, dtype=float)
X_scaled.head()
X_scaled.info()<jupyter_output><class 'pandas.core.frame.DataFrame'>
RangeIndex: 6999 entries, 0 to 6998
Data columns (total 13 columns):
num_reactions         6999 non-null float64
num_comments          6999 non-null float64
num_shares            6999 non-null float64
num_likes             6999 non-null float64
num_loves             6999 non-null float64
num_wows              6999 non-null float64
num_hahas             6999 non-null float64
num_sads              6999 non-null float64
num_angrys            6999 non-null float64
status_type_link      6999 non-null float64
status_type_photo     6999 non-null float64
status_type_status    6999 non-null float64
status_type_video     6999 non-null float64
dtypes: float64(13)
memory usage: 710.9 KB<jupyter_text>5. Executa o algoritmo OpticsA descrição das células é elencado na seguinte sequência<jupyter_code>mdl_cluster = OPTICS(min_samples = 50,
                     metric = 'l2',
                     metric_params = None,
                     cluster_method = 'dbscan',
                     predecessor_correction = True,
                     min_cluster_size = None,
                     algorithm = 'auto',
                     n_jobs = -1)
mdl_cluster.fit(X_scaled)
labels_050 = cluster_optics_dbscan(reachability=clust.reachability_,
                                   core_distances=clust.core_distances_,
                                   ordering=clust.ordering_, eps=0.5)
labels_200 = cluster_optics_dbscan(reachability=clust.reachability_,
                                   core_distances=clust.core_distances_,
                                   ordering=clust.ordering_, eps=2)

space = np.arange(len(X_scaled))
reachability = mdl_cluster.reachability_[mdl_cluster.ordering_]
labels = mdl_cluster.labels_[mdl_cluster.ordering_]

plt.figure(figsize=(10, 7))
G = gridspec.GridSpec(2, 3)
ax1 = plt.subplot(G[0, :])
ax2 = plt.subplot(G[1, 0])
ax3 = plt.subplot(G[1, 1])
ax4 = plt.subplot(G[1, 2])

# Reachability plot
colors = ['g.', 'r.', 'b.', 'y.', 'c.']
for klass, color in zip(range(0, 5), colors):
    Xk = space[labels == klass]
    Rk = reachability[labels == klass]
    ax1.plot(Xk, Rk, color, alpha=0.3)
ax1.plot(space[labels == -1], reachability[labels == -1], 'k.', alpha=0.3)
ax1.plot(space, np.full_like(space, 2., dtype=float), 'k-', alpha=0.5)
ax1.plot(space, np.full_like(space, 0.5, dtype=float), 'k-.', alpha=0.5)
ax1.set_ylabel('Reachability (epsilon distance)')
ax1.set_title('Reachability Plot')
# OPTICS
colors = ['g.', 'r.', 'b.', 'y.', 'c.']
for klass, color in zip(range(0, 5), colors):
    Xk = X_scaled[mdl_cluster.labels_ == klass]
    ax2.plot(Xk[:, 0], Xk[:, 1], color, alpha=0.3)
ax2.plot(X_scaled[mdl_cluster.labels_ == -1, 0], X_scaled[mdl_cluster.labels_ == -1, 1], 'k+', alpha=0.1)
ax2.set_title('Automatic Clustering\nOPTICS')

# DBSCAN at 0.5
colors = ['g', 'greenyellow', 'olive', 'r', 'b', 'c']
for klass, color in zip(range(0, 6), colors):
    Xk = X_scaled[labels_050 == klass]
    ax3.plot(Xk[:, 0], Xk[:, 1], color, alpha=0.3, marker='.')
ax3.plot(X_scaled[labels_050 == -1, 0], X_scaled[labels_050 == -1, 1], 'k+', alpha=0.1)
ax3.set_title('Clustering at 0.5 epsilon cut\nDBSCAN')

# DBSCAN at 2.
colors = ['g.', 'm.', 'y.', 'c.']
for klass, color in zip(range(0, 4), colors):
    Xk = X_scaled[labels_200 == klass]
    ax4.plot(Xk[:, 0], Xk[:, 1], color, alpha=0.3)
ax4.plot(X_scaled[labels_200 == -1, 0], X[labels_200 == -1, 1], 'k+', alpha=0.1)
ax4.set_title('Clustering at 2.0 epsilon cut\nDBSCAN')

plt.tight_layout()
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10684588221893154, 'fraction_numerical': 0.027679690169723204, 'mean_word_length': 4.223081499107674, 'pattern_counts': {'":': 0, '<': 24, '<?xml version=': 0, '>': 24, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 8, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '5', 'dir': 'jupyter-structured-clean-dedup', 'id': '185583', 'license': 'Apache-2.0', 'n_tokens_mistral': 3189, 'n_tokens_neox': 3061, 'n_words': 831, 'path': 'jupyter/ML T2 - PPGCC-DC-UFSCar.ipynb', 'repo_name': 'darosantos/RFNS', 'size': '8818'}