#---------------------------------------------------------------#
# Leer los datos

data <- read.csv("datatest1.csv", 
               sep=";", 
               dec=",", 
               na.strings=c(".", "NA", "", "?"), 
               strip.white=TRUE, 
               encoding="UTF-8")

data$class=as.factor(data$class) # la transformación está bien
# valores discretos
# en factores

df <- data.frame(datos) # creación del data frame

#---------------------------------------------------------------#
source("pair_panels.R") # funciones param de la función pairs
require(stats) # estadísticas básicas
require(graphics) # gráficos básicos
require(dplyr) # librería de manipulación de datos
require(caret) # para predicciones y transformación.
library(ROCR)
library(rattle) # riskchart

library(AppliedPredictiveModeling) # para tener un transparentTheme
#---------------------------------------------------------------#
require(caret)      # super paquete
# CV k-fold 
set.seed(2)
fitControl <- trainControl( ## 10-fold CV
  method = "repeatedcv",
  number = 10,
  ## 10 veces
  repeats = 10)
#---------------------------------------------------------------#
m <- train(v12~.,data = df,
           method = "glm",
           trControl = fitControl
           ## opciones particulares
           )
#---------------------------------------------------------------#
z_norm  <- function(x){ 
  if((class(x) != "factor") & (class(x) != "character")) {
    x <-  ((x-mean(x))/sd(x))
    x <-  (x - min(x)) /abs(max(x)-min(x))
    }
  x
  }
df <- data.frame(lapply(df,z_norm))
#---------------------------------------------------------------#
# creación partición training/test
set.seed(2)
p          <- createDataPartition(y=df$clase,
                                  p= 60/100,
                                  list=FALSE)
training   <- df[p,]  
test       <- df[-p,]
#---------------------------------------------------------------#
# BONUS diag por parejas                                          #
                         # eleccionde las variables del data set 
X     <- c("v3", "v5", "v6", "v7")
y     <- "clase"        # nuestro destino

pairs(training[c(X, y)], # correlaciones
      diag.panel = panel.hist, 
      upper.panel = panel.cor,
      lower.panel = panel.smooth,
      main = "RELACIONES 2 A 2 ENTRE LAS FEATURES")

#---------------------------------------------------------------#
## BONUS constitución árbol decisión                        ##

library(rpart)         # árbol de decisión
set.seed(2)
X     <- c("v3", "v5", "v6", "v7")  # explicativa
y     <- "clase"                   # respuesta

d <- training[c(X, y)] # el data frame de entrenamiento
t <- test[c(X, y)]     # el data frame de prueba

m <-  rpart(clase  ~ .  , 
            data = d,
            control=rpart.control(minsplit=1,cp=0)
            ) 

library(rpart.plot)       # para trazar el árbol
prp(m,extra=1)            # trazar el árbol

predictions <-predict(m,t, type="class")#  predecir en test
c <- confusionMatrix(predictions,       #  matriz de confusión
                     t$clase)
cat(" Accuracy de las pruebas Tree : ",c[[3]][1],"\n") 
print(c)                                # matriz confusión 


#---------------------------------------------------------------#
# CV k-fold 
set.seed(2)
fitControl <- trainControl( ## 10-fold CV
  method = "repeatedcv",
  number = 10,
  ## 10 veces
  repeats = 10)

#---------------------------------------------------------------#
# naive Bayes                                                   #

set.seed(2)
X     <- c("v3", "v5", "v6", "v7")  # explicativa
y     <- "clase"                   # respuesta

d <- training[c(X, y)] # el data frame de entrenamiento
t <- test[c(X, y)]     # el data frame de prueba

if(require("e1071")==FALSE) install.packages("e1071")
library(e1071)


m <-  naiveBayes(clase  ~ .  , 
                 data = d,
                 importance=TRUE,
                 laplace = 0) 

predictions <-predict(m,t, type="class")#  predecir en test
c <- confusionMatrix(predictions,       #  matriz de confusión
                     t$clase)
cat(" Accuracy de las pruebas naiveBayes : ",c[[3]][1],"\n") 

print(c)                                # matriz de confusión

pred <- as.numeric(levels(predictions))[predictions]
real <- as.numeric(levels(t$clase))[t$clase]
error <- pred-real
tt <- data.frame(t,error)
plot(tt[,1:5], col = 8 - error*2, pch = 20-error)

m$apriori    #reparto de las clases
m$tables$v3  # media y desviación típica por clase/variable



#---------------------------------------------------------------#
set.seed(2)
if(require("C50")==FALSE) install.packages("C50")
library(C50)
m <- train(clase  ~ ., 
           data = d,
           method ="C5.0",
           importance = TRUE)
predictions <-predict(m,t, type="raw")#  predecir en test
c <- confusionMatrix(predictions,       #  matriz de confusión
                     t$clase)
cat(" Accuracy C5.0 : ",c[[3]][1],"\n") 


importancias <- varImp(m, scale = FALSE)
importancias
plot(importancias, top = 4)
plot(m, subtree = 3)
summary(m)

print(c)                                # matriz de confusión
pred <- as.numeric(levels(predictions))[predictions]
real <- as.numeric(levels(t$clase))[t$clase]
error <- pred-real
tt <- data.frame(t,error)
plot(tt[,1:5], col = 8 - error*2, pch = 20-error)

#---------------------------------------------------------------#
# SVM kernab y caret
set.seed(2)
if(require("kernlab")==FALSE) install.packages("kernlab")
library(kernlab)
m <- train(clase  ~ ., 
           data = d,
           method ="svmPoly",
           importance = TRUE)
predictions <-predict(m,t)#  predecir en test
c <- confusionMatrix(predictions,       #  matriz de confusión
                     t$clase)
cat(" Accuracy  : ",c[[3]][1],"\n") 

 

print(c)                                # matriz de confusión
pred <- as.numeric(levels(predictions))[predictions]
real <- as.numeric(levels(t$clase))[t$clase]
error <- pred-real
tt <- data.frame(t,error)
plot(tt[,1:5], col = 8 - error*2, pch = 20-error)

importancias <- varImp(m, scale = FALSE)
importancias
plot(importancias, top = 4)
summary(m)
m


#---------------------------------------------------------------#
# BONUS SVM kernlab sin caret 

m1 <- ksvm(clase  ~ ., data = d, kernel = "polydot")
predictions <-predict(m1,t)#  predecir en test
c <- confusionMatrix(predictions,       #  matriz de confusión
                     t$clase)
cat(" Accuracy  : ",c[[3]][1],"\n") 



print(c)                                # matriz de confusión
pred <- as.numeric(levels(predictions))[predictions]
real <- as.numeric(levels(t$clase))[t$clase]
error <- pred-real
tt <- data.frame(t,error)
plot(tt[,1:5], col = 8 - error*2, pch = 20-error)

summary(m1)
xmatrix(m1)
ymatrix(m1)
coef(m1)[[1]]
SVindex(m1)
b(m1)
alpha(m1)
alphaindex(m1)
kernelf(m1)




#---------------------------------------------------------------#
# clustización kmeans con kernel                               #
set.seed(2)
X     <- c("v1", "v2","v3","v4")  # explicativa
y     <- "clase"       # respuesta

d <- training[c(X, y)] # el data frame de entrenamiento
t <- test[c(X, y)]     # el data frame de prueba
nb_v <- ncol(d)        # Numero de col de d
m2 <- kkmeans(as.matrix(d[,-nb_v]), 
              centers=4, 
              kernel="polydot", # nodo polinómico
              grado = 2 )       # grado 2

centers(m2)  # coordenadas del centro de los clústeres
size(m2)     # tamaño de los clústeres
kernelf(m2)  # tipo de kernel 

labels <- unlist(m2)[1:length(m2)]# extracción de las etiquetas 
# resultados (es decir, grupo)

anterior <- datos.marco(d[,1:nb_v-1],
                        etiquetas) # no útil pero agradable

x <- as.matrix(prev[,1:nb_v-1]) # x ejes para el plot

# valores y
# alineación repentina naive
# de valores de etiqueta
# con valores de clase
p <- prev$labels*100+100 # con este truco
p <- ifelse(p ==500,0,p) # ya no podemos perdernos
p <- ifelse(p ==300,1,p) # estos filtros se actualizan
p <- ifelse(p ==400,2,p) # manualmente cada vez
p <- ifelse(p ==200,3,p) # que se pasa a la vista de las etiquetas
y_new <- factor(p) # valores y
y_old <- d$clase # inútil, por estética 

trellis.par.set(theme = col.whitebg(), warn = FALSE)
transparentTheme(trans = .5)
featurePlot(x, y_new , 
            "ellipse", 
            jitter = TRUE,
            xlab="clases kkmeans")

featurePlot(x, y_new, "box")

transparentTheme(trans = .5)
featurePlot(x, y_old , 
            "ellipse", 
            jitter = TRUE,
            xlab="clases dataset")


featurePlot(x, y_old, "box")

#---------------------------------------------------------------#
# prueba con diferentes num de nodos                             #
k     <- 10       # num max nodos
sw    <- (1:k)*0  # vector de 0
psize_min <- 0.1        # proporción mínima efectiva 
psize     <- 1          # init proporción efectiva 100%
for (i in 2:k)
  {
  if (psize >= psize_min){
    set.seed(2)
    m2 <- kkmeans(as.matrix(d[,-nb_v]), 
                  centers=i,
                  kernel="polydot", # nodo polinómico
                  grado = 2 )       # grado 2)
    psize <- min(size(m2)/sum(size(m2)))
    swi   <- sum(withinss(m2))  # withinss:sum of square clusters
    sw[i] <- swi                # vector sum of sum ss
    }
  }
#---------------------------------------------------------------#
# plot resultado                                                #
# resultados (es decir, grupo)

prev <- data.frame(d[,1:nb_v-1],
                   labels) # no útil pero agradable
# 1) nulos deseleccionados con
# una seguridad de 1e-10
# 2) min de no nulos
# 3) desplazamiento de este min
# 4) mantener no nulos
# rq: si hubiésemos querido sw
# ahora teníamos que hacer sqrt
sw <- sw*(sw - min(ifelse(sw <= 1e-10, NA,sw), na.rm = TRUE))

                              # valor óptimo de k
require("ggplot2")            # paquete gráfico 
Pertinencia <- scale(sw, center = FALSE) # sin centro en cero
Numero_de_clusters <- 1:k               # 1 to k
p <- qplot(Numero_de_clusters, Pertinencia,geom = "line")
p <- p + scale_x_continuous(breaks=c(1:k)) # escala regular
p

