Data Mining: Buscando un buen Negocio
Procesamiento

OBTENIENDO LOS DATATFRAMSE DESDE LOS ARCHIVOS .JSON

#Dataset de la categoría Videojuegos
install.packages("jsonlite") 
library(jsonlite)
archivo <- "G:/Data mining/reviews_Video_Games.json"
con <- file(archivo, open="r")
complete_json <- readLines(con)
close(con)
datojson<-paste(complete_json,collapse=",")
datojson<-paste("[",datojson,"]",ste="")
Jsondata <- fromJSON(datojson)
datos <- as.data.frame(Jsondata)
View(datos)

#Dataset de la Categoría Celulares y accesorios
archivo2 <- "G:/Data mining/reviews_Cell_Phones_and_Accessories.json"
con2 <- file(archivo2, open="r")
complete_json2 <- readLines(con2)
close(con2)
datojson2<-paste(complete_json2,collapse=",")
datojson2<-paste("[",datojson2,"]",ste="")
Jsondata2 <- fromJSON(datojson2)
datos2 <- as.data.frame(Jsondata2)
View(datos2)

ANALISIS DE LOS DATOS

#Mezclar los dos dataset
total <- rbind(datos, datos2) 
dim(total)
summary(total)

#Eliminando columnas de Usuarios
total$reviewerID <- NULL
total$reviewerName <- NULL

#Encontrando los con mejor rating del 2014
BestRating <- with(total, total[overall==5, ])
filtro <- grep("2014", BestRating$reviewTime, ignore.case=TRUE)
BestNewRating <- BestRating[filtro,]

#Encontrando los peores del 2014
WorstRating <- with(total, total[overall<=2, ])
filtro2 <- grep("2014", WorstRating$reviewTime, ignore.case=TRUE)
WorstNewRating <- WorstRating[filtro2,]
TopWorst <- WorstNewRating[order(WorstNewRating$overall, decreasing = T), ]
TopWorstOrd <- TopWorst[order(TopWorst$unixReviewTime, decreasing = T), ]


#Comentarios con mayor cantidad de palabras y añadiendolo al dataset
ComentaryWorst <-  sapply(gregexpr("[[:alpha:]]+", TopWorst$reviewText), function(x) sum(x > 0))
TopWorst$WordCount = ComentaryWorst
TopWorstOrd2 <- TopWorst[order(TopWorst$WordCount, decreasing = T), ]

#Contar cantidad de reviews por producto
library(plyr)
ReviewCount <- count(TopWorst,"asin")
Topupdates <- merge(TopWorst, ReviewCount, by="asin")
						

#####Limpieza de datos#####################



##############################################################################################
##ADVERTENCIA: El codigo puede demorar 3 dias o mas dependiendo del tamaño del data set#######
##############################################################################################





import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns; sns.set(style="ticks", color_codes=True)
from sklearn.model_selection import cross_val_score
from sklearn import metrics, cross_validation
import gzip 
from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
from textblob import TextBlob


##funciones##
def parse(path): 
    g = gzip.open(path, 'rb') 
    for l in g: yield eval(l) 

def getDF(path): 
    i = 0 
    df = {} 
    for d in parse(path): 
        df[i] = d 
        i += 1 
    return pd.DataFrame.from_dict(df, orient='index') 

def word_count(string):
    if type(string)!=str:
        return 0
    tokens = string.split()
    n_tokens = len(tokens)
    return (n_tokens)

def raniking(dicc):
    return dicc[list(dicc.keys())[0]]


vader = SentimentIntensityAnalyzer()

def Sentimiento(texto):
    analysis = TextBlob(texto)
    try:
        testeo=analysis.detect_language() != 'en'
        if testeo:
            try:
                analysis=analysis.translate(to='en')
                texto = str(analysis)
            except:
                pass
    except:
        pass
    text=vader.polarity_scores(texto)
    return [text['neg'],text['neu'],text['pos'],text['compound'],analysis.sentiment.polarity,analysis.sentiment.subjectivity]


def muthelp(h):
    if h[0]==0:
        return 0.0
    else:
        return 1.*h[0]/h[1]


    
def alsob(r):
    if type(r)==float or not('also_bought' in r):
        return 0
    return len(r['also_bought'])


def aview(r):
    if type(r)==float or not('also_viewed' in r):
        return 0
    return len(r['also_viewed'])


def baftveiw(r):
    if type(r)==float or not('buy_after_viewing' in r):
        return 0
    return len(r['buy_after_viewing'])    

def bouto(r):
    if type(r)==float or not('bought_together' in r):
        return 0
    return len(r['bought_together'])  
########################################################################################
##################dataset base##########################################################
########################################################################################
data = getDF('Direccion dataset (ej: C:/Users/A/Desktop/reviews_Video_Games.json.gz)')
dfmeta=getDF('Direccion metadatos(ej: C:/Users/A/Desktop/meta_Video_Games.json.gz)')
#########################################################################################
#########################################################################################
#########################################################################################

##Eliminiacion de columnas inecesarias##


del data['reviewerID']
del data['helpful']
del data['reviewTime']
del data['unixReviewTime']
del data['summary']
del data['reviewerName']
del dfmeta['title']
del dfmeta['imUrl']
del dfmeta['brand']
del dfmeta['categories']

##Eliminacion de datos valores vacios y NaN##
dfmeta= dfmeta.dropna(subset=['salesRank'])
dfmeta= dfmeta[dfmeta["salesRank"]!={}]
dfmeta=dfmeta.reset_index(drop=True)

data=pd.merge(data,dfmeta,on='asin')
data= data.dropna(subset=['salesRank'])
data= data[data["salesRank"]!={}]
data=data.reset_index(drop=True)

del data['description']
del data['price']
del data['related']
del data['salesRank']
##Formacion de nuevas columnas##


data['word count']=data.apply(lambda row: word_count(row.reviewText), axis=1)

dfmeta['ranking']=dfmeta.apply(lambda row: raniking(row.salesRank), axis=1)
del dfmeta['salesRank']



dfmeta['also_bought']=dfmeta.apply(lambda row: alsob(row.related), axis=1)
dfmeta['also_viewed']=dfmeta.apply(lambda row: aview(row.related), axis=1)
dfmeta['buy_after_viewing']=dfmeta.apply(lambda row: baftveiw(row.related), axis=1)
dfmeta['bought_together']=dfmeta.apply(lambda row: bouto(row.related), axis=1)
del dfmeta['related']

dfmeta['descsize']=dfmeta.apply(lambda row: word_count(row.description), axis=1)
###############################


#sentimiento review #
vnegative=len(data.index)*[0]
vneutral=len(data.index)*[0]
vpositive=len(data.index)*[0]
vcompound=len(data.index)*[0]
vpolarity=len(data.index)*[0]
vsubjetivity=len(data.index)*[0]


lista=list(range(0,len(data.index),int(len(data.index)/10)))
lista.pop()
lista.append(len(data.index))


for d in range(0,9):
    for i in range(lista(d),lista(d+1)):
        ##review##
        text=data.iloc[i]['reviewText']
        vect=Sentimiento(text)
        vnegative[i]=vect[0]
        vneutral[i]=vect[1]
        vpositive[i]=vect[2]
        vcompound[i]=vect[3]
        vpolarity[i]=vect[4]
        vsubjetivity[i]=vect[5]

    data['blobPolarityReview'] = pd.Series(vpolarity, index=data.index)
    data['blobSubjetivityReview'] = pd.Series(vsubjetivity, index=data.index)
    data['vaderNegativeReview'] = pd.Series(vnegative, index=data.index)
    data['vaderNeutralReview'] = pd.Series(vneutral, index=data.index)
    data['vaderPositiveReview'] = pd.Series(vpositive, index=data.index)
    data['vaderCompoundReview'] = pd.Series(vcompound, index=data.index)
    



del data['reviewText']
##############################################################
#######se guarda data(Opcional)###############################
##############################################################
data.to_json('Direccion donde se quiere guardar/nombre archivo','records', None, 10, True, 'ms', None, False, 'gzip')

#sentimiento descripcion##

vnegatived=len(dfmeta.index)*[0]
vneutrald=len(dfmeta.index)*[0]
vpositived=len(dfmeta.index)*[0]
vcompoundd=len(dfmeta.index)*[0]
vpolarityd=len(dfmeta.index)*[0]
vsubjetivityd=len(dfmeta.index)*[0]
for i in range(len(dfmeta.index)):

    ##description##
    textd=dfmeta.iloc[i]['description']
    if type(textd)==float:
        vnegatived[i]=0.0
        vneutrald[i]=0.0
        vpositived[i]=0.0
        vcompoundd[i]=0.0
        vpolarityd[i]=0.0
        vsubjetivityd[i]=0.0
    else:
        vectd=Sentimiento(textd)
        vnegatived[i]=vectd[0]
        vneutrald[i]=vectd[1]
        vpositived[i]=vectd[2]
        vcompoundd[i]=vectd[3]
        vpolarityd[i]=vectd[4]
        vsubjetivityd[i]=vectd[5]
    
dfmeta['blobPolarityDescription'] = pd.Series(vpolarityd, index=dfmeta.index)
dfmeta['blobSubjetivityDescription'] = pd.Series(vsubjetivityd, index=dfmeta.index)
dfmeta['vaderNegativeDescription'] = pd.Series(vnegatived, index=dfmeta.index)
dfmeta['vaderNeutralDescription'] = pd.Series(vneutrald, index=dfmeta.index)
dfmeta['vaderPositiveDescription'] = pd.Series(vpositived, index=dfmeta.index)
dfmeta['vaderCompoundDescription'] = pd.Series(vcompoundd, index=dfmeta.index)
del dfmeta['description']
############################################
##############se guarda dfmeta##############
############################################
dfmeta.to_json('Direccion donde se quiere guardar metadatos/nombre archivo','records', None, 10, True, 'ms', None, False, 'gzip')

################################################################################
##############traspaso de informacio de data a dfmeta dfmeta####################
################################################################################

columnsProm=['blobPolarityReview','blobSubjetivityReview',                             
'overall'                                                                                         
,'vaderCompoundReview'               
,'vaderNegativeReview'                    
,'vaderNeutralReview'                 
,'vaderPositiveReview'                
,'word count']

def categorizador(asin,categorie):
    return np.mean(data.loc[data['asin']==asin][categorie])

for i in columnsProm:
    dfmeta[i]=dfmeta.apply(lambda row: categorizador(row.asin,i), axis=1)
    
################################################################
##############se guarda dfmeta como dataset final###############
################################################################    
    
dfmeta.to_json("C:/Users/Alvaro/Desktop/sentDescVidGam.json",'records', None, 10, True, 'ms', None, False, 'gzip')
						

#################Clasificacion################

import pandas as pd
import numpy as np

datos=pd.read_json("Direccion de los datos del codigo anterior",'records','frame', True, True, True, True, False, False, None, None, False, None, 'gzip')

##############Esta clasificacion solo srive para los datos de videogames#################
dtaSelecta=datos.loc[(datos['overall']>=4.5)&(datos['ranking']<=15000)&(datos['vaderCompoundReview']>=0.75)]

a=dtaSelecta.index.values
def selector(i):
    if i in a:
        return 1
    else:
        return 0
datos=datos.reset_index(inplace=True)    
datos['zClases']=datos['asin'].apply(selector)


datos.to_json("Direccion",'records', None, 10, True, 'ms', None, False, 'gzip')
####los datos que se guardan incluyen mas informacion que la que se usara en el clasificador####
						

###Test de clasificadores, estan fuertemente basados en el laboratorio de este tema######
from sklearn.dummy import DummyClassifier
from sklearn.svm import SVC  # support vector machine classifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB  # naive bayes
from sklearn.neighbors import KNeighborsClassifier
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt


from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score, recall_score, precision_score


def run_classifier(clf, X, y, num_tests=100):
    metrics = {'f1-score': [], 'precision': [], 'recall': []}
    
    for _ in range(num_tests):
        
        
        ### INICIO COMPLETAR ACÁ 
        #### TIP: divida el dataset, entrene y genere las predicciones.
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, stratify=y)
        clf.fit(X_train, y_train)  
        predictions = clf.predict(X_test)  

        ### FIN COMPLETAR ACÁ
        
        
        
        metrics['f1-score'].append(f1_score(y_test,predictions))  # X_test y y_test deben ser definidos previamente
        metrics['recall'].append(recall_score(y_test,predictions))
        metrics['precision'].append(precision_score(y_test,predictions))
    
    return metrics


##preparacion del dataset y eliminacion de columnas que se usaron para determinar las clases###
datos=pd.read_json("Direccion de los datos del codigo anterior",'records','frame', True, True, True, True, False, False, None, None, False, None, 'gzip')
del datos['ranking']
del datos['vaderCompoundDescription']
del datos['overall']



X_orig = datos[datos.columns[:-1]] # todo hasta la penultima columna
y_orig = datos[datos.columns[-1]]

print("Distribución de clases usando (over/sub)sampling")
print()



# oversampling sobre la clase 1
###size se puede vaiar en funciona la proporcion entre los datosq ue se desee
idx = np.random.choice(datos.loc[datos.zClases == 1].index, size=38000)
data_oversampled = pd.concat([datos, datos.iloc[idx]])

print("Data oversampled on class '1'")
print(data_oversampled['zClases'].value_counts())
print()

# subsampling sobre la clase 0
###size se puede vaiar en funciona la proporcion entre los datosq ue se desee
idx = np.random.choice(datos.loc[datos.zClases == 0].index, size=39500, replace=False)
data_subsampled = datos.drop(datos.iloc[idx].index)

print("Data subsampled on class '0'")
print(data_subsampled['zClases'].value_counts())


## ejecutar este código para preparar los datos
from sklearn.metrics import classification_report

# Preparando los data frames para ser compatibles con sklearn

# datos originales 
X_orig = datos[datos.columns[:-1]] # todo hasta la penultima columna
y_orig = datos[datos.columns[-1]]

# datos "oversampleados" 
X_over = data_oversampled[dataElCastrado.columns[:-1]]
y_over = data_oversampled[dataElCastrado.columns[-1]]

# datos "subsampleados"
X_subs = data_subsampled[dataElCastrado.columns[:-1]]
y_subs = data_subsampled[dataElCastrado.columns[-1]]



####test de clasificacion#####

c0 = ("Base Dummy", DummyClassifier(strategy='stratified'))
c1 = ("Decision Tree", DecisionTreeClassifier())
c2 = ("Gaussian Naive Bayes", GaussianNB())
c3 = ("KNN", KNeighborsClassifier(n_neighbors=5))

classifiers = [c0, c1, c2, c3]


from sklearn.dummy import DummyClassifier
from sklearn.svm import SVC  # support vector machine classifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB  # naive bayes
from sklearn.neighbors import KNeighborsClassifier


c0 = ("Base Dummy", DummyClassifier(strategy='stratified'))
c1 = ("Decision Tree", DecisionTreeClassifier())
c2 = ("Gaussian Naive Bayes", GaussianNB())
c3 = ("KNN", KNeighborsClassifier(n_neighbors=5))

classifiers = [c0, c1, c2, c3]



print("orig")
for name, clf in classifiers:
    metrics = run_classifier(clf, X_orig, y_orig)   # hay que implementarla en el bloque anterior.
    print("----------------")
    print("Resultados para clasificador: ",name) 
    print("Precision promedio:",np.array(metrics['precision']).mean())
    print("Recall promedio:",np.array(metrics['recall']).mean())
    print("F1-score promedio:",np.array(metrics['f1-score']).mean())
    print("----------------\n\n")
print("over")
for name, clf in classifiers:
    metrics = run_classifier(clf, X_over, y_over)   # hay que implementarla en el bloque anterior.
    print("----------------")
    print("Resultados para clasificador: ",name) 
    print("Precision promedio:",np.array(metrics['precision']).mean())
    print("Recall promedio:",np.array(metrics['recall']).mean())
    print("F1-score promedio:",np.array(metrics['f1-score']).mean())
    print("----------------\n\n")
print("subs")    
for name, clf in classifiers:
    metrics = run_classifier(clf, X_subs, y_subs)   # hay que implementarla en el bloque anterior.
    print("----------------")
    print("Resultados para clasificador: ",name) 
    print("Precision promedio:",np.array(metrics['precision']).mean())
    print("Recall promedio:",np.array(metrics['recall']).mean())
    print("F1-score promedio:",np.array(metrics['f1-score']).mean())
    print("----------------\n\n")