Estudio de técnicas de machine learning para la localización por WIFI

En este proyecto se desea ver si el “WIFI Fingerprinting” es un buen método de localización en interiores. Y se desea comprobar que algoritmo de machine learning puede dar una mejor precisión para la localización.

Para ello, hemos usado una base de datos perteneciente a un estudio que se hizo en la Facultad Jaume I de Castellón. Esta facultad consiste en 3 edificios. El data set contiene las medidas de intensidad de señal tomadas por 520 WAPs que hay dispuestos en distintos puntos de los 3 edificios. Además se proprcionan otras variables de interés: Latitud, Longitud, Piso, Edificio, Espacio, Usuario, Teléfono, Posición relativa y timestamp.

Los valores de intensidad de los WAPs están medidos en dBm, midiendo de 0 a -104 dBm, siendo 0 el caso de máxima señal. Para los casos en que no se detecta señal se indica con un 100.

Primero, leemos el data set y realizamos un pre-proceso. En éste, modificamos los valores de los WAPS que no detectan de 100 a -105.

#Cargamos librerías
library(caret)
library(dplyr)
library(tidyr)
library(ggplot2)
library(lubridate)
library(anytime)
library(matlab)

#Leemos training data
setwd("C:/Users/Pau A/Documents/Data Analysis Course/3- Deep Analytics and Visualization/Task 3/UJIndoorLoc")
trainingData <- read.csv("trainingData.csv")
validation_set <- read.csv("validationData.csv")

#Modificamos a -105 el valor de los Waps que no detectan
trainingData[trainingData==100] <- -105
validation_set[validation_set==100] <- -105

waps_train <- trainingData[,1:520]
#Borramos registros que contengan algun WAP con valor 0

vlength <- vector(mode="numeric", length=19937)

for (i in 1:19937){
  
  vlength[i] <-length(which(waps_train[i,] == 0))
  
}

waps_nozero <- which(vlength==0)

#el data set siguiente no contiene waps q marquen 0
trainingData <- trainingData[which(vlength==0),]

#Separamos por edificios
build0 <- subset(trainingData, BUILDINGID==0)
build1 <- subset(trainingData, BUILDINGID==1)
build2 <- subset(trainingData, BUILDINGID==2)

A continuación, para hacernos una idea de la forma de los edificios hacemos una representación de las latitudes y longitudes de los puntos donde se han tomado los datos. También hacemos visualizaciones separando edificio y planta para hacernos una idea de si se han tomado datos en todas las regiones de los edificios.

#Creamos data set con las ultimas columnas, y de los waps
last_col <- trainingData[,c(521:529)]
waps_col <- trainingData[,c(1:520)]
#Separamos por edificios
build0 <- subset(trainingData, BUILDINGID==0)
build1 <- subset(trainingData, BUILDINGID==1)
build2 <- subset(trainingData, BUILDINGID==2)
building_0 <- subset(last_col, BUILDINGID==0)
building_1 <- subset(last_col, BUILDINGID==1)
building_2 <- subset(last_col, BUILDINGID==2)
##Separamos por pisos cada edificio
#Edificio 0
f0_b0 <- subset(building_0, FLOOR==0)
f1_b0 <- subset(building_0, FLOOR==1)
f2_b0 <- subset(building_0, FLOOR==2)
f3_b0 <- subset(building_0, FLOOR==3)
#Edificio 1
f0_b1 <- subset(building_1, FLOOR==0)
f1_b1 <- subset(building_1, FLOOR==1)
f2_b1 <- subset(building_1, FLOOR==2)
f3_b1 <- subset(building_1, FLOOR==3)
#Edificio 2
f0_b2 <- subset(building_2, FLOOR==0)
f1_b2 <- subset(building_2, FLOOR==1)
f2_b2 <- subset(building_2, FLOOR==2)
f3_b2 <- subset(building_2, FLOOR==3)
f4_b2 <- subset(building_2, FLOOR==4)
f0_b0_reduced <- distinct(f0_b0, SPACEID, LONGITUDE, LATITUDE)
build_draw <- ggplot(last_col, aes(x=LONGITUDE)) + 
      geom_point(aes(y=LATITUDE))
            
build_draw

#Distribuci?n zonas edificio 0
f0_b0_map <- ggplot(f0_b0, aes(x=LONGITUDE)) + geom_point(aes(y=LATITUDE, color=factor(SPACEID))) + ggtitle("Edificio 0, planta 0") + xlab("Longitud") + ylab("Latitud")
f0_b0_map

f1_b0_map <- ggplot(f1_b0, aes(x=LONGITUDE)) + geom_point(aes(y=LATITUDE, color=factor(SPACEID))) + ggtitle("Edificio 0, planta 1") + xlab("Longitud") + ylab("Latitud")
f1_b0_map

f2_b0_map <- ggplot(f2_b0, aes(x=LONGITUDE)) + geom_point(aes(y=LATITUDE, color=factor(SPACEID))) + ggtitle("Edificio 0, planta 2") + xlab("Longitud") + ylab("Latitud")
f2_b0_map

f3_b0_map <- ggplot(f3_b0, aes(x=LONGITUDE)) + geom_point(aes(y=LATITUDE, color=factor(SPACEID))) + ggtitle("Edificio 0, planta 3") + xlab("Longitud") + ylab("Latitud")
f3_b0_map

#Distribuci?n zonas edificio 1
f0_b1_map <- ggplot(f0_b1, aes(x=LONGITUDE)) + geom_point(aes(y=LATITUDE, color=factor(SPACEID))) + ggtitle("Edificio 1, planta 0") + xlab("Longitud") + ylab("Latitud")
f0_b1_map

f1_b1_map <- ggplot(f1_b1, aes(x=LONGITUDE)) + geom_point(aes(y=LATITUDE, color=factor(SPACEID))) + ggtitle("Edificio 1, planta 1") + xlab("Longitud") + ylab("Latitud")
f1_b1_map

f2_b1_map <- ggplot(f2_b1, aes(x=LONGITUDE)) + geom_point(aes(y=LATITUDE, color=factor(SPACEID))) + ggtitle("Edificio 1, planta 2") + xlab("Longitud") + ylab("Latitud")
f2_b1_map

f3_b1_map <- ggplot(f3_b1, aes(x=LONGITUDE)) + geom_point(aes(y=LATITUDE, color=factor(SPACEID))) + ggtitle("Edificio 1, planta 3") + xlab("Longitud") + ylab("Latitud")
f3_b1_map

#Distribuci?n zonas edificio 2
f0_b2_map <- ggplot(f0_b2, aes(x=LONGITUDE)) + geom_point(aes(y=LATITUDE, color=factor(SPACEID))) + ggtitle("Edificio 2, planta 0") + xlab("Longitud") + ylab("Latitud")
f0_b2_map

f1_b2_map <- ggplot(f1_b2, aes(x=LONGITUDE)) + geom_point(aes(y=LATITUDE, color=factor(SPACEID))) + ggtitle("Edificio 2, planta 1") + xlab("Longitud") + ylab("Latitud")
f1_b2_map

f2_b2_map <- ggplot(f2_b2, aes(x=LONGITUDE)) + geom_point(aes(y=LATITUDE, color=factor(SPACEID))) + ggtitle("Edificio 2, planta 2") + xlab("Longitud") + ylab("Latitud")
f2_b2_map

f3_b2_map <- ggplot(f3_b2, aes(x=LONGITUDE)) + geom_point(aes(y=LATITUDE, color=factor(SPACEID))) + ggtitle("Edificio 2, planta 3") + xlab("Longitud") + ylab("Latitud")
f3_b2_map

f4_b3_map <- ggplot(f4_b2, aes(x=LONGITUDE)) + geom_point(aes(y=LATITUDE, color=factor(SPACEID))) + ggtitle("Edificio 2, planta 4") + xlab("Longitud") + ylab("Latitud")
f4_b3_map

De los gráficos anteriores se puede ver por ejemplo que en la última planta del edificio 2 no se tomaron datos para una de las zonas (la esquina inferior derecha), asi como tampoco en una zona de las plantas 0 y 1 del edificio 1.

Nuestro objetivo ahora es ver si podemos predecir la posición de una persona una vez tenemos los datos de la señal de los Waps recibida. Para ello hemos probado con distintos algoritmos de machine learning (KNN, Support Vector Machine, Random Forest, C5.0). Hemos entrenado esos algoritmos para predecir las distintas variables que nos pueden indicar la posición.

En nuestro caso hemos determinado que para predecir las 3 coordenadas de posición usaremos latitud, longitud y planta del edificio. También hemos considerado predecir el edificio porque pensamos que se puede predecir con una accuracy de prácticamente 1, y que podemos incorporar la predicción del edificio para predecir las otras variables, separando en tres grupos.

Para comenzar veamos como han sido entrenados los modelos.

Entrenamiento para predecir el Buliding. Usamos el árbol de decisión C5.0. Para la predicción usamos tan solo los 3 WAPS mas relevantes para cada registro, esto es el nombre de los 3 WAPS mas detectados:

### Predicción de Building ###

build_data <- trainingData[,c(1:520)]

build_data[build_data==0] <- -105

build_data <- cbind(build_data, trainingData$BUILDINGID)

waps.relevantes <- data.frame()
for (i in 1:nrow(build_data)){
  vec <- build_data[i,1:520] 
  #posicion del max en el vector build data va a ser mi primera celda de cada registro. 
  row.relevante <- order(vec, decreasing = T)[1:3]
#  row.relevante <- order(vec, decreasing = T)[1]
  waps.relevantes <- rbind(waps.relevantes, row.relevante)
      #mi data set va a ser registro x registro los 3 valores maximos relacionados con el wap que los detecta
      #voy a pedir el "nombre del wap" de forma numerica    
      
    }

waps.relevantes$BUILDINGID <- build_data$`trainingData$BUILDINGID`
waps.relevantes$FLOOR <- trainingData$FLOOR

reg.irrelevantes <- c() 
for (i in 1:nrow(build_data)){
  if (sum(build_data[i,1:ncol(build_data)-1])/(ncol(build_data)-1) == -105)
  reg.irrelevantes <- c(reg.irrelevantes, i)
}
  
waps.relevantes.entreno <- waps.relevantes[-reg.irrelevantes,]
waps.relevantes.BUILD <- waps.relevantes.entreno[,c(1:4)]


## Entrenamos modelo c5.0 ##
tic()
#Cambiamos valores numericos de building por letras
waps.relevantes.BUILD$BUILDINGID[waps.relevantes.BUILD$BUILDINGID==0] <- "a"
waps.relevantes.BUILD$BUILDINGID[waps.relevantes.BUILD$BUILDINGID==1] <- "b"
waps.relevantes.BUILD$BUILDINGID[waps.relevantes.BUILD$BUILDINGID==2] <- "c"

#Factorizamos BUILDINGID
waps.relevantes.BUILD$BUILDINGID <- factor(waps.relevantes.BUILD$BUILDINGID)

colnames(waps.relevantes.BUILD) <- c("Max1","Max2","Max3","BUILDINGID")

#Creamos 10 fold cross validation
fitControl <- trainControl(## 10-fold CV
  method = "cv",
  classProbs = TRUE
)

#Entrenamos los datos
set.seed(15)
C5_build <- train(BUILDINGID ~ ., data = waps.relevantes.BUILD, 
                 method = "C5.0", 
                 trControl = fitControl,
                 metric = "ROC",
                 preProc = c("center", "scale")
)

A continuación, entrenamos los modelos de latitud, longitud y floor por cada edificio por separado. Para ello hemos usado el Random Forest, que dió mejor RMSE en el caso de latitud y longitud y mejor Accuracy para el piso.

library(randomForest)
library(hydroGOF)


### LATITUDE ###

lat_b0 <- build0[,c(1:520,522,524)]
lat_b1 <- build1[,c(1:520,522,524)]
lat_b2 <- build2[,c(1:520,522,524)]

#Realizamos partición de train y test
tic()

RF_lat_b0 <- randomForest(LATITUDE ~ ., data = lat_b0)
RF_lat_b1 <- randomForest(LATITUDE ~ ., data = lat_b1)
RF_lat_b2 <- randomForest(LATITUDE ~ ., data = lat_b2)

toc()


### LONGITUDE ###

long_b0 <- build0[,c(1:520,521,524)]
long_b1 <- build1[,c(1:520,521,524)]
long_b2 <- build2[,c(1:520,521,524)]

#Realizamos partición de train y test
tic()

RF_long_b0 <- randomForest(LONGITUDE ~ ., data = long_b0)
RF_long_b1 <- randomForest(LONGITUDE ~ ., data = long_b1)
RF_long_b2 <- randomForest(LONGITUDE ~ ., data = long_b2)

toc()

### FLOOR ###
#Usaremos solo los 5 Waps mas relevantes para el entreno y la predicción

floor_b0 <- build0[,c(1:520,523,524)]
floor_b1 <- build1[,c(1:520,523,524)]
floor_b2 <- build2[,c(1:520,523,524)]

#Cambiamos valores numC)ricos de Floor por palabras
floor_b0$FLOOR[floor_b0$FLOOR==0] <- "a"
floor_b0$FLOOR[floor_b0$FLOOR==1] <- "b"
floor_b0$FLOOR[floor_b0$FLOOR==2] <- "c"
floor_b0$FLOOR[floor_b0$FLOOR==3] <- "d"

floor_b1$FLOOR[floor_b1$FLOOR==0] <- "a"
floor_b1$FLOOR[floor_b1$FLOOR==1] <- "b"
floor_b1$FLOOR[floor_b1$FLOOR==2] <- "c"
floor_b1$FLOOR[floor_b1$FLOOR==3] <- "d"

floor_b2$FLOOR[floor_b2$FLOOR==0] <- "a"
floor_b2$FLOOR[floor_b2$FLOOR==1] <- "b"
floor_b2$FLOOR[floor_b2$FLOOR==2] <- "c"
floor_b2$FLOOR[floor_b2$FLOOR==3] <- "d"
floor_b2$FLOOR[floor_b2$FLOOR==4] <- "e"

#Factorizamos Floor
floor_b0$FLOOR <- factor(floor_b0$FLOOR)
floor_b1$FLOOR <- factor(floor_b1$FLOOR)
floor_b2$FLOOR <- factor(floor_b2$FLOOR)

#Entrenamos modelos
RF_floor_b0 <- randomForest(FLOOR ~ ., data = floor_b0)
RF_floor_b1 <- randomForest(FLOOR ~ ., data = floor_b1)
RF_floor_b2 <- randomForest(FLOOR ~ ., data = floor_b2)

A continuación creamos una función que haga predicciones de forma escalonada, de latitud, longitud y floor con la informacion del building, usando los modelos entrenados préviamente:

#FUNCTION´
wifiloc <- function(wap){
  
  if (length(wap) != 520){
    stop("The vector needs 520 waps")
  }
  
  if (colnames(wap)[1] != "WAP001"){
    stop("Introduce a Vector containing WAP001 to WAP520")
  }
  #Building
  label <- order(wap, decreasing = T)[1:3]
  bd <- as.data.frame(label)
  bd <- as.data.frame(t(bd))
  colnames(bd) <- c("Max1","Max2","Max3")
  bd$BUILDINGID <- vector(mode="character", length = 1)
  bd$BUILDINGID <- predict(C5_build, bd)
  
  bd$BUILDINGID <- as.numeric(bd$BUILDINGID) - 1      
  
    #Latitude build 0
  lt <- wap
  lt$BUILDINGID <- bd$BUILDINGID
  lt_b0 <- subset(lt, BUILDINGID==0)
  lt_b1 <- subset(lt, BUILDINGID==1)
  lt_b2 <- subset(lt, BUILDINGID==2)
  lt$LATITUDE <- rbind(predict(RF_lat_b0, lt_b0), predict(RF_lat_b1, lt_b1), predict(RF_lat_b2, lt_b2))
  
   #Longitude
  lg <- wap
  lg$BUILDINGID <- bd$BUILDINGID
  lg_b0 <- subset(lg, BUILDINGID==0)
  lg_b1 <- subset(lg, BUILDINGID==1)
  lg_b2 <- subset(lg, BUILDINGID==2)
  lg$LONGITUDE <- rbind(predict(RF_long_b0, lg_b0), predict(RF_long_b1, lg_b1), predict(RF_long_b2, lg_b2))
  
   #Floor
  label_2 <- order(wap, decreasing = T)[1:5]
  fl <- as.data.frame(label_2)
  fl <- as.data.frame(t(fl))
  colnames(fl) <- c("Max1","Max2","Max3","Max4","Max5")
  fl$FLOOR <- vector(mode="character", length = 1)
  fl$BUILDINGID <- bd$BUILDINGID
  fl_b0 <- subset(fl, BUILDINGID==0)
  fl_b1 <- subset(fl, BUILDINGID==1)
  fl_b2 <- subset(fl, BUILDINGID==2)
  if(nrow(fl_b0) != 0){
     fl_b0$FLOOR <- predict(C5_floor_b0, fl_b0)
  }
  
  
  if(nrow(fl_b1) != 0){
     fl_b1$FLOOR <- predict(C5_floor_b1, fl_b1)
  }
  
  if(nrow(fl_b2) != 0){
     fl_b2$FLOOR <- predict(C5_floor_b2, fl_b2)
  }
  fl <- rbind(fl_b0,fl_b1,fl_b2)
  # 
  wap$LATITUDE <- lt$LATITUDE
  wap$LONGITUDE <- lg$LONGITUDE
  wap$BUILDINGID <- bd$BUILDINGID
 
  wap$FLOOR <- fl$FLOOR
  wap$FLOOR <- as.numeric(wap$FLOOR) - 1
  
  return(wap[,521:ncol(wap)])
  
}

Llamamos la función dándole los datos del Validation Set y hace una predicción por cada registro del data set:

#Creamos data frame
pred <- data.frame(LATITUDE = as.numeric(), LONGITUDE = as.numeric(),BUILDINGID = as.numeric(),FLOOR= as.numeric())
#Hacemos loop para todos los datos y llamamos la funci?n a cada fila
for(i in 1:1111){
pred[i,] <- wifiloc(validation_set [i,1:520])
}

Calculamos los erroresm asociados a la predicción de cada variable:

#Building
pred$BUILDREAL <- validation_set$BUILDINGID[1:1111]
pred$ERRORBID <- pred$BUILDINGID - pred$BUILDREAL
mean(pred$ERRORBID, na.rm=T)

[1] -0.00540054

buildMAE <- mean(abs(pred$ERRORBID), na.rm=T)
build_confusion <- confusionMatrix(data=pred$BUILDINGID, validation_set$BUILDINGID)
build_confusion

Confusion Matrix and Statistics

          Reference
Prediction   0   1   2
         0 535   6   0
         1   1 301   1
         2   0   0 267

Overall Statistics
                                          
               Accuracy : 0.9928          
                 95% CI : (0.9859, 0.9969)
    No Information Rate : 0.4824          
    P-Value [Acc > NIR] : < 2.2e-16       
                                          
                  Kappa : 0.9886          
 Mcnemar's Test P-Value : NA              

Statistics by Class:

                     Class: 0 Class: 1 Class: 2
Sensitivity            0.9981   0.9805   0.9963
Specificity            0.9896   0.9975   1.0000
Pos Pred Value         0.9889   0.9934   1.0000
Neg Pred Value         0.9982   0.9926   0.9988
Prevalence             0.4824   0.2763   0.2412
Detection Rate         0.4815   0.2709   0.2403
Detection Prevalence   0.4869   0.2727   0.2403
Balanced Accuracy      0.9938   0.9890   0.9981

#Latitud
pred$LATREAL <- validation_set$LATITUDE[1:1111]
pred$ERRORLAT <- pred$LATITUDE - pred$LATREAL
mean(pred$ERRORLAT, na.rm=T)

[1] 1.755398

mean(abs(pred$ERRORLAT), na.rm=T)

[1] 6.257309

rmse_lat <- rmse(pred$LATITUDE, pred$LATREAL)
latitudeRSQ <- 1 - (sum((pred$LATREAL-pred$LATITUDE)^2)/sum((pred$LATREAL-mean(pred$LATREAL))^2))
#Longitud
pred$LONGREAL <- validation_set$LONGITUDE[1:1111]
pred$ERRORLONG <- pred$LONGITUDE - pred$LONGREAL
mean(pred$ERRORLONG, na.rm=T)

[1] -1.371383

mean(abs(pred$ERRORLONG), na.rm=T)

[1] 7.057186

rmse_long <- rmse(pred$LONGITUDE, pred$LONGREAL)
longitudeRSQ <- 1 - (sum((pred$LONGREAL-pred$LONGITUDE)^2)/sum((pred$LONGREAL-mean(pred$LONGREAL))^2))
#Floor
pred$FLOORREAL <- validation_set$FLOOR[1:1111]
pred$ERRORFLOOR <- pred$FLOOR - pred$FLOORREAL
mean(pred$ERRORFLOOR, na.rm=T)

[1] -0.01890189

floor_confusion <- confusionMatrix(data=pred$FLOOR, validation_set$FLOOR)
floor_confusion

Confusion Matrix and Statistics

          Reference
Prediction   0   1   2   3   4
         0 124  21   2   0   1
         1   6 420  20   1   2
         2   2  16 276   6   0
         3   0   5   8 164   3
         4   0   0   0   1  33

Overall Statistics
                                          
               Accuracy : 0.9154          
                 95% CI : (0.8975, 0.9311)
    No Information Rate : 0.4158          
    P-Value [Acc > NIR] : < 2.2e-16       
                                          
                  Kappa : 0.8818          
 Mcnemar's Test P-Value : NA              

Statistics by Class:

                     Class: 0 Class: 1 Class: 2 Class: 3 Class: 4
Sensitivity            0.9394   0.9091   0.9020   0.9535   0.8462
Specificity            0.9755   0.9553   0.9702   0.9830   0.9991
Pos Pred Value         0.8378   0.9354   0.9200   0.9111   0.9706
Neg Pred Value         0.9917   0.9366   0.9630   0.9914   0.9944
Prevalence             0.1188   0.4158   0.2754   0.1548   0.0351
Detection Rate         0.1116   0.3780   0.2484   0.1476   0.0297
Detection Prevalence   0.1332   0.4041   0.2700   0.1620   0.0306
Balanced Accuracy      0.9574   0.9322   0.9361   0.9682   0.9226

Como podemos ver anteriormente, para la predicción del building obtenemos una Accuracy de prácticamente 1, errando solo en 8 casos de 1111. Para la predicción del floor la Accuracy ya es mas baja, de 0,9154. Este error puede ser debido a la confusión que se puede producir en puntos cercanos a huecos de escalera o ascensor, donde la señal de los WAPS de pisos siguientes puede ser bien recibida.

Representamos gráficamente las distribuciones de error para la latitud y la longitud. Observamos también el RMSE de ambas coordenadas.

library(ggplot2)
#Histogramas
hist(pred$ERRORLAT, 
     breaks=60, 
     freq=TRUE,
     xlim = c(-60,60),
     col="#0b87a1",
     main="Distribución de error en la latitud",
     xlab="Error latitud",
     ylab="Frecuencia"
)

hist(pred$ERRORLONG, 
     breaks=120, 
     freq=TRUE,
     xlim = c(-60,60),
     col="#0b87a1",
     main="Distribución de error en la longitud",
     xlab="Error longitud",
     ylab="Frecuencia"
)

rmse_long

[1] 17.02018

rmse_lat

[1] 11.74968

El RMSE de la latitud es 11,75 y el de la longitud es 17,02. Tiene sentido que el de la longitud sea mayor puesto que el conjunto de los edificios es mas extenso en el sentido de coordenadas de la longitud. Una de las fuentes del error puede ser que en el Training Set se han tomado los datos de forma controlada, en puntos concretos, y muchas veces en los mismos puntos, mientras que en el Validation Set las medidas son tomadas de forma aleatoria. Además el Training Set se deja zonas de algun edificio sin cubrir con lo cuál en esas zonas el error es mayor. También, como podemos ver a continuación se observa que es en las esquinas donde se producen mas errores, probablemente debido a la dispersión que provocan las paredes de éstas, haciendo que la senyal de los Waps de una dirección quede atenuada y la trinagulación no pueda ser tan precisa.

outliers_LAT <- subset(pred, ERRORLAT > 15)
p_LAT <- ggplot() + 
  geom_point(data=pred, aes(x=LONGREAL, y=LATREAL), color="grey", size=1) +
  geom_point(data=outliers_LAT,aes(x=LONGREAL, y=LATREAL), color="#003b55", size=2) +
  ggtitle("Outliers latitud") + xlab("Longitud") + ylab("Latitud")
p_LAT

outliers_LONG <- subset(pred, ERRORLONG > 20)
p_LONG <- ggplot() + 
  geom_point(data=pred, aes(x=LONGREAL, y=LATREAL), color="grey", size=1) +
  geom_point(data=outliers_LONG,aes(x=LONGREAL, y=LATREAL), color="#003b55", size=2) +
  ggtitle("Outliers longitud") + xlab("Longitud") + ylab("Latitud")
p_LONG

p <-  ggplot() + 
  geom_point(data=pred, aes(x=LONGREAL, y=LATREAL), color="grey", size=1) +
  geom_point(data=outliers_LONG,aes(x=LONGREAL, y=LATREAL), color="#003b55", size=2) +
  ggtitle("Outliers longitud") + xlab("Longitud") + ylab("Latitud") +
  geom_point(data=pred, aes(x=LONGREAL, y=LATREAL), color="grey", size=1) +
  geom_point(data=outliers_LAT,aes(x=LONGREAL, y=LATREAL), color="#003b55", size=2)

Finalmente quiero comentar algunas opciones para mejorar el modelo. La primera es normalizar por filas la señal de los Waps para predecir la latitud y la longitud, puesto que así se pierde variabilidad y se equiparan los valores máximos recibidos en cada registro si son recibidos por el mismo WAP. Otra opción es incorporar datos del Validation Set para entrenar los modelos, cubriendo con éste las zonas que no se cubren con el Training Set. Otra opción sería probar otros algoritmos como el KNN, que si bien nos dan un RMSE mayor porqué los outliers son mayores, también predice mas cantidad de puntos correctamente, siendo la dsitribución de error antes expuesta mas estrecha y alta en el medio. Se podrían combinar ambos algoritmos, usando primero el KNN y despues usando el Random Forest para la predicción de esos puntos que sean muy mal predichos con el KNN.