problemas de procesamiento

Vista previa del material en texto

UNIVERSIDAD NACIONAL DEL ALTIPLANO
 		FACULTAD DE INGENIERÍA MECANICA 
 ELECTRICA, ELECTRONICA Y SISTEMAS
 ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
 CURSO:
 Paralelismo, Concurrencia y Sistemas Distribuidos
 TEMA:
 Problemas de Procesamiento Distribuido
	PRESENTADO POR:	
· Villalta Quispe, Emerson Edward
· Quispe Quispe, Néstor Armando
· Quispe Condori, Milagros Yesenia
 DOCENTE:
 Ing. Donia Alizandra Ruelas Acero
 
 SEMESTRE: 
 Octavo
 PUNO – PERÚ
 2021
WORD COUNT 
Word Count es la cantidad de palabras en un documento o pasaje de texto. El conteo de palabras puede ser necesario cuando se requiere que un texto se mantenga dentro de cierto número de palabras. Este puede ser particularmente el caso en la academia , los procesos legales, el periodismo y la publicidad . Los traductores suelen utilizar el recuento de palabras para determinar el precio de un trabajo de traducción.
El Problema Word Count, consiste realizar conteo de palabras en archivos por lo que permite el conteo de palabras en cualquier tamaño del archivo a leer y contar palabras
El código que se menciona a continuación esta realizado en Python.
Código: 
filename = "words.txt"
numlineas = 0
numpalabras = 0
numletras = 0
with open(filename, 'r') as file:
	for linea in file:
		listapalabras = linea.split()
		numlineas+=1
		numpalabras+=len(listapalabras)
		numletras+=len(linea)
print("lineas: %i\npalabras: %i\ncaracteres: %i" %(numlineas,numpalabras,numletras))
Ejecución con el archivo “elquijote.txt”
Ejecución con un archivo menor “words.txt”
INVERTED INDEX
Un índice invertido es una forma de estructurar la información que va a ser recuperada por un motor de búsqueda. Por tanto, el objetivo es crear la estructura de datos para llevar a cabo una búsqueda de texto completa.
En un índice invertido, el buscador crea los índices, o términos de búsqueda, a partir de una serie de documentos, indicando el o los documentos que los contienen.
De esta manera, cuando el usuario teclea un término de búsqueda determinado, el buscador le indica los documentos que contienen dicho término.
¿Cómo funciona?
Por ejemplo, supongamos un buscador que obtiene los índices, es decir, los términos de búsqueda, a partir de 2 documentos que contienen diferentes textos.
· Documento 1: "Salvador Dalí nació en Figueras."
· Documento 2: "Figueras es una ciudad de Gerona."
El buscador creará un índice con las diferentes palabras que aparecen, indicando el documento en el que aparece. Generalmente, se excluirán algunas palabras (“en”, “de”, …).
	Id
	Palabra
	Documento nº
	1
	Salvador
	1
	2
	Dalí
	1
	3
	nació
	1
	4
	Figueras
	1,2
	5
	ciudad
	2
	6
	Gerona
	2
En este tipo de índice, los términos y su Índice no están predeterminados, por el contrario se elaboran una vez el buscador ha analizado los documentos que se le han proporcionado. Esta característica diferencia un índice invertido respecto al índice de una base de datos tipo SQL.
Este es el tipo de indexación que usan los buscadores, ya que permite una rápida búsqueda en documentos de texto. El índice, además de indicar el documento donde aparece un término de búsqueda dado, podría contener otra información, por ejemplo, la frecuencia de aparición del término, o el lugar del documento donde aparece.
Código en C++
#include <algorithm>
#include <fstream>
#include <iostream>
#include <vector>
#include <string>
 
const std::string _CHARS = "abcdefghijklmnopqrstuvwxyz0123456789.:-_/";
const size_t MAX_NODES = 41;
 
class node
{
public:
 node() { clear(); }
 node( char z ) { clear(); }
 ~node() { for( int x = 0; x < MAX_NODES; x++ ) if( next[x] ) delete next[x]; }
 void clear() { for( int x = 0; x < MAX_NODES; x++ ) next[x] = 0; isWord = false; }
 bool isWord;
 std::vector<std::string> files;
 node* next[MAX_NODES];
};
 
class index {
public:
 void add( std::string s, std::string fileName ) {
 std::transform( s.begin(), s.end(), s.begin(), tolower );
 std::string h;
 for( std::string::iterator i = s.begin(); i != s.end(); i++ ) {
 if( *i == 32 ) {
 pushFileName( addWord( h ), fileName );
 h.clear();
 continue;
 }
 h.append( 1, *i );
 }
 if( h.length() )
 pushFileName( addWord( h ), fileName );
 }
 void findWord( std::string s ) {
 std::vector<std::string> v = find( s );
 if( !v.size() ) {
 std::cout << s + " ¡no fue encontrado!\n";
 return;
 }
 std::cout << s << " encontrado en:\n";
 for( std::vector<std::string>::iterator i = v.begin(); i != v.end(); i++ ) {
 std::cout << *i << "\n";
 }
 std::cout << "\n";
 }
private:
 void pushFileName( node* n, std::string fn ) {
 std::vector<std::string>::iterator i = std::find( n->files.begin(), n->files.end(), fn );
 if( i == n->files.end() ) n->files.push_back( fn );
 }
 const std::vector<std::string>& find( std::string s ) {
 size_t idx;
 std::transform( s.begin(), s.end(), s.begin(), tolower );
 node* rt = &root;
 for( std::string::iterator i = s.begin(); i != s.end(); i++ ) {
 idx = _CHARS.find( *i );
 if( idx < MAX_NODES ) {
 if( !rt->next[idx] ) return std::vector<std::string>();
 rt = rt->next[idx];
 }
 }
 if( rt->isWord ) return rt->files;
 return std::vector<std::string>();
 }
 node* addWord( std::string s ) {
 size_t idx;
 node* rt = &root, *n;
 for( std::string::iterator i = s.begin(); i != s.end(); i++ ) {
 idx = _CHARS.find( *i );
 if( idx < MAX_NODES ) {
 n = rt->next[idx];
 if( n ){
 rt = n;
 continue;
 }
 n = new node( *i );
 rt->next[idx] = n;
 rt = n;
 }
 }
 rt->isWord = true;
 return rt;
 }
 node root;
};
int main( int argc, char* argv[] ) {
 index t;
 std::string s;
 std::string files[] = { "Mila1.txt", "Nestor2.txt", "Edward3.txt" };
 
 for( int x = 0; x < 3; x++ ) {
 std::ifstream f;
 f.open( files[x].c_str(), std::ios::in );
 if( f.good() ) {
 while( !f.eof() ) {
 f >> s;
 t.add( s, files[x] );
 s.clear();
 }
 f.close();
 }
 }
 
 while( true ) {
 std::cout << "Ingrese una palabra para buscar, regrese para salir: ";
 std::getline( std::cin, s );
 if( !s.length() ) break;
 t.findWord( s );
 
 }
 return 0;
}
Contenido de los txt
Compilando
PROBLEMAS QUE TUVIMOS EN EL PROCESO DEL DESARROLLO.
Se lanza la instancia EC2 con clave sistemas2.ppk
*****PLAY***** Se coloca el putty para ingresar al problema
Error en la entrada de usuario se puso: Ubuntu; y es ubuntu
Se verifica la version
Por ser iniciada otra vez al momento me pidió reconocer el JAVA_HOME y poner la correcta exportación
Se configura y se guarda el archivo xml
Se crea la clave de imagen en ssh
Se obtiene un permiso denegado al tratar de conectarse ya que me dice permiso denegado por lo cual se hace otra vez sobre el permiso.
Ya en esta imagen hicimos la corrección de los archivos xml; guardando correctamente con control C y de ahí “:wq” para guardar y salir
Ahora me indica que no se encuentra el archivo el cual quiero autorizar
En esta imagen se coloca el JAVA_HOME por defecto pero un error minimo que se cometio a la hora de trabajar fue que no se borró el # por lo que me genero más problemas 
En la imagen el error era a la hora de conectarse en los puertos localhost y los namenodes donde decían que no existía el JAVA_HOME 
Al no ver el # se hizo otra vez los documentos al punto de hacer el mismo procedimientovarias veces y no obtener una respuesta a eso
Por lo que después de se optó por repetir los pasos otra vez y así tener una nueva instancia correctamente ya sabiendo que errores no cometer
A la segunda instancia nueva
Ya completamente conectada y con sus seguridad y reglas probadas
Hasta ese punto todo ya iba correctamente pero de ahí a la hora de ingresar los archivos nuevos tenia varios errores 
Se crearon carpetas nuevas “prueba” y “prueba2”
Se quiso subir un archivo a partir de ahí pero no quiso subir el .txt con el que se probaría los códigos 
Como se ve, creamos un archivo prueba.txt el cual tenía algo como “hola hadoop” para poder ingresar el archivo, de ahí se usó -cup pero tampoco lo añadió a ninguna prueba.
Al final me da todos los códigos concluyendo que no se puede subir tampoco de esa forma
Después de varias configuraciones con hadoop/bin/hdfs dfs -cup prueba.txt /user/ubuntu/
Y luego al no poder obtener, se tomaron varias formas que practicamente era combinaciones entre ellas solo hacer “hdfs dfs -cup -f …” que tampoco cargaba el archivo a subir; los códigos eran con mapreduce y varias formas de hacer un conteo de palabras.
Tambié se vió el conteo de palabras que viene por defecto en los archivos el cual es con JAVA y pero no lo hicimos ese código creyendo que tal vez sería una copia y no algo hecho por nosotros.