Integrar o PureData System for Analytics e o InfoSphere BigInsights para Análise de Email

Combinar os recursos avançados de analítica de texto do BigInsights com seu warehouse

PureData™ System for Analytics é a principal plataforma de warehousing da IBM. Este artigo explica como integrá-lo ao InfoSphere® BigInsights™, a distribuição Hadoop pronta para empresas da IBM. Vamos discutir os conceitos de integração, assim como um caso de uso primário para essa integração, combinando os recursos avançados de analítica de texto do BigInsights com seu warehouse. Vamos ilustrar como criar um pequeno cenário que enriquece dados de funcionários com informações extraídas por email. Em seguida, vamos demonstrar como extrair essas informações no BigInsights e como fazer upload dos resultados extraídos para o PureData for Analytics. Nós também mostramos como acessar dados armazenados no BigInsights a partir do warehouse para facilitar recursos de drill through.

Benjamin Leonhardi, Software Engineer, IBM

Photo of author Benjamin LeonhardiBenjamin Leonhardi é líder da equipe de ativação de parceiro de Big Data/Warehousing. Antes disso, ele era desenvolvedor de software para o InfoSphere Warehouse no IBM Research And Development Lab Boeblingen, Alemanha. Ele era desenvolvedor nas soluções de mineração de dados, mineração de texto e relatório de mineração.



Piotr Pruski, Technical Enablement Specialist, IBM

Author photoPiotr Pruski é especialista de ativação técnica de Big Data na equipe IBM Information Management Business Partner Ecosystem. Seu principal foco é ajudar a acelerar vendas e sucesso de parceiros buscando e envolvendo parceiros de negócios, permitindo que eles trabalhem com produtos do portfólio de IM ― especificamente, o InfoSphere BigInsights. Em funções anteriores, ele trabalhou com o DB2, o IBM Smart Analytics System 5710 e por pouco tempo com o IBM PureData System for Transactions.



Andre Albuquerque, Technical Enablement Specialist, IBM

Andre AlbuquerqueAndre Albuquerque é líder técnico de Big Data para a equipe IBM Information Management PureData Ecosystems. Ele passou a fazer parte do IBM Canada Labs em 2009 e trabalha com diversos produtos IBM, como o DB2 e a plataforma de big data da IBM. Como líder técnico, ele é o proprietário de conteúdo do Big Data Fundamentals Bootcamp.



26/Nov/2013

Introdução

A integração corporativa é um valor exclusivo da IBM. Alguns dos casos de uso para tecnologias de big data que os clientes têm podem se tornar possíveis somente por meio de integração. Isso requer a integração de informações existentes na empresa com os novos fluxos de informações fora da empresa. Os tipos desejados de analítica não podem ser realizados, a menos que dados estruturados, assim como não estruturados e semiestruturados sejam analisados juntos. Vamos ver aqui que o valor de fontes de dados tradicionais e não tradicionais e tecnologias tradicionais e não tradicionais aumenta quando elas são unidas.

Antes de continuar, observe que cobrimos uma quantidade de terreno bem extensiva neste artigo e omitimos algumas informações que acreditamos que sejam básicas ou fundamentais. Portanto, supomos pelo menos um entendimento rudimentar de BigInsights, AQL, JAQL, PureData System for Analytics e Cognos®. Informações adicionais podem ser localizadas na seção Recursos de todas essas tecnologias.

PureData System for Analytics (Anteriormente Conhecido como Netezza)

O PureData System for Analytics, desenvolvido com tecnologia Netezza, é um aplicativo de dados simples para analítica séria. Ele simplifica e otimiza desempenho de serviços de dados para aplicativos analíticos, permitindo que algoritmos complexos sejam executados em minutos em vez de em horas. Você pode conhecer o PureData System for Analytics como Netezza Appliances. O produto foi renomeado e poderemos usar os dois nomes um pelo outro.

Destaques:

  • Velocidade— 10-100 vezes mais rápido do que o sistema customizado tradicional
  • Simplicidade— Configuração rápida, fácil para uma experiência do usuário simplificada
  • Escalabilidade— Capacidade de dados do usuário em escala peta.
  • Inteligente— Algoritmos complexos em minutos; biblioteca rica de analítica integrada

InfoSphere BigInsights

O InfoSphere BigInsights ajuda as empresas a analisarem e descobrirem insights de negócios ocultos em grandes volumes de dados brutos, como logs da web, fluxos de cliques, feeds de notícias, sites de redes sociais, dados de sensores, email e mensagens instantâneas. O BigInsights complementa sua infraestrutura de gerenciamento de informações existentes, incluindo data warehouses e ferramentas analíticas, estendendo seus recursos analíticos para incluir uma maior variedade e volume de dados em rápida alteração.

Destaques:

  • Permite que as empresas explorem rapidamente grandes volumes de dados brutos para obter insight em desafios operacionais que eram anteriormente muito grandes ou complexos para enfrentar.
  • Processa vários dados, incluindo formatos não estruturados e semiestruturados frequentemente ignorados por tecnologias tradicionais. Esses dados podem estar "bagunçados" e conter estruturas variadas com inter-relacionamentos potencialmente complexos.
  • Permite analítica de classe corporativa com escalabilidade massiva em hardware de mercadoria de baixo custo.
  • Aprimora e integra-se a software de gerenciamento de informações popular, incluindo data warehouses, DBMSes relacionais, plataformas de fluxo de dados, ferramentas de business intelligence e mais.

Integração

O gráfico a seguir descreve a visualização base do data warehouse e do BigInsights para este artigo.

Data Warehouse e BigInsights Comparados
Armazém de DadosBigInsights
Tipos de dadosDados estruturadosQualquer tipo de dados, estruturado ou não estruturado
Carregamento de dadosDados são limpos/estruturados antes de entrarem no warehouse para maximizar seu utilitário.Dados brutos podem ser armazenados no estado em que se encontram, sem qualquer modificação, preservando fidelidade e linhagem.
Abordagem analítica
  • Dados estruturados de alto valor
  • Operações e processos repetidos (por exemplo, transações, relatórios, BI etc.)
  • Fontes relativamente estáveis
  • Requisitos bem entendidos
  • Otimizado para acesso e análise rápidos
  • Dados e conteúdo altamente variáveis; alguns podem ser de alto valor
  • Análise iterativa, exploratória (por exemplo, pesquisa científica, modelagem comportamental)
  • Fontes voláteis
  • Perguntas ad hoc e requisitos em mudança
  • Otimizado para flexibilidade
HardwareDispositivo eficiente e sistemas otimizadosHardware de mercadoria não dispendioso

Uma plataforma e abordagem de big data efetivas requerem integração ao restante de sua infraestrutura de TI. A última coisa necessária em sua arquitetura é outra tecnologia ou silo de dados. As tecnologias de big data devem funcionar em tandem com e estender o valor de suas tecnologias analíticas e de data warehouse existentes.

O seguinte será nossa base para o restante deste artigo e por que desejamos e precisamos atingir essa integração.

O PureData System for Analytics pode processar terabytes de dados estruturados, mas tem recursos não estruturados limitados. O InfoSphere BigInsights tem limitações ao processar informações estruturadas, mas ele realmente brilha para analítica não estruturada. Ao combinar os pontos fortes dos dois sistemas, podemos:

  • Analisar grandes quantias de dados não estruturados no BigInsights e gravar os resultados estruturados no PureData System for Analytics ou ler os mesmos on demand com UDFs do Netezza.
  • Use soluções de relatórios padrão para acessar o PureData System e enriquecer relatórios estruturados (OLAP, por exemplo) com informações não estruturadas.

Usar Descrição de Caso

A figura a seguir demonstra o caso de uso no qual vamos basear nosso cenário de integração.

Caso de Uso de Integração do BigInsights e PureData System for Analytics

A demo mostra a integração do PureData System for Analytics e do BigInsights e usa o Cognos como um front-end. Os registros de funcionários são armazenados no PureData System for Analytics e email é armazenado e analisado no BigInsights. Um anotador AQL pontua o email como comercial ou particular. AQL é a annotated query language, uma linguagem de programação semelhante a SQL usada para a extração de informações estruturadas do texto. Os resultados da pontuação são, então, transferidos por upload do BigInsights para o PureData System for Analytics por meio de um módulo JAQL Netezza. Os resultados são agregados e mostrados em um relatório Cognos (funcionários e seu número de email particular e comercial). O relatório também permite um drill through nos textos de email subjacentes, que são, então, recuperados do BigInsights. Isso usa a funcionalidade do conector Netezza BigInsights para ler de HDFS.


Análise de Documento

Aqui, descrevemos como criar um anotador AQL simples e usá-lo para extrair informações estruturadas de um conjunto de documentos. Vamos primeiramente descrever como criar um anotador AQL simples que possa distinguir email comercial de email particular. A próxima etapa é importar o email para o BigInsights. Em seguida, usamos um script JAQL para anotar os documentos e fazer upload dos resultados no PureData System for Analytics.

Isso contém a parte do BigInsights de nossa integração, mas ainda precisaremos criar um recurso de drill through do relatório Cognos para os dados de email subjacentes. Para fazer isso, precisamos ser capazes de acessar o sistema de arquivos HDFS a partir do data warehouse do PureData System for Analytics. Isso é obtido por meio da extensão Netezza UDF enviada com o InfoSphere BigInsights. Vamos descrever o processo de instalação e mostrar uma possibilidade de implementar a função de drill through.

Abrangemos muito conteúdo, portanto, a implementação será muito simplificada. Planejamos fornecer mais detalhes e alternativas para algumas das etapas descritas em artigos futuros.

Desenvolvimento do Anotador AQL

Vamos descrever resumidamente como desenvolver um anotador AQL baseado em dicionário que possa distinguir entre email comercial e particular. Esse anotador pode ser usado para, por exemplo, identificar emails relacionados não comerciais que não precisam ser arquivados, reduzindo, assim custos de backup. Como somos limitados pelo escopo do artigo, vamos usar somente uma pequena parte dos recursos de AQL; a intenção é fornecer uma ideia do que é possível. Seu ambiente de desenvolvimento será parecido com o seguinte.

InfoSphere BigInsights Development Studio

Nosso anotador terá dois dicionários que contêm palavras indicativas de email particular e comercial. Em uma segunda etapa, vamos usar AQL para contar todas as ocorrências de ambas as categorias de palavras e, por fim, calcular um único número, ou uma pontuação total, para cada email. Identificar um email como particular, o que significa mais palavras particulares do que comerciais, irá gerar um número negativo, enquanto que um email comercial com mais palavras comerciais do que palavras particulares irá gerar um número positivo. Também vamos demonstrar a criação de um AQL Java™ UDF, já que AQL mão tem sua própria função de subtração. Todavia, é trivial implementar esses tipos de funcionalidade em tecnologia Java.

É claro que cada conjunto de emails pode ter diferentes requisitos, portanto, usamos um conjunto de treinamento de mensagens de emails que foram divididas manualmente em email comercial e particular; neste exemplo limitado, há aproximadamente 10 para cada. A partir deles, identificamos as listas de palavras e criamos os dicionários. Supomos que temos um conhecimento fundamental de AQL e do ambiente de desenvolvimento. É possível localizar detalhes e exemplos adicionais na seção Recursos .

AQL é uma linguagem modular, portanto, criamos um projeto com dois módulos: Common e Email. Common é usado para definir os UDFs que podemos querer reutilizar em outros projetos. Nós, então, usamos ele no módulo Email principal para extrair a pontuação de email.

Desenvolvendo o UDF de subtração

Para calcular a pontuação total, é necessário implementar um Java UDF que pode subtrair dois números inteiros. Isso pode ser implementado no mesmo projeto no qual você implementar seu AQL já que um projeto Eclipse do BigInsights é derivado de um Projeto Eclipse Java. A seguir está o código de nosso UDF:

package com.ibm.imte.taudfs;

public class Sub {
	public Integer sub(Integer i, Integer j) {
		return i - j;
	}
}

Em seguida, criamos um módulo AQL chamado Common que implementa essa função e exporta a mesma para uso em outros módulos. Abaixo está o código-fonte desse módulo. Também compilamos o código Java acima em um JAR e colocamos o mesmo na mesma pasta do módulo. Essa pasta está automaticamente no caminho de classe do código AQL.

module Common;

create function sub(i Integer ,  j Integer)
return Integer
external_name 'udfs.jar:com.ibm.imte.taudfs.Sub!sub'
language java 
deterministic
return null on null input;

export function sub;

Como exportamos a função, agora podemos importar e usar essa função em outros módulos AQL. Uma melhor prática é colocar todos os seus UDFs em um módulo separado.

Na segunda etapa, vamos utilizar dois dicionários contendo palavras que indicam email particular ou comercial. Observe que não estamos almejando 100 por cento de precisão. Haverá algumas situações em que palavras comerciais são usadas em email particular e vice-versa, mas calculamos um número total no fim de cada documento. AQL também fornece muitas opções para filtrar resultados e aprimorar a precisão do anotador. No entanto, para este pequeno exemplo, vamos utilizar uma abordagem muito básica. Aqui estão entradas de amostras nos dicionários.

Dicionário private.dict

mom
sister
love
party
sister
happy easter
christmas
x-mas
...

Dicionário work.dict

business unit
invoice
sap
sybase
database
it system
solution area
kick-off
workshop
reporting solution
...

Agora precisamos criar o módulo principal chamado Emails. Na pasta dictionary deste módulo, incluímos os dois arquivos de dicionários mostrados acima. Agora, podemos codificar o anotador no arquivo AQL principal. Primeiro, precisamos incluir um identificador de módulo e importar o módulo Common que criamos antes.

module Emails;

import module Common;

Agora precisamos importar o dicionário particular e criar uma visualização AQL dos documentos, extraindo todas as ocorrências do dicionário no documento. Para obter informações adicionais sobre AQL, consulte Recursos.

create dictionary PrivateDict
from file 'dictionaries/private.dict'
with language as 'en';

create view PrivateWords as
extract dictionary 'PrivateDict' 
	on R.text as match
from Document R;
output view PrivateWords;

De forma semelhante, repetimos isso para o dicionário comercial.

create dictionary WorkDict
from file 'dictionaries/work.dict'
with language as 'en';

create view WorkWords as
extract dictionary 'WorkDict' 
	on R.text as match
from Document R;
output view WorkWords;

Não estamos interessados nas instâncias reais, mas queremos ter um único número, portanto, podemos contar o número de provas para cada palavra localizada. AQL é muito semelhante a SQL, portanto, podemos simplesmente calcular uma contagem nas duas visualizações: WorkWords e PrivateWords.

create view NumPrivateWords as 
select Count(P.match) as num from PrivateWords P;
output view NumPrivateWords;

create view NumWorkWords as 
select Count(W.match) as num from WorkWords W;
output view NumWorkWords;

Agora temos o número de provas de palavras particulares e comerciais para cada email. Na próxima etapa, queremos criar uma pontuação simples para o email, portanto, vamos subtrair o número de provas particulares do número de provas comerciais. Se houver predominantemente provas comerciais, a pontuação será positiva. Se houver predominantemente provas particulares, a pontuação total será negativa. Para calcular a diferença, vamos usar nosso AQL UDF definido antes. Por fim, emitimos a saída da visualização TotalScore, para que possamos usá-la externamente em programas Java e JAQL. Isso é diferente de da instrução de exportação, que é usada para dependências de módulos.

create view TotalScore as
select Common.sub(w.num, p.num) as totalscore
from NumWorkWords w, NumPrivateWords p;

output view TotalScore;

Agora criamos nosso anotador simples e podemos testá-lo no ambiente de desenvolvimento usando a visualização extraction plan. Como podemos ver nos resultados, temos um anotador funcional que identifica todas as 10 mensagens de email comerciais de amostra como comerciais e todos os emails particulares como particulares.

Resultado da Execução de AQL

Por fim, precisamos exportar o anotador de AQL gerado como arquivos TAM. Usar Export > BigInsights > Export Text Analytics Extractorirá criar dois arquivos TAM para ambos os módulos. Para utilizá-los com JAQL, precisamos copiar esses arquivos para o BigInsights. Para o propósito deste artigo, vamos supor que estejam na pasta /home/biadmin/nz-demo/Annotator. Na seção a seguir, vamos usar JAQL para executar esse anotador em um conjunto de mensagens der email armazenadas em um cluster do BigInsights.

Importando Dados para o BigInsights

Agora que criamos o anotador AQL, precisamos importar os dados de emails para o BigInsights. Há muitas maneiras de atingir isso. Essencialmente, precisamos assegurar que os dados estejam armazenados em arquivos grandes e possam ser divididos para que possam aproveitar a arquitetura Hadoop. Também precisamos manter a capacidade de associar um ID de email a cada texto de email. Para aproveitar a arquitetura paralela em Hadoop, os arquivos precisam ser divisíveis. Isso significa que os carregadores de arquivos podem dividir o arquivo em diversos blocos. Arquivos que têm novas linhas são automaticamente divisíveis. Diversos arquivos em uma pasta compactada também são divisíveis, desde que um formato de armazenamento divisível, como lzo, seja usado.

Em nosso exemplo, vamos usar arquivos delimitados separados por vírgula que têm duas colunas: ID e TEXT. Colocamos todos os caracteres de nova linha nas mensagens de email com espaços, já que isso não influencia nossos anotadores. Pode ser necessário escapar esses caracteres de forma diferente se novas linhas forem importantes para sua análise.

Em muitas situações, você terá um conjunto de arquivos, cada um contendo um documento de texto como um email. Em nosso exemplo, usamos um script Perl simples para transformá-los em um arquivo delimitado. Como alternativa, JAQL pode manipular conjuntos de arquivos também, mas isso estaria além do escopo deste artigo. Nosso arquivo de dados para o seguinte: um arquivo delimitado com uma linha por email e duas colunas: LABEL e TEXT. LABEL é um ID de email exclusivo usado para associar o email a um funcionário e um campo de texto que contém o conteúdo do email.

1|Message-ID: <29394058.1075855815542.JavaMail@test> Date: Mon, 5 Jun...     
2|Message-ID: <9986382.1075855895922.JavaMail@test> Date: Wed, 16 Aug...
...

O comando JAQL a seguir carrega o arquivo no HDFS:

read(del("file:///home/biadmin/nz-demo/combinedEmails.txt", 
	{schema: schema{label, text}, delimiter: "|", quoted: false})) 
-> write(del("hdfs:/tmp/emails.del", 
	{schema: schema{label, text}, delimiter: "|", quoted: false}));

Decidimos manter o arquivo em HDFS como um arquivo delimitado descompactado. Para melhor desempenho e uma área de cobertura de armazenamento menor, podemos compactá-lo durante o carregamento. Para melhor desempenho, também armazenaríamos o arquivo como um arquivo de sequência. Os arquivos de sequência são arquivos JSON nativos e aumentam as velocidades de carregamento de arquivo, pois, essencialmente, armazenam arquivos na representação de dados interna de JAQL. No entanto, os arquivos de sequência não são legíveis para o ser humano, portanto, não os usamos para esta demo. Observe a sintaxe para especificar o esquema de arquivo e o formato de arquivo. Para obter uma documentação completa desses recursos, consulte o centro de informações (consulte Recursos).

Analisando Documentos com JAQL

Agora precisamos anotar os resultados. Para fazer isso, precisamos importar o módulo systemT. Esse módulo JAQL contém as funções para anotar documentos de texto: import systemT;.

Em seguida, precisamos criar uma variável que especifica como ler o arquivo no HDFS. Como não materializamos o comando com :=, ele será executado somente na etapa de anotação real:

emails = read(del("hdfs:/tmp/emails.del", 
{schema: schema{label, text}, delimiter: "|", quoted: false}));

Agora fazemos a anotação:

textemails = emails -> transform { label: $.label,  score: 
	systemT::annotateDocument( $, ["Common", "Emails"], 
			["file:///home/biadmin/nz-demo/Annotator"], 
			tokenizer="multilingual", 
			outputViews=["Emails.TotalScore"])};

O operador transform em JAQL permite calcular novos campos no fluxo JSON. Especificamos dois campos: Um é o rótulo (nosso ID do email) e o outro campo é calculado por nosso anotador AQL. Para fazer isso, usamos a função systemT::annotateDocument . Isso calcula a pontuação do email que descrevamos na seção AQL e inclui a mesma no rótulo. Usamos a função com as funções a seguir:

  • $: O primeiro parâmetro é o documento que desejamos anotar. Em JAQL, $ denota o documento atual. annotateDocument espera, por padrão, dois campos, label e text.
  • ["Common", "Emails"]: O segundo parâmetro especifica os arquivos TAM que desejamos utilizar. Você especifica os mesmos como um array de cadeia de caractere, em que as cadeias de caracteres são os nomes dos arquivos TAM.
  • ["file:///home/biadmin/nz-demo/Annotator"]: O diretório ou diretórios que contêm os arquivos TAM. Também pode ser uma pasta compactada.
  • tokenizer="multilingual": Esse parâmetro especifica que desejamos usar o tokenizer LanguageWare. Esse é um tokenizer eficiente com análise de sintaxe e suporte a diversas linguagens. Para tarefas simples, o tokenizer de espaço em branco pode ser suficiente, mas, quando em dúvida, use LanguageWare.
  • outputViews=["Emails.TotalScore"]: O último parâmetro especifica quais visualizações de saída nos anotadores queremos incluir nos registros JSON.

Agora, extraímos a pontuação de email e incluímos a mesma nos registros JSON. Os resultados serão semelhantes ao seguinte:

[{ "label": "1",
  "score": {
  	  "Emails.TotalScore": [{"totalscore": -3}],
  	  "label": "8",
  	  "text": "Message-ID: <384643.10758531370..."
  }
},
...
{ "label": "9",
  "score": {
  	  "Emails.TotalScore": [{"totalscore": -4}],
  	  "label": "9",
  	  "text": "Message-ID: <8489243.10758620563..."
  }
}]

Como é possível visualizar, os resultados são incluídos como subarrays no fluxo. Isso é necessário porque uma visualização de saída AQL normalmente tem mais de um resultado. Pode haver diversas pessoas, endereços etc. no arquivo de texto. Em nosso exemplo, agregamos um número total, portanto, sempre teremos somente um único resultado final. Também queremos poder carregar os resultados em uma tabela de banco de dados Netezza. Para obter isso, precisamos simplificar o array (ou seja, queremos ter uma lista de IDs de email e suas respectivas pontuações em uma tabela simples). Isso pode ser obtido em JAQL com o comando expand unroll . Ele moverá o subarray um nível para cima e criará uma linha de resultado pai para cada linha do subarray.

scoredemails =  textemails -> transform {label:$.label, 
				score: $.score."Emails.TotalScore".totalscore, } 
				-> expand unroll $.score 
				-> transform {label: $.label, score: $.score} ;

Fizemos duas coisas com essa parte do código. Primeiro, nós desenrolamos os subarrays e mesclamos os mesmos ao array pai. Em seguida, usamos transform para alterar a nomenclatura dos campos, de forma que correspondam à nomenclatura da tabela Netezza. Por fim, precisamos gravar os resultados no HDFS, para que possamos posteriormente pegá-los e movê-los para o banco de dados Netezza. Para fazer isso, usamos o comando a seguir.

scoredemails -> write(del("hdfs:/tmp/emails/scoredemails.del", 
		{schema: schema{label, score}, 
		delimiter: "|", quoted: false}));

Agora salvamos um arquivo delimitado simples com duas colunas, ID de email e pontuação calculada, e salvamos o mesmo em HDFS. O arquivo é semelhante ao seguinte:

1|-3
9|-4
10|10
11|19
12|16
13|9
14|16
...

Agora podemos executar o script JAQL completo com jaqlshell -b analyzeemails.jaql. Como alternativa, podemos empacotá-lo como um aplicativo e planejar ou chamar o mesmo por uma API REST.

Upload de Resultados para o PureData System for Analytics

Aqui, descrevemos como fazer upload dos resultados da seção anterior para uma tabela Netezza. Vamos utilizar o conector JAQL Netezza para isso. Como alternativa, também é possível realizar o pull de resultados por Netezza UDFs, que iremos descrever na próxima seção. Mas em nossa demonstração, a análise é um push. Separamos a parte de análise e upload por razões operacionais. Você, é claro, poderia fazer em uma única etapa também.

Precisamos importar o Netezza Connector para nosso script JAQL: import dbms::netezza;.

É claro que é possível usar o módulo DBMS padrão, mas isso não resultará no melhor desempenho. O módulo Netezza utiliza tabelas externas para carregamentos e descarregamentos e utiliza carregamentos paralelos para desempenho ideal. Também é necessário copiar o JAR do driver JDBC Netezza para a pasta JAQL $JAQL_HOME/modules/dbms/netezza ou incluir o local no caminho de classe.

Em seguida, precisamos configurar uma conexão com o banco de dados. Isso requer a função netezza::connect com cadeia de caractere de conexão JDBC e propriedades da conta do usuário. Utilizamos o banco de dados BIGIDEMO para nosso banco de dados de amostras.

db := netezza::connect( 
		url = 'jdbc:netezza://netezza_host:5480/BIGIDEMO', 
		properties = { user: "admin", password: "password"});

Agora precisamos ler o arquivo que criamos anteriormente. Observe que alteramos os nomes dos esquemas. Precisamos carregá-los com os mesmos nomes de colunas usados na tabela Netezza, incluindo distinção entre maiúsculas e minúsculas.

tblData = read(del("hdfs:/tmp/emails/scoredemails.del", 
			   {schema: schema{EMAIL_ID: long, WORK_PRIVATE: long}, 
			   	delimiter: "|", quoted: false}));

Agora precisamos preparar a instrução insert . Ela funciona de forma semelhante a JDBC. Especificamos a conexão com o banco de dados e o nome da tabela para a inserção: dataIn = netezza::prepareInsert( db, 'EMAIL_SCORE' );.

Devido à arquitetura exclusiva do PureData System for Analytics, não há necessidade de especificar contagens de confirmação ou de quaisquer outros parâmetros. JAQL irá carregar os dados automaticamente em quatro carregamentos paralelos, dividindo os dados no ID da fatia de dados. É possível especificar divisões, que definem o número em que as partes dos dados estão divididas. Isso é útil se dados carregados forem usados para cálculos adicionais. Esse seria encadeamento único se nenhuma divisão fosse definida. Para nosso upload não precisamos deles.

Por fim, podemos executar o upload com o fluxo do arquivo de email na instrução de inserção: tblData -> write( dataIn );.

Concluímos o upload de nossos dados no PureData System for Analytics. Precisamos implementar uma função drill down nas próximas seções. Para fazer isso, precisamos truncar o campo de texto, para que o PureData System for Analytics possa carregar os campos de texto. O PureData System for Analytics tem um limite superior de 64.000 bytes para campos de caracteres normais e 16.000 bytes para campos NCHAR unicode. Para truncar o campo de texto, usamos a função de subsequência.

read(del("hdfs:/tmp/emails.del", 
	{schema: schema{label, text}, delimiter: "|", quoted: false}))
	->transform {ID: toNumber($.id), TEXT: substring($.text, 0, 15000)} 
	-> write(del("hdfs:/tmp/email_text.del", 
		{schema: schema{ID, TEXT}, 
		delimiter: "|",quoted:true}));

Fizemos upload da pontuação de email para uma tabela Netezza e preparamos o arquivo de email para drill through. Agora podemos executar o script JAQL completo com jaqlshell -b uploadscoring.jaql.

Instalação de Netezza UDFs

Aqui, vamos descrever como instalar Netezza UDFs. Essas funções definidas pelo usuário permitem acessar um sistema BigInsights a partir do PureData System for Analytics. Três funções são fornecidas:

  • HDFS_READ: Essa função permite ler arquivos do sistema de arquivos HDFS remoto.
  • HDFS_WRITE: Essa função permite gravar arquivos em HDFS.
  • JAQL_SUBMIT: Essa função executa uma cadeia de caractere JAQL no BigInsights.

É possível localizar o instalador para Netezza UDFs na página de boas-vindas do console da web do BigInsights. Faça download dos mesmos e copie-os para o host PureData System for Analytics. Em seguida, instale as extensões Netezza com o script install.sh na pasta scripts do pacote de instalação.

Isso descompacta os UDFs e coloca os mesmo na pasta Netezza extension. Ainda precisamos implementá-los em um banco de dados. Em nosso exemplo, criamos um banco de dados chamado BIGIDEMO, que contém nossas tabelas de amostra. Para implementar os UDFs nesse banco de dados e especificar parâmetros de conexão para a conexão, é possível utilizar o comando a seguir. Irá implementar os UDFs e armazenar as informações de conexão para o servidor BigInsights. Você poderia conectar a dois servidores BigInsights diferentes instalando-os em bancos de dados separados.

./nzbiuser --user admin --pw password --db bigidemo 
			--bilocation http://bi_host:8080 
			--biuser biadmin --bipw password

Os Netezza BigInsights UDFs agora estão implementados e prontos para serem usados. Observe que a função JAQL_SUBMIT usa o aplicativo ad hoc JAQL no BigInsights, portanto, é necessário ter esse aplicativo implementado para usar esse UDF.

Desenvolvimento da Função Drill Down

Aqui, descrevemos como desenvolver a função drill down que permitirá selecionar um funcionário específico no relatório Cognos e que carregará as mensagens de email correspondentes do BigInsights. Com isso, teremos mostrado a integração do BigInsights e do PureData System for Analytics em ambos os diretórios. Transferimos por upload as informações do BigInsights para o PureData System for Analytics nas seções anteriores e agora vamos conectar do PureData System for Analytics ao BigInsights. A função que usamos está incluída abaixo. Ele utiliza a função HDFS_READ para ler o arquivo de texto do email do HDFS, especificando parâmetros de carregamento semelhantes a uma definição de carregamento de tabela externa normal. Observe que precisamos especificar os arquivos da parte subjacente, pois JAQL divide arquivos gravados em arquivos com diversas partes para cada tarefa de redução. Isso é transparente para JAQL, mas não é transparente para a função HDFS_READ , uma função da tabela Java, o que significa que precisa ser executado na cláusula FROM da consulta e é necessário usar como prefixo a palavra-chave TABLE WITH FINAL .

SELECT 
EMPLOYEE.E_ID, 
EMPLOYEE_EMAIL.EMAIL_ID,
T.TEXT
from 
	BIGIDEMO..EMPLOYEE EMPLOYEE,
	BIGIDEMO..EMPLOYEE_EMAIL,
	table with final (hdfs_read('/tmp/email_text.del/part*', 
		'DELIMITER "|"', 'ID INT, TEXT NVARCHAR(15000)')) AS T
WHERE 
	EMPLOYEE.E_ID = EMPLOYEE_EMAIL.E_ID  AND EMPLOYEE_EMAIL.EMAIL_ID = T.ID

O resultado dessa consulta é o seguinte:

E_ID | EMAIL_ID | TEXT
5    |        3 | "Message-ID: <13093069.1075849668865 ... "
6    |        8 | "Message-ID: <384643.1075853137096.Ja... "
...

Isso lerá todo o texto de email no PureData System for Analytics e a instrução pode ser utilizada como qualquer outra tabela. Também associamos os IDs de email e funcionário para que possamos filtrar facilmente pelo ID do funcionário. Por motivos de desempenho, você normalmente usaria como prefixo uma chamada JAQL_SUBMIT que realiza o push da filtragem para o BigInsights. Omitimos isso deste artigo, pois isso forçaria a criação de um procedimentos armazenado que primeiramente faz JAQL_SUBMIT e, em seguida, lê o documento filtrado. Também precisaríamos incluir o ID do funcionário nos documentos de email ou realizar o push dos IDs de email solicitados para uma cadeia de caractere JAQL. Isso estaria além do escopo do artigo, portanto, use o código a seguir como uma inspiração:

CALL JAQL_SUBMIT('
	read(del("hdfs:/tmp/email_text.del", {schema: schema{id, text}}))
		-> filter $.id == "5" 
		-> write(del("hdfs:/tmp/single_employee_emails.del", 
				{schema: schema{id, text}}));
	');

Agora terminamos todas as preparações e podemos iniciar a criação de nossos relatórios Cognos.


Criação de Relatório

Vamos descrever muito rapidamente o relatório de demonstração criado. Ele também conterá as tabelas de banco de dados de nosso aplicativo de amostra. Vamos primeiramente mostra a camada do modelo de dados e, em seguida, os relatórios criados. É um relatório Cognos direto, portanto, entramos nos mínimos detalhes. É possível localizar informações adicionais sobre como criar relatórios Cognos na seção Recursos .

Modelo de dados

Nosso modelo de dados consiste em seis assuntos de consulta. Quatro tabelas físicas, uma derivativa para criação de relatório facilitada e um assunto dinâmico com base em uma consulta:

  • NATION: Cada registro de funcionário tem um ID de nação, essa é uma tabela de consulta que contém as informações de nação.
  • EMPLOYEE: Uma tabela com registros de funcionários. Contendo ID do funcionário, ID da nação, nome e sobrenome.
  • EMPLOYEE_EMAIL: Uma tabela contendo IDs de funcionários para os IDs de emails. Para que possamos corresponder email a um funcionário específico.
  • EMAIL_SCORE: Essa é a tabela usada para armazenar a pontuação de email em nosso script JAQL. Ela tem duas colunas: email ID e work_private score.
  • EMAIL_SCORE_FILTERED: Esse assunto de consulta é criado em EMAIL_SCORE para facilitar a criação do relatório.
  • EMAIL_TEXT: Esse assunto de consulta permite efetuar drill down até o texto do email para um determinado funcionário usando a função descrita acima.

Importamos os quatro primeiros assuntos de consulta no Cognos com base nas tabelas Netezza subjacentes com o mesmo nome. Também precisamos criar relacionamentos entre todos os assuntos de consulta, para que o Cognos possa associá-los corretamente ao ID de nação, ID de email ou ID de funcionário quando as colunas de diversos assuntos de consulta forem usadas na mesma consulta de relatório.

O assunto de consulta EMAIL_SCORE_FILTERED simplifica a pontuação comercial para cada ID de email em dois itens de consulta (WORK_MAILS e PRIVATE_MAILS), cada um dos quais podendo ser 0 ou 1. Ele utiliza instruções CASE para verificar se a pontuação a WORK_PRIVATE é positiva, o que significa que a coluna comercial é 1 e a coluna particular é 0; ou negativa, o que significa que o item de consulta comercial é 0 e o item de consulta particular é 1. Isso permite contar facilmente o número de mensagens de email particulares e comerciais que cada funcionário tem enviado.

O assunto de consulta EMAIL_TEXT está utilizando a função drill down desenvolvida na seção anterior. Ele é criado em uma consulta SQL nativa. Algumas pequenas mudanças de sintaxe foram feitas para acomodar o Cognos. Quando esse assunto de consulta é referido em um relatório Cognos, a consulta subjacente será executada, buscando o texto de email no PureData System for Analytics e, em seguida, no Cognos. O modelo de dados completo é semelhante à figura a seguir.

Modelo de dados

Juntando Tudo: O Relatório do Cognos

Nossa demo do Cognos consiste em duas páginas de relatório conectadas por funcionalidade drill through. O relatório principal mostra colunas das tabelas estáticas NATION, EMPLOYEE e EMAIL_SCORE. É uma tabela de funcionários com informações pessoais (ID do funcionário, nome, sobrenome, nação) e informações da anotação de texto (ou seja, quantas mensagens de email particulares e comerciais enviadas). Também implementamos uma funcionalidade drill through no campo de ID de funcionário. Se um ID de funcionário específico for selecionado, o segundo relatório será chamado com o ID do funcionário como parâmetro de entrada para buscar o texto de email para esse funcionário.

Página Principal do Relatório

A segunda página do relatório contém uma tabela simples de todas as mensagens de email do funcionário específico. Ela exibe o ID do email e o texto do email truncado buscado do BigInsights. Também exibimos work_private score.

Página de Drill Through do Relatório

Conclusão

Demonstramos uma maneira de integrar o PureData System for Analytics e o ambiente BigInsights Hadoop. Tentamos demonstrar como cada um pode ser usado por seus pontos fortes. O PureData System for Analytics é usado como um warehouse e plataforma base para executar os relatórios do Cognos BI e o BigInsights é usado para armazenar e analisar arquivos de texto. NO BigInsights, usamos a linguagem AQL de extração de texto eficiente para extrair informações estruturadas dos arquivos de texto não estruturados. Usamos JAQL para executar a anotação de texto e para fazer upload dos resultados para o PureData System for Analytics. Por fim, usamos os Netezza UDFs para implementar um recurso de drill down do PureData System for Analytics para o BigInsights mostrando ambas as direções de integração. Juntamos tudo isso no exemplo de análise de email, armazenando e analisando dados de email no BigInsights e os dados de funcionários estruturados no PureData System for Analytics.

Cobrimos muito terreno, portanto, não conseguimos investigar cada parte detalhadamente. Em uma solução de produção real, AQL seria muito mais complexa. Também armazenaríamos os dados usando JAQL de maneira compactada e otimizada e drill through seria implementado de maneira paralelizável. No entanto, esperamos que este artigo tenha fornecido a você um bom ponto de partida.


Download

DescriçãoNomeTamanho
Scripts and demo files used in this articleNZ-BigInsights-Article.zip96KB

Recursos

Aprender

Obter produtos e tecnologias

  • Obtenha uma versão de avaliação do IBM InfoSphere BigInsights e gerencie e analise volumes massivos de dados estruturados e não estruturados em descanso.
  • Obtenha uma versão de avaliação do IBM InfoSphere Streams.
  • Obtenha uma versão de avaliação do IBM InfoSphere BigInsights e gerencie e analise volumes massivos de dados estruturados e não estruturados em descanso.
  • Desenvolva seu próximo projeto de desenvolvimento com o software de teste IBM, disponível para download diretamente do developerWorks.

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Rational, Cloud computing
ArticleID=939250
ArticleTitle=Integrar o PureData System for Analytics e o InfoSphere BigInsights para Análise de Email
publish-date=11262013