5- Indique que tarea realiza el siguiente programa de Spark Scala e indique como se podría
modificar par eliminar la string “cuentas” cada vez que aparezca.
val counts = [Link](_.replaceAll("[.,]", ""))
.map(_.replaceAll("-", ""))
.flatmap(line => [Link](" "))
.map(word => (word, 1))
.reduceByKey(_+_)
.sortBy(_._2)
.collect
Agregar antes del collect la siguiente línea
.filter((x:String) => x!="cuentas"
Este programa es un contador de palabras. Básicamente lo que hace es eliminar las comas,
puntos y demás estructuras que no sean palabras, para luego contar cada palabra cuantas
veces esta repetida en el texto.
3- Describa las principales ventajas de usar un sistema de análisis de Spark Scala, así como las
principales diferencias frente a los sistemas basados en R.
Apache Spark es un sistema informático distribuido de código abierto que se utiliza para el
procesamiento y análisis de big data. Está diseñado para trabajar con grandes conjuntos de datos
y proporcionar un procesamiento rápido y eficiente. Spark admite varios lenguajes de
programación, incluidos Python, Scala y R. Cada uno de estos lenguajes tiene sus ventajas y
desventajas cuando se usa con Spark.
Python es una opción popular para trabajar con Spark debido a su simplicidad, facilidad de uso
y la gran cantidad de bibliotecas y marcos disponibles. La API de PySpark permite a los
desarrolladores de Python interactuar con Spark de manera fácil y eficiente. Python tiene una
amplia colección de marcos y bibliotecas de ciencia de datos como NumPy, Pandas y Scikit-learn,
lo que lo convierte en una excelente opción para la preparación de datos, la limpieza de datos y
la ingeniería de características.
Scala, por otro lado, es un lenguaje de programación que está diseñado para ejecutarse en JVM
(Java Virtual Machine) y es conocido por su velocidad y escalabilidad. Spark está escrito en Scala
y, por lo tanto, Scala se considera el idioma nativo de Spark. Scala es ideal para desarrollar
aplicaciones informáticas distribuidas de alto rendimiento y es particularmente útil para el
procesamiento de big data.
R es un lenguaje de programación comúnmente utilizado para el análisis estadístico y la ciencia
de datos. R tiene una amplia variedad de paquetes y bibliotecas disponibles para el aprendizaje
automático, el modelado estadístico y la visualización de datos, lo que lo convierte en una
excelente opción para el análisis de datos y las tareas de aprendizaje automático.
Cuando se trata de elegir el mejor lenguaje para Spark, hay varios factores a considerar. Si ya está
familiarizado con un idioma en particular, podría ser una buena idea quedarse con ese idioma.
Si buscas simplicidad y facilidad de uso, Python es una excelente opción. Si necesita escalabilidad
y computación de alto rendimiento, Scala podría ser la mejor opción. Si ya tiene experiencia en
R y prefiere usarlo, entonces R podría ser la mejor opción para usted.
En general, no existe una respuesta única sobre qué idioma es el mejor para Spark. La elección
depende de sus requisitos y preferencias específicas. Sin embargo, Python y Scala son los
lenguajes más populares para Spark debido a su simplicidad, facilidad de uso y escalabilidad. Es
fundamental elegir el idioma que mejor se adapte a usted y a las necesidades de su proyecto,
teniendo en cuenta su familiaridad con el idioma, los requisitos de rendimiento y la
disponibilidad de bibliotecas y marcos.
4- Indique que para que tareas y fases utilizarías tanto Apache NIFI y Kafka en un sistema de
Big Data que recibe los ficheros de todos los semáforos de una ciudad inteligente y los
almacena en una base de datos NoSQl.
Los ficheros serán trasladados con Apache nifi, quien los va a tratar y entregar a Kafka quien por
último lo almacenará en la base de datos NoSQL.
¿Para qué se utiliza Apache NiFi?
• Transferencia confiable y segura de datos entre sistemas
• Entrega de datos de fuentes a plataformas analíticas
• Enriquecimiento y preparación de datos:
• Conversión entre formatos
• Extracción/Análisis
• Decisiones de enrutamiento
Apache Kafka
• Apache Kafka es un sistema de mensajería de publicación y suscripción distribuida. Él
está diseñado para soportar lo siguiente
• Mensajería persistente con estructuras de disco O(1) que proporcionan tiempo constante
rendimiento incluso con muchos TB de mensajes almacenados.
• Alto rendimiento: incluso con hardware muy modesto, Kafka puede admitir
cientos de miles de mensajes por segundo.
• Soporte explícito para particionar mensajes en servidores Kafka y distribuir
consumo sobre un grupo de máquinas de consumo mientras se mantiene la perpartición
ordenar la semántica.
• Soporte para carga de datos en paralelo en Hadoop.
Enunciado común problemas 1 y 2:
• La función agrupa, toma una lista L y un elemento E. Dicha función intenta dividir L en
dos sublistas, de las siguientes forma: si los primeros elementos coinciden con E,
devuelve una nueva lista con dichos primeros elementos agrupados por un lado y el
resto de los elementos en otro (es decir, se genera una lista con dos elementos, que
son listas a su vez). Si los primeros elementos No coinciden con el dado, devuelven la
lista original por ejemplo:
(agrupa (list a a b b a a) a) // devuelve ( ( a a) (b b a a))
( agrupa (list a a b b a ) b) // devuelve (a a b b a)
Nota: En el segundo caso no ha agrupado elementos por que los primeros no coinciden con b
• La función seguidos, que a partir de una lista determina el número de repeticiones
consecutivas de elementos que hay en una lista. Por ejemplo:
(seguidos (list a a b b c c c b a a a )) // devuelve (2 2 3 1 3)
• La función length devuelve el número de elementos en una lista
1- Escriba en LISP
- La función LENGTH
- La función SEGUIDOS, suponiendo que ya existe la función AGRUPA
- Función SEGUIDOS
(DEFUN Seguidos (L))
(COND
(NULL (L)) 0)
(EQ (CAR L SECOND L)) (LENGTH(CAR(AGRUPA (L CDR L)) Seguidos (CDR (AGRUPA(L CDR L)))
(T (1 (Seguidos (CDR L)))
- Función LENGTH
(DEFUN LENGHT (L))
(COND
(NULL (L)) 0
(T (1 + LENGTH (CDR L))))
2- Escriba en SCALA, usando programación funcional, la función AGRUPA.
NOTA: el operador e : : L es la concatenación del elemento e a la lista L por delante.
def agrupa( e: Any, lista: List[Any]) : List[Any] = {
lista match{
case head :: tail if (e == head) => [Link]( _ == e).toList
case head :: tail if (e != head) => (head :: tail)
case _ => Nil
}
}
agrupa('a', List('a', 'a', 'a', 'b', 'c'))
agrupa('a' , List('b', 'c', 'a', 'a', 'a'))
