Alexandre Rademaker

Tutorial sobre gramáticas computacionais no formalismo HPSG utilizando a Grammar Matrix

2021-04-05T00:00:00-03:00

Pré-Inscrição

Os interessados devem se inscrever no formulário

https://forms.gle/8EGJNa8oWjbLjqe47

Inscrição Zoom

Os interessados devem ainda se inscrever no Zoom, ambiente que será usado para o curso:

https://fgv-br.zoom.us/meeting/register/tJMrcu-hpjojGN2fy_gru7zDcVIp5xkIAXo4

Depois do registro, um email com a confirmação e link para os encontros será enviado para seu email.

Resumo

Gramáticas computacionais elaboradas manualmente com base em princípios linguísticos têm tido a sua eficácia comprovada em diversas aplicações de nível industrial que exigem compreensão textual, em tarefas como tradução automática, resolução de perguntas e extração de informações. Esse tipo de gramática é um complemento às abordagens estatísticas baseadas em corpora sintaticamente anotados, os chamados treebanks. A anotação de um corpus por meio de um gramática computacional assegura a profundidade e a consistência das análises, permitindo que o conhecimento de especialistas seja automaticamente aplicado na anotação de um grande volume de sentenças. Uma das teorias gramaticais formais mais utilizadas para a elaboração de gramáticas desse tipo é a HPSG. As principais gramáticas de ampla cobertura implementadas nesse formalismo são a English Resource Grammar (ERG), a JACY do japonês e a gramática alemã do DFKI (Centro de Pesquisa Alemão de Inteligência Artificial), resultado de um esforço de mais de uma década de indivíduos ou pequenos grupos. A modelagem computacional dos fenômenos gramaticais de uma língua nesse formalismo pressupõe o domínio da linguagem de descrição TDL (Type Description Language), constituindo uma tarefa de programação complexa, objeto da engenharia da gramática. A Grammar Matrix, que vem sendo desenvolvida desde os anos 2000 na University of Washington por Emily M. Bender e colegas, possibilita a reutilização de soluções de implementação das gramáticas referidas para a construção de novas gramáticas, dispensando conhecimento da linguagem TDL. O sistema possui uma interface sob a forma de um questionário baseado em extensa pesquisa tipológica, que cobre alguns dos principais fenômenos gramaticais das línguas do mundo. Para construção de uma gramática computacional de uma determinada língua, o usuário só precisa especificar as particularidades da língua em relação a uma série de parâmetros gramaticais, como ordem de palavras, tipos de categorias morfossintáticas etc. bem como descrever as propriedades dos itens lexicais. Essa gramática inicial pode ser ampliada depois manualmente. Neste tutorial, apresentamos os conceitos linguísticos fundamentais necessários à compreensão e utilização do questionário bem como noções mínimas da teoria da HPSG. As noções serão exemplificadas por meio da construção de minigramáticas do inglês e do latim, línguas que diferem estruturalmente de modo bastante significativo. O tutorial será concluído com a apresentação de aplicações e ferramentas para utilização da ERG. Para acompanhamento do tutorial, recomendamos a prévia instalação do parser LKB-Fos integrado ao editor Emacs e aquisição de uma familiaridade mínima com os dois sistemas, embora isso não seja estritamente necessário.

Instrutores

Leonel Figueiredo de Alencar — Professor Titular da Universidade Federal do Ceará e Professor Visitante da Escola de Matemática Aplicada da Fundação Getúlio Vargas
Alexandre Rademaker — Professor da Escola de Matemática Aplicada da Fundação Getúlio Vargas e Pesquisador do IBM Research

Programação

12.04.2021 15:00 – 16:30 (L. F. de Alencar): Conceitos linguísticos fundamentais: estrutura de constituintes, teoria X-barra, gramática universal, relações gramaticais, categorias morfossintáticas, controle, raising etc. Noções elementares de HPSG: estrutura de traços tipada, hierarquia de tipos, unificação etc. Minigramática English 1.
19.04.2021 15:00 – 16:30 (L. F. de Alencar): Minigramática English 2. Minigramática Latin 1.
26.04.2021 15:00 – 16:30 (L. F. de Alencar): Minigramática English 3. Minigramática Latin 2.
03.05.2021 15:00 – 16:30 (L. F. de Alencar): Minigramática English 4. Minigramática Latin 3. Limitações da Grammar Matrix e como contorná-las. Exemplos concretos de modificações manuais do código TDL.
10.05.2021 15:00 – 16:30 (A. Rademaker): English Resource Grammar, aplicações e ferramentas de utilização.

Referências

BENDER, Emily; FLICKINGER, Dan M.; OEPEN, Stephan. The Grammar Matrix: An Open-Source Starter-Kit for the Rapid Development of Cross-Linguistically Consistent Broad-Coverage Precision Grammars. CARROLL, John; OOSTDIJK, Nelleke; SUTCLIFFE, Richard (Org.). Proceedings of the Workshop on Grammar Engineering and Evaluation at the 19th International Conference on Computational Linguistics. Taipei, Taiwan, 2002. p. 8-14.
BENDER, Emily M.; DRELLISHAK, Scott; FOKKENS, Antske; POULSON, Laurie; SALEEM, Safiyyah. Grammar Customization. Research on Language and Computation, vol. 8, n. 1, p. 23-72. 2010.
COPESTAKE, Ann. Implementing Typed Feature Structure Grammars. Stanford: CSLI, 2002.
COPESTAKE, Ann. LKB User Manual
LinGO Grammar Matrix. https://matrix.ling.washington.edu
LKB-FOS. http://moin.delph-in.net/wiki/LkbFos
SAG, Ivan A.; WASOW, Thomas; BENDER, Emily. Syntactic theory: a formal introduction. 2. ed. Stanford: CSLI Publications, 2003.

Material

arquivos disponibilizados em tutorial.

reading list

2020-09-23T00:00:00-03:00

https://www.aclweb.org/anthology/P08-2048.pdf

the authors suggest a basian network to map ERG predicates to propbank and verbnet predicates.

http://www.mt-archive.info/MTS-2005-Flickinger.pdf

The description of the LOGON transfer system for machine translation and the SEM-I (semantic interface) for a grammar.

https://www.d.umn.edu/~tpederse/Pubs/AAAI04PedersenT.pdf

WordNet::Similarity is a freely available software package that makes it possible to measure the semantic similarity or relatedness between a pair of concepts.

https://www.aclweb.org/anthology/E09-1001.pdf

Links for articles about RMRS and MRS. Description of the RMRS to DMRS conversion. Link to the article about EDS.

Argument labelling is thus quite different from PropBank (Palmer et al., 2005) role labelling despite the unfortunate similarity of the PropBank naming scheme.
In principle, at least, we could (and should) systematically link the ERG to FrameNet, but this would be a form of semantic enrichment mediated via the SEM-I (cf Roa et al. (2008)), and not an alternative technique for argument indexation.

http://www.lrec-conf.org/proceedings/lrec2006/pdf/364_pdf.pdf

Reference to syntatic `discriminants` Carter 1997. The paper presents the MRS to EDS transformation and discussions about the discriminant-based treebanking.

Handle constraints of the form hi =q hj (‘equal modulo quantifier insertion’) in an MRS express that either the two are equal or that hi outscopes hj , i.e. formally that the formula depicted by hj is a subformula of the formula depicted by hi.

Extração de relações familiares do DHBB

2020-06-06T00:00:00-03:00

Continuando o post anterior, como o leitor deve ter observado, nosso objetivo não é fazer perguntas específicas, mas preparar o corpus e desenvolver ferramentas para que várias diferentes perguntas possam ser respondidas. Mas vamos à uma demanda por extração de informação que nos parece óbvia: relações familiares. Imagine tentarmos responder questões como o número de famílias que se perpetuam na política brasileira nas últimas décadas.

O que então precisamos responder é o que esperamos de saída ao executarmos ferramentas de NLP nos verbetes do DHBB. No que segue, assumo que desejamos construir um grafo onde nós são pessoas e arestas representem relações familiares entre as pessoas, rotuladas pelas relações. A idéia seria construir este grafo a partir dos verbetes. Diversas consultas sobre este grafo seriam possíveis e, direta ou indiretamente, as respostas serviriam de dados para sua reportagem. Alguém consegue pensar em algo mais específico ou mais simples?

Construir o grafo que idealizei acima envolve: 1) identificação de nomes próprios de pessoas; 2) identificação de substantivos ou adjetivos relacionados à relações familiares; 3) identificação de padrões sintáticos que identifiquem relações familiares explicitas ou implícitas mencionadas nos verbetes.

Existem algumas tarefas que precisamos realizar: NER (named e entities recognition), NEC (named entities classification: pessoa ou instituição ou lugar etc) e desambiguação de nomes. Para identificar as entidades nomeadas o problema parece simples mas sempre temos casos mais complicados. Por exemplo, podemos marcar uma entidade ou duas na sentença 1, levando as anotação de 2 ou 3:

Universidade Federal do Rio de Janeiro
[Universidade Federal do Rio de Janeiro]
[Universidade Federal] do [Rio de Janeiro]

Note que identificar, classificar e disambiguar não necessariamente são tarefas separadas. Tipicamente a desambiguação significa mapear uma string no texto à uma entrada em uma base de dados. Obviamente a existência de uma lista de nomes de políticos (obtida de sites do governo), pode ajudar, mas em geral usamos recursos mais abrangentes como DBPedia, Wkidata, Yago etc. Tomando a decisão por 2, uma ligação possível seria com a página. A existência da entrada na Wikipedia para `Universidade Federal do Rio de Janeiro’ é uma evidência de que a anotação 2 seria mais adequada. E obviamente se desambiguamos uma entrada X contra um DB que já nos diz o tipo de X também estamos também fazendo a classificação, os problemas se misturam.

A identificação dos nomes pode ser feita diretamente, marcando no texto de entrada segmentos que correspondem a nomes ou como uma camada de anotação acima das árvores sintáticas. Penso que combinar as abordagens sempre ajuda muito a identificarmos errors de processamento. Usando o WKS já temos uma primeira versão de anotações.

Uma das coisas que está na nossa lista de tarefas é verificar as anotações sintáticas a partir de listas de nomes de entidades. Sequencias de tokens partes de um nome deveriam estar todos em uma subárvore da arvore sintática. Esta verificação nos ajudaria a melhorar as análises sintáticas que já temos. Como disse acima, listas de nomes de pessoas, instituições ou lugares podem ser obtidas de sites do governo, das bases que mencionei acima ou usar as anotações que já temos.

Feita a identificação de nomes, podemos partir para os termos de parentesco. Um bom ponto de partida seria a nossa OpenWordnet-PT. Uma revisão da cobertura dela para estes termos seria excelente. Descobrir o que temos e o que está faltando. Assim poderíamos usar a estrutura da WN para generalizar as buscas nos textos por termos relacionados à relações familiares, ao invés de enumerar todos os termos, poderíamos usar as relações semânticas da WN para perguntar por termos e seus hipônimos, por exemplo. Entender a modelagem destes termos na OWN-PT seria o ponto de partida e este assunto é bem interessante por si só:

https://en.wikipedia.org/wiki/Kinship_terminology
https://en.wikipedia.org/wiki/Dyadic_kinship_term
https://en.wikipedia.org/wiki/Coefficient_of_relationship
https://en.wikipedia.org/wiki/Category:Kinship_terminology não tem links para Português, talvez Wikipedia precise de ajuda.

Uma busca no DHBB pelos termos mais ‘óbvios’ que me ocorreram ajuda a termos uma idéia do que devemos encontrar no DHBB. Esta é uma busca preliminar, não está cobrindo o DHBB inteiro e claramente o analisador sintático ainda comete errors e não faz análises consistentes. Também podemos ter uma idéias da quantidade de sentenças que mencionam estes termos:

% awk '$0 ~ /text =/ {sent = $0} $3 ~ /^(irmã|irmão|pai|mãe|tio|tia|bisavô|bisavó|primo|prima|avô|avó|sobrinho|sobrinha|cunhado|cunhada|parente)$/ {print sent}' *.conllu  | wc -l
    5812

Em seguida, temos a identificação das possíveis relações de parentesco entre pessoas que possam ser identificadas nos textos. Obviamente, muitas vezes os autores podem apenas mencionar a existência de um parente mas não nomea-lo. Nos exemplos abaixo, note que o nome do verbetado (pessoa que o verbete descreve) não aparece explicitamente nas sentenças.

% awk '$0 ~ /text =/ {sent = $0} $3 ~ /^(irmã|irmão|pai|mãe|tio|tia|bisavô|bisavó|primo|prima|avô|avó|sobrinho|sobrinha|cunhado|cunhada|parente)$/ {print sent}' *.conllu  | head

Em reportagem do dia 18 de março de 2000, do jornal «Folha de S. Paulo», Armando Abílio foi acusado de ser, ao lado do deputado Raimundo Santos (PFL-PA), o campeão do nepotismo na Câmara dos Deputados, tendo contratado sete parentes para seu gabinete.
Casou-se com Rosimere Bronzeado Vieira - sobrinha de Luís Bronzeado, que foi deputado federal pela Paraíba de 1959 a 1967 -, com quem teve cinco filhos.
Ainda em 1998, foi nomeada para o cargo vitalício de conselheira do Tribunal de Contas do Estado do Amapá (TCE-AP) por João Capiberibe, seu irmão e então governador do estado.
Como advogado, Pedro Aleixo participou de rumorosos julgamentos, entre eles o das irmãs Poni (31/3/1964), que conseguiu inocentar da acusação de assassinato, e o de Roberto Lobato (abril de 1973), igualmente absolvido da mesma imputação, nesse caso contra o posicionamento de Pedro Aleixo, que atuou como advogado de acusação.
Era casado com Maria Stuart Brandi Aleixo, com quem teve quatro filhos, um dos quais, Maurício Brandi Aleixo, após a morte do pai, empenhou-se em dar prosseguimento à organização do PDR.
Seu avô, Miguel Arraes, de quem era considerado sucessor político, foi por três vezes governador de Pernambuco (1963-1964, 1987-1990 e 1995-1998) e deputado federal durante dois mandatos (1983-1987 e 1991-1995).
Sua mãe Ana Arraes exerceu mandato como deputada federal (2007-2010) e desde 2011 é ministra do Tribunal de Contas da União (TCU).
Em 2005, foi eleito para o cargo de presidente do PSB, após a morte de seu avô e então presidente do Partido, Miguel Arraes.
Durante sua gestão destacam-se a criação de programas sociais como o “Pacto pela Vida”, promovido pela Secretaria Estadual de Segurança com vistas à redução dos índices de violência, que alcançou queda de 39% no índice de homicídios; e o programa “Mãe Coruja Pernambucana”, criado para diminuir a taxa de mortalidade infantil, mais tarde condecorado pela Organização das Nações Unidas (ONU) e posteriormente agraciado com o Prêmio Interamericano da Inovação para a Gestão Pública Efetiva.
Francisco Campos aprendeu as primeiras letras com sua mãe e depois passou dois anos como interno no Instituto de Ciências e Letras de São Paulo, regressando em seguida a Dores do Indaiá para estudar português e francês.
Há entretanto quem julgue, como Alexandre Barbosa Lima Sobrinho, que suas realizações foram motivadas pelo afã de projetar nacionalmente o próprio nome de Antônio Carlos, tendo em vista a sucessão de Washington Luís, que assumira a presidência da República em 15 de novembro de 1926.

Quando olhamos para os tokens que são termos de relações familiares e sua relação com os demais tokens das sentenças, temos 299 casos de ligações sintáticas diferentes, comprovando o que vemos nos exemplos acima, uma possível grande diversidade de padrões sintáticos usados.

% awk '$3 ~ /^(irmã|irmão|pai|mãe|tio|tia|bisavô|bisavó|primo|prima|avô|avó|sobrinho|sobrinha|cunhado|cunhada|parente)$/ {print $2,$4,$8}' *.conllu | sort | uniq -c | sort -nr | wc -l
     299

Os 10 casos mais frequentes são os abaixo. O simbolo nsubj indica sujeito da sentença, nmod indica que a palavra ‘pai’ está modificando outro substantivo, flat:name indica que o termo é parte de um nome etc.

% awk '$3 ~ /^(irmã|irmão|pai|mãe|tio|tia|bisavô|bisavó|primo|prima|avô|avó|sobrinho|sobrinha|cunhado|cunhada|parente)$/ {print $2,$4,$8}' *.conllu | sort | uniq -c | sort -nr | head
 649 pai NOUN nsubj
 394 pai NOUN nmod
 370 irmão NOUN nsubj
 309 Sobrinho PROPN flat:name
 254 pai NOUN nsubj:pass
 211 irmão NOUN appos
 177 irmão NOUN nmod
 170 irmão NOUN nsubj:pass
 163 avô NOUN nsubj
 144 tio NOUN nsubj

Isto indica que embora possamos escrever padrões para extração de informações das árvores ou diretamente do texto das sentenças, o trabalho poderá ser bem grande. Uma idéia é construir abstrações nestas estruturas gerando representação mais semânticas para serem analisadas. Outra idéia seria usar técnicas de aprendizado de máquina tanto na identificação de termos para relações familiares quando na extração de relações familiares. Existem vários artigos explorando estas técnicas.

Iniciantes na área de PLN costumam encontrar bibliotecas como NLTK, e acreditar que usando a biblioteca poderão processar textos facilmente. De fato, esta particular biblioteca é bem documentada e descreve no capítulo 7 algumas abordagens para extração de informações. Mas muito dos passos mencionados no texto assumem modelos já treinados, no inglês. E mesmo que existam modelos para Português, nossos experimentos mostram que no DHBB os resultados contém muitos erros em todas as etapa: segmentação de sentenças, pos tagging, identificação de nomes etc. Por isso nosso projeto.

Para interessados na área de processamento de texto, sugiro a leitura do livro ainda em edição https://web.stanford.edu/~jurafsky/slp3/.

Processando o DHBB -- o que temos até agora?

2020-06-04T00:00:00-03:00

Hoje recebi uma mensagem bem interessante perguntando sobre o que tenho feito em relação ao processamento do DHBB. Resolvi aproveitar para escrever este post.

Na lista das minhas publicações, interessados podem consultar todos os artigos que escrevemos sobre trabalhos com o DHBB. Ao longo dos anos, fizemos diferentes experimentos ‘exploratórios’ no DHBB, alguns com objetivo, não de processar o DHBB, mas de usa-lo para expandir recursos que precisávamos criar para o processamento de textos em PT, além mesmo do DHBB.

Recentemente, agora sim ja tendo recursos para tal, pudemos começar a pensar no processamento do DHBB propriamente dito. Mas os recursos necessários ainda estão longe de completos ou com tamanho adequado para garantir boa qualidade, logo penso no processamento do DHBB como um projeto de longo prazo que passará por refinamentos sucessivos. Quando digo recursos, falo de coisas como:

Nossa WordNet do português.
O corpus Bosque e os outros de PT que também mantemos como parte do projeto Universal Dependencies. Estes dados usados para parser das sentenças.
O dicionário morfológico.
O corpus com anotações de papéis semânticos para treino de SRL.

No artigo do último PROPOR, mostramos que mesmo a segmentação de sentenças não é trivial e que certamente vários erros de análise sintática (usamos o UDPipe) existem dado o reduzido tamanho do corpus Bosque e diferenças entre o estilo textual do corpus Bosque (jornalístico) para o DHBB (enciclopédico). O que estamos fazendo é criar um workflow que permita o trabalho de longo prazo onde revisões humanas sejam integradas em ciclos de treino e avaliação dos diferentes componentes que estamos usando. Eu poderia falar muito mais sobre as dificuldades reais na segmentação de sentenças, mas vou deixar isso para outros posts.

Para a segmentação de sentenças, temos tido melhores resultados com o OpenNLP, que comparamos com outras ferramentas no paper mencionado acima, dentre elas o Freeling, que encontramos muitas limitações de configuração (abreviações no final de sentenças são um problema sem solução para o Freeling). Mas aprendemos que o modelo de segmentação disponibilizado em também erra várias sentenças do DHBB. Com isso, retreinamos o OpenNLP com um subconjunto de sentenças do DHBB segmentadas manualmente. Ainda estamos investigando alternativa ao OpenNLP, talvez o próprio UDPipe ou NLTK, este issue trata deste assunto. Não sou muito fã de Python, mas começamos a testar o NLTK principalmente por causa do modulo de segmentação de sentenças que implementa o algoritmo Punkt, especialmente util para lidar com abreviações.

Falando da análise sintática. Treinamos o UDPipe com o corpus UD_Portuguese-Bosque, que estamos ainda constantemente revisando, expandido com as sentenças do DHBB analisadas que já revisamos. Com este modelo, aplicamos no restante do DHBB e repetimos o ciclo. Nas últimas semanas, focamos nas sentenças dos primeiros parágrafos dos verbetes, temos atualmente umas 200-300 sentenças revisadas. Estas sentenças, quando adicionadas ao Bosque, conseguiram ‘ensinar’ o UDPipe a análise dos primeiros parágrafos dos verbetes (os parágrafos que falam sobre relações familiares).

Em paralelo ao nosso trabalho, Diana e Suemi incluiram o DHBB no acervo da Linguateca, seguindo os métodos de processamento dos textos que a Linguateca adota. Eu não estou mais participando diretamente deste esforço embora tenha colaborado em um artigo do ano passado. Para mim, a principal limitação da abordagem da Linguateca são as ferramentas adotadas. Algumas proprietárias, como o parser PALAVRAS que produzem analises pouco ’standard’ e consequentemente de difícil integração com outras ferramentas. Por isso prefiro outras abordagens.

Quanto a colaboração com interessados. Uma coisa que precisamos muito é UI. Nosso ciclo de revisão e treino com human-in-the-loop precisa evoluir para que os usuários possam fazer revisões em interfaces mais visuais sem lidar com arquivos. Isto permitiria maior agilidade em cada ciclo de revisão. Na parte mais de NLP, ter a análise sintática é apenas uma etapa para extração de informações. Precisamos de muitas outras ‘camadas’ de anotação como SRL, NER, expressões temporais etc. E talvez continuar combinando técnicas. Por exemplo, para reconhecimento de entidades nomeadas, temos um modelo treinado no IBM Watson Knowledge Studio (WKS). Nosso demo ainda está super básico e também precisa evoluir. Mas o modelo treinado no WKS ainda precisa ser melhorado e ainda precisamos pensar como integrar as anotações do WKS com estes processamentos mais ‘linguisticos’ que estamos fazendo agora. Enfim, muita coisa para fazer.

Com sorte, o que está sendo feito pode ser útil para processamento de outros textos no futuro, além do DHBB, como wikipedia.

São vários colaboradores participando deste projeto, em diferentes momentos e de diferentes formas. Em especial, não posso deixar de mencionar a Valeria de Paiva, amiga que me introduziu na área de linguistica computacional e me apresentou tantas pessoas ao longo destes anos.

PARSEME corpus

2019-05-20T00:00:00-03:00

During the evaluation of a paper, I read about the PARSEME annotation guidelines of verbal multiword expression.

The question that came to my mind was, what would happen if we process PARSEME data with ERG grammar? Would it be possible to associate to each type of verbal construction a pattern in the MRS?

Links:

http://parsemefr.lif.univ-mrs.fr/parseme-st-guidelines/1.1/?page=home
http://erg.delph-in.net

RDF/OWL support for Common Lisp

2018-01-17T00:00:00-02:00

As I wrote in the comments on this issue, it would be a nice project to improve Wilbur and Racer2 making them more modular and robust. It is a shame the current support for RDF/OWL in Lisp, it is almost nothing compare with Python and Java libraries available such as:

https://rdflib.readthedocs.io/en/stable/
https://jena.apache.org

The only robust library available for RDF/OWL in Lisp is the Allegro Graph system from Franz, but it is a commercial and since its 3.X version, it can’t be used as a library for simples RDF/OWL manipulations.

I found https://github.com/SeijiKoide/SWCLOS but I haven’t tried it yet. The ideas didn’t not evolved so much since the paper The Use of Lisp in Semantic Web Applications.

anotações sintáticas

2017-06-06T00:00:00-03:00

Dada a sentença “O garoto, que mora na rua 12, estava correndo atrás da bola.”, são várias as análises sintáticas possíveis dependendo do formalismo adotado. Estes formalismos dividem-se em duas grandes classes: `phrase-structure` ou `dependencies` mas existem variações entre teorias dentro destas classes. Vejamos dois formalismos de dependências.

O sistema PALAVRAS tem como saída padrão para a análise por dependências da sentença acima, o seguinte trecho:

O [o] <*> <artd> DET M S @>N #1->2
garoto [garoto] <Hbio> N M S @SUBJ> #2->11
, #3->0
que [que] <clb> <clb-fs> <rel> SPEC M S @SUBJ> #4->5
mora [morar] <vK> <mv> <np-close> V PR 3S IND VFIN @FS-N< #5->2
em [em] <sam-> PRP @<SA #6->5
a [o] <-sam> <artd> DET F S @>N #7->8
rua [rua] N F S @P< #8->6
12 [12] <card> NUM M/F P @<SC #9->5
, #10->0
estava [estar] <fmc> <aux> V IMPF 3S IND VFIN @FS-STA #11->0
correndo [correr] <clb> <mv> V GER @ICL-AUX< #12->11
atrás de [atrás=de] <sam-> PRP @<ADVL #13->12
a [o] <artd> <-sam> DET F S @>N #14->15
bola [bola] <cc> <tool> <food-c-h> <act> N F S @P< #15->13
. #16->0

Um parser de dependências treinado com um corpus anotado seguindo o modelo de dependências Universal Dependencies, neste caso o corpus UD_Portuguese (Bosque em UD produzido pelo nosso grupo), produz a seguinte saída para a mesma sentença:

1	O	_	DET	DET	_	2	det	_	_
2	garoto	_	NOUN	NOUN	_	12	nsubj	_	SpaceAfter=No
3	,	_	PUNCT	.	_	5	punct	_	_
4	que	_	PRON	PRON	_	5	nsubj	_	_
5	mora	_	VERB	VERB	_	2	acl:relcl	_	_
6-7	na	_	_	_	_	_	_	_	_
6	en	en	ADP	ADP	_	8	case	_	_
7	a	o	DET	DET	Definite=Def|Gender=Fem|Number=Sing|PronType=Art	8	det	_	_
8	rua	_	NOUN	NOUN	_	5	nmod	_	_
9	12	_	NUM	NUM	NumType=Card	8	appos	_	SpaceAfter=No
10	,	_	PUNCT	.	_	5	punct	_	_
11	estava	_	AUX	AUX	_	12	aux	_	_
12	correndo	_	VERB	VERB	_	0	root	_	_
13	atrás	_	ADV	ADV	_	12	advmod	_	_
14-15	da	_	_	_	_	_	_	_	_
14	de	de	ADP	ADP	_	16	case	_	_
15	a	o	DET	DET	Definite=Def|Gender=Fem|Number=Sing|PronType=Art	16	det	_	_
16	bola	_	NOUN	NOUN	_	13	nmod	_	SpaceAfter=No
17	.	_	PUNCT	.	_	12	punct	_	_

Existem diferenças teóricas e técnicas entre estes dois modelos de dependências. As diferenças teórias são as que caracterizam cada modelo ou formalismo. Por exemplo, em UD, o `root` da sentença, o nó raiz da árvore sintática, é o verbo `correr`. Para o PALAVRAS o root é o verbo `estar` que, alias, não é exatamente o root, porque o root para o PALAVRAS é um nó 0, que não tem nenhum token associado. PALAVRAS identificou `atrás de` como uma MWE funcionando como preposição enquanto UD não fez o mesmo agrupamento. Para o PALAVRAS, todas as pontuações apontam para o root da sentença. Para UD, o tratamento das pontuações não é tão simples. Vale perceber que o parser UDPipe, que usei para produzir a saída acima, errou no desmembramento da contração `na`.

Mas para revisão do corpus, estou agora mais interessado nas diferenças técnicas. Ambas as saídas codificam de forma diferente várias informações: os links de dependência, as POS tags, as features, lemas etc. Ambos representam um token por linha, mas o PALAVRAS apresenta as informações de cada token de uma forma mais `flat`, uma sopa de símbolos, apelando para alguns caracteres especiais que identificam os tipos de cada símbolo. Lema entre conchetes, tags e features em maiusculas, relações sintáticas começam com o símbolo `@` e outras tags sintáticas e semânticas entre `<…>`. Em contrapartida, o formato CoNLL-U adotado por UD propõe que cada informação esteja em uma coluna de um formato tabular. Em UD, as features são explicitamente definidas, por exemplo, `Gender=Fem`. No PALAVRAS o símbolo `F` codifica esta mesma informação.

Pensando na tarefa de revisão de anotações sintáticas, qual formato seria mais adequado para edições? Quais outros formatos possíveis existem? Esta discussÃo é certamente menos relevante se adotarmos uma postura de revisão de corpora centrada no suporte de alguma ferramenta de anotação, como Brat ou Webanno. Mas a verdade é que nenhuma destas ferramentas é tão flexível como a edição direta de arquivos texto com suporte de alguma interface de visualização e `debug` da anotação.

Ideas of Projects for 2017

2017-02-22T00:00:00-03:00

Some possible ideas for students looking for projects: ‘iniciação científica’.

Text Entailment

We propose a project to evaluate different techniques for text entailment using deep parsing. We were particularly interested in ‘deep’ linguistic processing of sentences. The goal is the combination of linguistic and statistical processing methods for getting at the meaning of texts and utterances. For the experiments, we propose the use of the SICK corpus and it was the corpus used in the SemEval 2014.

Some tools/ideas under consideration are:

Dependency Parser for Portuguese in FreeLing

Freeling is a developer-oriented library providing language analysis services. Freeling has already a good support for Portuguese in all its base modules (tokenizer, sentence splitter, POS tagger, WSD, etc.). We want to extend that support with a dependency parser for Portuguese. This project is about to understand how to train a parser in FreeLing and make it for Portuguese, evaluating the result.

For the training we can use the recently released UD_Portuguese data under the Universal Dependencies project.

SUO-KIF translator to TPTP

We have rewrote the translation from SUO-KIF logic language to TPTP language. In this project we want to expand the translation of high-order construction to TPTP/THF. In the sequence, we want to make the output readable to SNARK prover to explore its support to Procedural Attachments.

Ideally, the translator should be written in logic or functional programming style using: Prolog, Haskell or Common Lisp, etc.

CoNLL-U and Universal Dependencies toolset

The creation of an annotated corpus with dependencies is a hard task and very time-consuming. We are collaborating with the Universal Dependencies Project, with a Portuguese Corpus (UD_Portuguese). After release 2.0, we are now preparing for the next version expanding and solving errors in the current 2.0 corpus.

In this project, we are interested in improving the necessary tools that we use:

CL-CONLLU : a Common Lisp library for work with CoNLL-U files
conllu-workbench : a set of opensource tools that we use for searching and editing the corpus.

In particular, the CL library needs better support for rules and functions for comparing different trees and help in the identification of common patterns of errors.

Improving the openWordnet-PT interface

The OpenWordnet-PT, abbreviated as OpenWN-PT or simply OWN-PT) is a open access wordnet for Portuguese, originally developed by Valeria de Paiva, Alexandre Rademaker and Gerard de Melo as a syntactic projection of Universal WordNet (UWN) of de Melo and Weikum. Like many other open wordnets we believe that lexical resources need to be open to be useful.

The OpenWN-PT is available in RDF/OWL, following and expanding, when necessary, the mappings from the original Princeton WordNet. Both the data and the RDF template settings (classes and properties) of the OpenWN-PT are freely available for download here. Besides being downloadable, the data can be retrieved via SPARQL in the endpoint and one can consult and compare it with other wordnets at the generic interface provided by the Open MultiLingual WordNet project.

This project is about helping our team in the improving of the web interface for our openWordnet-PT.

In particular, we need to: (1) simplify the architecture; (2) improve the interface for votes and suggestions; (3) improve navegation and data visualization.

web crawler in Racket

2016-10-01T00:00:00-03:00

I usually like to suggest projects for students as part of their evaluation in the ‘programming language’ course. This course uses Racket language and we follow the SICP book. So the question is always what are the good projects for the students. Getting data from different source and combine then in a flexible user interface is a very common idea. Today I decide to investigate the difficult of developing a simple web crawler in Racket. Since I usually code in Common Lisp, I was looking for something similar of CL libs like drakma and Closure.

Using DrRacket only for teaching is not enough for being confortable with the Racket ecosystem. First I had to discover how to install the HTML parsing lib. This was done with:

raco pkg install html-parsing

After I have decided what libs to use, I had to understand their interfaces. My first code in Racket for retrieve and parse a simple HTML page is:

#lang racket

(require net/http-client)
(require html-parsing)

(let-values (((a b c) (http-sendrecv "arademaker.github.io"
                                     "/about.html")))
  (html->xexp c))

Not sure if this is the most efficiente way to make it, but surelly it is simple enough to start with.

Project Ideas

2016-09-17T00:00:00-03:00

Knowledge Representation via ACE

Following the article https://arxiv.org/abs/1303.4293, we can think in a lot of possible extensions. For Portuguese support, we would need to develop the Portuguese concrete syntax in GF. The idea of code the translation of ACE to OWL in GF would be very interesting to explore.

Learning support tools

We would like to have an environment similar to https://www.hackerrank.com for receiving submissions of students projects.

SUMO to TFF and HTF

We have an SUMO to TPTP/FOF translation in https://github.com/own-pt/cl-krr. We would like to extend to TFF and later to TFF or THF. Alternatively, we can also translate to http://www.ai.sri.com/~stickel/snark.html language.

Semantic Web technologies

Both systems were realised opensource, much can be done to improve them! We need Common Lisp libraries for Linked Data and related technologies:

json-ld: some initial attempt made from cl-json-ld and maybe some references from Franz’s code.
owlapi: some references at cliki. Common Lisp really need an OWLAPI library.
Racer and Wilbur are very nice libs.

I would be very happy to supervise a work (undergrad or masters) to develop such libraries in Common Lisp.

Lisp library for metadata extraction

Contribute to projects like http://code.google.com/p/cl-jpegmeta/ and http://www.xach.com/lisp/zpb-exif/ to improve both library and the hability to handle IIM-style IPTC fields, EXIF fields and XMP metadata.

Simple queries in openWordnet-PT

2016-07-28T00:00:00-03:00

Our OpenWordnet-PT is freely available for download and online use since its beginning. Nevertheless, some people still have difficulties to use the data without a proper introduction to our ‘data model’. Although we have already presented it in many conferences and articles, I believe some examples of queries can help people understand better our data.

All relations are between synsets from PWN (Princeton). Since we haven’t created any new synset yet, all our synsets are linked to Princeton Synsets via owl:sameAs relation. Thus, our network is a projection of the PWN network, we have a injective map between our synsets and PWN synsets. Obviously, we have new senses and new words and these resources are linked to our synsets.

In other words, to know the hypernyms of the word “cachorro” one must ‘use’ the PWN synsets and relations:

select ?sspt ?otherpt ?otherword 
{
  ?word wn30:lexicalForm "cachorro"@pt .
  ?sspt wn30:containsWordSense/wn30:word ?word .
  ?ssen owl:sameAs ?sspt .   
  ?ssen wn30:hyponymOf+ ?other .
  ?other owl:sameAs ?otherpt .
  ?otherpt wn30:containsWordSense/wn30:word/wn30:lexicalForm ?otherword .
}

Note that hyponymOf+ is a SPARQL 1.1 construction (property paths). It means the transitive closure of the hyponymOf relation. The idea is to first get the synset in OWN-PT which contains “cachorro”, then find the equivalent synset in PWN. With the right synsets in PWN, we look for the related ones in OWN-PT and return them. Finally, we get the words from the OWN-PT synsets that we found.

Note also that not all relations are between synsets, some relations such as derivationallyRelated are relation between senses:

select ?s ?p
{
   ?s wn30:derivationallyRelated ?p.
}

We associate synsets via skos:inScheme to two special resources representing the PWN and OWN-PT wordnets to facilitate queries.

select distinct ?schema
{
   ?wsa wn30:derivationallyRelated ?wsb .
   ?ss skos:inScheme ?schema ;
       wn30:containsWordSense ?wsa .
}

Our data model is described in the wn30.ttl file. This is our ‘vocabulary’ in Semantic Web terms. The queries above can be tested in our SPARQL endpoint.

Sudoku as programming and logic exercise

2016-07-19T00:00:00-03:00

Last semester, at some point in my course on Data Structures and Algorithms, once again I mentioned the SUDOKU problem. I am sure that I haven’t covered all about it yet, and this post is just to remember me about things that I would like to came back at some point:

In Common Lisp, some libraries make the problem so easy that is hard to explain to the students why the logic based approaches are so challenging. Examples are: computed-class, cells and screamer.

Sudoku as SAT is documented in the article [3] and we know that a better encoding should be possible. I would love to continue the experiments with SNARK theorem prover following ideas from the papers [1] and [2].

T. Hillenbrand, D. Topic, and C. Weidenbach, “Sudokus as Logical Puzzles”, pp. 1–11, Apr. 2016.
G. Santos-García and M. Palomino, “Solving Sudoku Puzzles with Rewriting Rules”, pp. 1–16, 2006.
I. Lynce and J. Ouaknine, “Sudoku as a SAT Problem”, online.

So many interesting things to do!

Semantic Links for Portuguese

2016-06-13T00:00:00-03:00

We have presented the paper Semantic Links for Portuguese in the LREC 2016. As we already know, the paper is not the end of this work, possible the contrary of that. We already know some improvements needed and some related works that we sill have to analyse. This post is to register these information and list possible future works for the article.

Thanks, Diana Santos for suggesting me the works:

Medeiros, José Carlos, Rui Marques & Diana Santos. Português Quantitativo, Actas do 1.o Encontro de Processamento de Língua Portuguesa (Escrita e Falada) - EPLP’93, (Lisboa, 25-26 de Fevereiro de 1993).
Alina Villalva, Estruturas Morfológicas, thesis, Lisboa, 1994.
The thesis “A complementação da forma nominalizada deverbal sufixal e a conceituação do complemento nominal” by Rosa Marina de Brito Meyer, see thesis.
Articles in PROPOR or EBRALC or ELC from Violeta Quertal.

We still need more experiments with corpora. Possible verifying the cases of zero-derivational words. We can use a generator of verbs forms (conjugator) for help with the annotation of candidates.

We have cases like the verb ‘aparecer’ and its nominalizations: ‘aparição’, ‘aparecimento’ and ‘aparência’. All of them must be in the resource for sure. Words as ‘coberta’ and ‘cobertura’ should be also in the resource, but what about the less frequent ones?

Ambiguities versus fine-grained classification. The semantic links ação and resultado do make sense in Portuguese? If the introduce too many classes (using classes from other languages), we are creating a problem, not dealing with one real problem.

Valeria has also posted recently about our work with nominalizations.

Congratuatios Guilherme Passos

2016-06-10T00:00:00-03:00

Guilherme Passos presented last week his final undergrad project. Congratulations Guilherme, well done. The project is an extension of the ideas from the book:

P. Blackburn and J. Bos, Representation and inference for natural language. 2005

Guilherme expands the code from the book to use the Princeton Wordnet for making a simple conversational chatbot that can understand some sentences (basically all type of sentences considered in the book) module some hyponyms and hypernyms from PWN, and provide some answers to the user. The links for the code and texts will be available soon here.

Solving the Puzzle

2016-04-03T00:00:00-03:00

Solving the Can You Solve The Impossible Puzzle? with Common Lisp and Org Mode.

Our search space contains 45 possible candidates of pairs of numbers. The tables below will have one candidate of a pair on each row. In the first column, we have the multiple, in the second column the sum and the last two columns the candidate pair. The prune function will help us to reduce the search space on each interaction, filtering the elements without repetition.

(ql:quickload :group-by)

(defun prune (data func)
  (let* ((pre (group-by:group-by-repeated data :keys (list func)))
         (input (remove-if (lambda (p) (<= (length (cdr p)) 1)) pre)))
    (reduce (lambda (acc a) (append acc (cdr a))) input
            :initial-value '((m s x y)))))

(cons '(m s x y)
      (loop for x from 1 to 9
            append (loop for y from 9 downto x
                         collect (list (* x y) (+ x y) x y))))

#+RESULTS[ca79f9a22ba8cd356c32197a5ac0ad93f8159c81]: start

m	s	x	y
9	10	1	9
8	9	1	8
7	8	1	7
6	7	1	6
5	6	1	5
4	5	1	4
3	4	1	3
2	3	1	2
1	2	1	1
18	11	2	9
16	10	2	8
14	9	2	7
12	8	2	6
10	7	2	5
8	6	2	4
6	5	2	3
4	4	2	2
27	12	3	9
24	11	3	8
21	10	3	7
18	9	3	6
15	8	3	5
12	7	3	4
9	6	3	3
36	13	4	9
32	12	4	8
28	11	4	7
24	10	4	6
20	9	4	5
16	8	4	4
45	14	5	9
40	13	5	8
35	12	5	7
30	11	5	6
25	10	5	5
54	15	6	9
48	14	6	8
42	13	6	7
36	12	6	6
63	16	7	9
56	15	7	8
49	14	7	7
72	17	8	9
64	16	8	8
81	18	9	9

In the first time that Barack asked Pete, if Pete knew the answer his multiple would be unique defined in the candidate list, that was not the case, so we must remove the multiples without repetitions.

(prune (cdr data) #'first)

#+RESULTS[6db81e23c88ea3483e1865437f8de0f9cca170cd]: step-1

m	s	x	y
36	12	6	6
36	13	4	9
24	10	4	6
24	11	3	8
12	7	3	4
12	8	2	6
16	8	4	4
16	10	2	8
18	9	3	6
18	11	2	9
4	4	2	2
4	5	1	4
6	5	2	3
6	7	1	6
8	6	2	4
8	9	1	8
9	6	3	3
9	10	1	9

When Barack asked Susan for the first time, she already knew that Pete didn’t know the answer either. So the candidate list in her mind is the list above. But she didn’t know the answer of Barack’s question either, so her sum are not unique in this list too.

(prune (cdr data) #'second)

#+RESULTS[2ac1f2a3d955fbf7a89f6db99a91c8f902775483]: step-2

m	s	x	y
9	6	3	3
8	6	2	4
6	5	2	3
4	5	1	4
8	9	1	8
18	9	3	6
16	8	4	4
12	8	2	6
6	7	1	6
12	7	3	4
18	11	2	9
24	11	3	8
9	10	1	9
16	10	2	8
24	10	4	6

In the second time that Barack asked Pete, he still didn’t know. So we have to exclude all unique multiples again.

(prune (cdr data) #'first)

#+RESULTS[d5b928145f97d2bea7471b63383a9e34d6178b5a]: step-3

m	s	x	y
24	10	4	6
24	11	3	8
12	7	3	4
12	8	2	6
16	10	2	8
16	8	4	4
18	11	2	9
18	9	3	6
6	7	1	6
6	5	2	3
8	9	1	8
8	6	2	4
9	10	1	9
9	6	3	3

The same again for the second time Barack asked Susan:

(prune (cdr data) #'second)

#+RESULTS[17b25e5fc689d147eda2bd35c388cde44f310568]: step-4

m	s	x	y
9	6	3	3
8	6	2	4
8	9	1	8
18	9	3	6
16	8	4	4
12	8	2	6
6	7	1	6
12	7	3	4
18	11	2	9
24	11	3	8
9	10	1	9
16	10	2	8
24	10	4	6

Pete in the third time still didn’t know.

(prune (cdr data) #'first)

#+RESULTS[44d455fea1e59e9db1788bb012f6cdd4abcc32f1]: step-5

m	s	x	y
24	10	4	6
24	11	3	8
12	7	3	4
12	8	2	6
16	10	2	8
16	8	4	4
18	11	2	9
18	9	3	6
8	9	1	8
8	6	2	4
9	10	1	9
9	6	3	3

Susan in the third still didn’t know.

(prune (cdr data) #'second)

#+RESULTS[7a0a13546e37c1bd0d1fff1059eb069b381cbd30]: step-6

m	s	x	y
9	6	3	3
8	6	2	4
8	9	1	8
18	9	3	6
16	8	4	4
12	8	2	6
18	11	2	9
24	11	3	8
9	10	1	9
16	10	2	8
24	10	4	6

Pete once more didn’t know:

(prune (cdr data) #'first)

#+RESULTS[079394364b443353af7d9353a8c0a38835b09ee2]: step-7

m	s	x	y
24	10	4	6
24	11	3	8
16	10	2	8
16	8	4	4
18	11	2	9
18	9	3	6
8	9	1	8
8	6	2	4
9	10	1	9
9	6	3	3

Susan in the fourth time didn’t know either:

(prune (cdr data) #'second)

#+RESULTS[e8f43474732654a4d80a659c50fe51b7ddba6a28]: step-8

m	s	x	y
9	6	3	3
8	6	2	4
8	9	1	8
18	9	3	6
18	11	2	9
24	11	3	8
9	10	1	9
16	10	2	8
24	10	4	6

At this moment, in the fifth time, Pete knew the answer. That is, his number should be 16, since this is the only multiple that unique defines the candidates: 2 and 8.

If Pete didn’t knew at this time, Barack would have asked once more to Susan and we would have to exclude the pair (2,8) from the list of candidates:

(prune (cdr data) #'first)

#+RESULTS[b04f949aa4cfaea9ae9f63533fc50b207336f698]: step-9

m	s	x	y
24	10	4	6
24	11	3	8
18	11	2	9
18	9	3	6
8	9	1	8
8	6	2	4
9	10	1	9
9	6	3	3

In this candidate list, Susan would not be able to identify the numbers since no sum is unique.

Let over Lambda

2016-02-07T00:00:00-02:00

I am reading “Let over Lambda”. Amazing how truly is the comments and the words on the back cover. This book is really for Common Lisp developers with very solid background. I am still in Section 5.3, some part demands 1-2 days for real understanding. The problem isn’t the text, actually, the book is very well-written, but the code blocks are hard to grasp: macros that define macros that define macros and so on…

I hope to update this post with more specific comments from my experiences through the book. So far, two observations:

Don’t try to use SBCL for run the code. The way that SBCL encodes backquotes is incompatible with the code from Chapter 3. More in this question of Stackoverflow. I didn’t find any information about it in the official book website.

I haven’t investigated it further but it looks like CCL does not handle very well the read-time conditionalization:

#+nil
(progn
  (defvar test (counter-class))
  (funcall test)
  (toogle-counter-direction)
  (funcall test))

That is, the selection of no feature - one method to comment the following expression. I am still investigating this issue since it only appeared when I loaded the code using an ASDF system definition and quicklisp. Comments are welcome.

Building a shared world: Mapping distributional to model-theoretic semantic spaces

2016-01-03T00:00:00-02:00

The introduction of this papers is fascinating. The complementarity mentioned in the introduction has been in my mind for a while:

In recent years, the complementarity of distributional and formal semantics has become increasingly evident… A number of proposals have emerged from these considerations, suggesting that an overarching semantics integrating both distributional and formal aspects would be desirable…

Another interesting part of the paper is its section 4.2, when the authors introduce their definition of ‘model-theoretic spaces’:

Ontologies can be represented in various ways, but in this paper, we assume they are formalised in terms of sets of entities… In our account, we do not have an a priori model of the world: we wish to infer it from our observation of language data

In the next paragraphs, the authors precisely defined their ‘model-theoretic spaces’. The article is worth to reading.

@InProceedings{herbelot-vecchi:2015:EMNLP,
    author    = {Herbelot, Aur\'{e}lie  and  Vecchi, Eva Maria},
    title     = {Building a shared world: mapping distributional to
                    model-theoretic semantic spaces},
    booktitle = {Proceedings of the 2015 Conference on Empirical Methods
                    in Natural Language Processing},
    month     = {September},
    year      = {2015},  address   = {Lisbon, Portugal},
    publisher = {Association for Computational Linguistics},
    pages     = {22--32},
    url       = {http://aclweb.org/anthology/D15-1003}
}

Merging RDF files

2015-08-18T00:00:00-03:00

How to merge multiple RDF files into a single RDF file? The first idea would be to convert each RDF file in ntriples and just concatenate them using unix cat utility, right? No, it doesn’t work with blank nodes (or BNodes)! BNodes from different files with the same ID would be merged as a single resource and this is not the expected semantics, BNodes from different files are different resources, even if they have the same id.

The rapper is a utility from the package Redland. Below I am presented the files and the number of triples on each one.

$ rapper -c -i ntriples wordnet-en-fixed.nt
rapper: Parsing returned 3517504 triples

$ rapper -c -i ntriples own-pt-fixed.nt
rapper: Parsing returned  824916 triples

The oldest tool to support merging of RDF files is CWM. CWM is written in python and its performance is really bad. The command below hasn’t finish after 5 minutes.

/usr/local/cwm-1.2.1/cwm --ntriples own-pt-fixed.nt wordnet-en-fixed.nt > tudo-cwm.nt

Next tool that I tried was $RDF_pro$. The performance was excellent, only 11 seconds! But we must add a parameter -w to force BNodes in input files to be renamed to avoid possible clashes. Actually, it doesn’t make sense to me why this is not the default behaviour.

$ rdfpro @r -w own-pt-fixed.nt wordnet-en-fixed.nt @w tudo-pro.nt
14:45:53(I) 4342420 triples read (377077 tr/s avg)
14:45:53(I) 4342420 triples written (377077 tr/s avg)
14:45:53(I) Done in 11 s

Next tool, riot from the Jena library. The performance was not bad, it took twice the time of $RDF_pro$ but it finished. The only problem is that it complained about some IRI that no other tool complained.

$ time riot own-pt-fixed.nt wordnet-en-fixed.nt > tudo-riot.nt
14:51:14 WARN riot :: [line: 282756, col: 1 ] Bad IRI: <https://w3id.org/own-pt/wn30-pt/instances/word-Ĳsselmeer> Code: 47/NOT_NFKC in PATH: The IRI is not in Unicode Normal Form KC.
14:51:14 WARN riot :: [line: 282756, col: 1 ] Bad IRI: <https://w3id.org/own-pt/wn30-pt/instances/word-Ĳsselmeer> Code: 56/COMPATIBILITY_CHARACTER in PATH: Bad character
...

real	0m27.398s
user	0m29.905s
sys	0m1.751s

I don’t like warnnings so I tried the safe path. I converted the ntriple file with these strange IRIs to RDF/XML and called riot again. No warnnings this time, good!

$ rapper -i ntriples -o rdfxml own-pt-fixed.nt  > own-pt-fixed.rdf
rapper: Serializing with serializer rdfxml
rapper: Parsing returned 824916 triples

$ riot --time own-pt-fixed.rdf wordnet-en-fixed.nt > tudo-riot.nt
own-pt-fixed.rdf : 14.84 sec  824,916 triples  55,602.32 TPS
wordnet-en-fixed.nt : 21.82 sec  3,517,504 triples  161,175.95 TPS
Total : 36.66 sec  4,342,420 triples  118,451.17 TPS

But the output produced does have some errors! The IRIs are not encoded as the way the ntriples specification requires.

$ rapper -c -i ntriples tudo-riot.nt

rapper: Parsing URI tudo-riot.nt with parser ntriples
rapper: Error - URI tudo-riot.nt:117668 column 55 - Non-printable ASCII character 195 (0xC3) found.
rapper: Error - URI tudo-riot.nt:117668 column 56 - Non-printable ASCII character 162 (0xA2) found.

By the way, for the future, I will use $RDF_pro$.

VIVO Apps and Tools Webinar

2014-04-30T00:00:00-03:00

Introduction

Yerterday I presented for the Apps and Tools working group my workflow to prepared data to be inserted into FGV VIVO instance. Since some people asked be to share the links and the file that I used to guide the presentation, I made this post.

This page is generated from a org file that I export to HTML and further processed with Jekyll. The process of use org files with jekyll is outlined here. I plan to improve this workflow, but it is working for my personal website and for the websites of the courses that I teach at FGV.

The Toolset

This is the non comprehensive list of tools that I use. I am listing here the main tools that come up into my mind that should be interesting to others.

Emacs
Org-Mode
Slime
Common Lisp compilers and interpreters: Allegro CL, SBCL and ABCL (Lisp on JVM, so I can use Java RDF libraries).
CWM
Allegro Graph Triplestore
Gruff
Git
R
Python
xsltproc and xmllint
tidy

Data Sources

We have to main sources of data: (1) the FGV researchers’ curricula vitae from Lattes Platform and; (2) the FGV digital library.

During the webinar I shared my screen and presented the web interface that CNPq provides for researchers update their resumes. I also shown my curriculum vitae and discussed why I do not consider Brazilian Researchers curricula vitae open data given the captcha that blocks crawlers to get XML files from the Lattes website in a batch mode.

I forgot to mention during the webinar but one of my old dreams is to convice CNPq to add RDFa or https://schema.org microformats into the HTML pages of the curricula vitae. This would not only allow crawlers to easier process the data but could also facilitate the maintainance of the system. My current XSLT transformation of Lattes XML to RDF cloud provide the starting point to RDFa embeeding.

The FGV Digital Library runs Dspace. The publications and collections metadata are easly collected from Dspace using the OAI-PMH protocol.

Lattes XML Files

As I said in the previous section, the curricula vitae of Brazilian Researchers are not open data, that is, they are not public available in structured format. They are only public available as HTML pages in the Lattes website, with limited search interface. The only way to universities and research institutions get the curricula vitae of their researchers in a structured format is to sign an aggrement with CNPq. FGV has signed this aggrement and we have one server authorized to access CNPq web server to retrive the XML files of all curriculae that have informed any professional activity with FGV.

To transform the Lattes files to RDF, I use a XSLT transformation that I developed few years ago. The XSLT is freely available at github in the repository Semantic Lattes.

In this repo, I made also available the DTD that I try hard to keep up-to-date. Unfortunately, until recently, CNPq did not make public annoucement of chances in the structure of the XML files that they produce, so I had to adapt the DTD whenever I identify changes. I have just found in the end of this page that CNPq finally realized the importance of making available the updated DTD. Nevertheless, the DTD in the link of this page is outdated. At least, using this DTD to validate the 489 FGV’s curriculae I got more than 100 erros but using my DTD to validate the same files I got only 2 errors. Considering that those 489 files were produced my CNPq, we have two options: (1) the DTD is outdated; or (2) the code that produces the XML files has bugs. The two erros that I find using my DTD occur only with two curriculae that were not updated in the last 2 years.

After download the XML files, the general idea to process them and produce the RDF files is outlined in the code below:

for f in $ROOT/ontos/xml/*.xml; do
    ID=$(basename $f .xml)
    echo Processing $ID
    xmllint --noout --dtdvalid $REPO/LMPLCurriculo.DTD $f 2>> error.log
    xsltproc --stringparam ID $ID $REPO/lattes.xsl $f > $ID.rdf  
done

After that, I import the RDF files to Allegro Graph making each curriculum a separated graph so I can easly identify the provenance of each triple. The importation is done using the agload utility. The load process takes aprox. 2 minutes:

Load finished 487 sources in 00:02:03 (123.02 seconds).  
Triples added: 1,690,538 
Average Rate: 13742.00 tps

Data Deduplication

I briefly commented about the deduplication of records during the webinar. I do have to take care of removing duplicated resources about the same entity. Considering a thesis defended by and student at FGV whom have as advisor a professor at FGV. I will have metadata (triples) about this thesis from three different sources: (1) the RDF produced from the advisor’s curriculum lattes XML; (2) the RDF produce from the student’s curriculum lattes XML; and (3) the RDF obtained from the FGV Digital Library.

The current code that I use to identify duplicated resources is a Common Lisp library that is easily used if placed inside the local-projects directory of a Quicklisp instalation.

I can write an entire article only about deduplication in RDF. I am still thinking hard about this problem and really would like to find better alternatives. One can note that deduplication of nodes in a RDF graph should not be done type by type as I am doing now. The rules to identify resources as being refering the same entity could dependent each other. That is, the deduplication of instances of foaf:Person can activate the rule to deduplicate instances of bibo:Article and vice-versa. It would be better to have a kind of fixed point transformation in the RDF graph that could keep clustering nodes until nothing more can be done. As a logician, I am very interested in approach this problem in a more declarative and deductive way.

I also have to note that owl:sameAs semantics doesn’t help here. I do use owl:sameAs to mark the nodes that should be merged but I have to merge the nodes after all owl:sameAs triples are produced. I do this with two SPARQL construct queries:

delete { ?s1 ?p ?o . }
insert { ?s2 ?p ?o . }
where {
  ?s1 owl:sameAs ?s2 .
  ?s1 ?p ?o .
  filter( !sameTerm(?p, owl:sameAs) )
}

delete { ?x ?p ?o1 . }
insert { ?x ?p ?o2 . }
where {
  ?o1 owl:sameAs ?o2 .
  ?x ?p ?o1 .
  filter( !sameTerm(?p, owl:sameAs) )
}

Note that the filters block the propagation of the owl:sameAs triples.

Mapping Lattes RDF to VIVO RDF

To map the Lattes RDF model produced by my XSLT to the expected VIVO RDF model, I have to look carefully to each instance of data. This mapping is not completed but at this point I have already mapped most of the data about people, publication, research areas and departaments.

To work on the rules and queries to transform the data, I used the query and data browsing tools developed by Franz: Gruff and AllegroGraph WebView. During the webinar I presented both systems.

The mapping is developed as rules that were easly tested with CWM. One example of rules is

{ ?dept foaf:member ?person ;
        rdf:type foaf:Group . } => 
{ [ vivo:relates ?dept ;
    vivo:relates ?person ;
    a vivo:FacultyPosition ;
    rdfs:label "Professor Adjunto"@pt ] . } .

Rules like the one above are placed in an n3 file and executed by CWM that receives the rule file and the data file and produces the data output file. Unfortunately, CWM does not have good performance and I haven’t even tried to use it with all the data. I develop the rules and test them with only one curriculum vitae file.

Once I finish to test the rules, I rewrite them as SPARQL queries. The one above becomes:

insert 
{ graph <http://www.fgv.br/vivo/import/> 
  {            
   [ vivo:relates ?dept ;
     vivo:relates ?person ;
      a vivo:FacultyPosition ;
     rdfs:label "Professor Adjunto"@pt ] . 
  }
}
where
{ ?dept foaf:member ?person ;
        rdf:type foaf:Group . 
}

Note that: (1) the query produces blank nodes that need to be transformed into normal nodes before loaded into VIVO; (2) All created triples are placed in a separated graph; and (3) if this query is executed twice it will generate duplicated and dispensable triples. This is the most important limitation of using SPARQL for me. CWM will only execute a rule whenever necessary and the rules do not have to explicit declare any condition to avoid unnecessary creation of triples.

It is still not clear to me if all SPARQL queries can be rewrited to prevent non necessary creation of triples. Moreover, I don’t want to have too complicated SPARQL queries to maintain.

We found a bug in the split command of Mac OS

2013-07-18T00:00:00-03:00

Yesterday my friend Marcelo Nery and I found a bug in the split command of Mac OS. At first, I was surprised (we don’t expect to find bugs in core tools like grep, ls, split, wc…, right?) and almost expected to find the same bug in the Linux version of split. At least in the split of Ubuntu distribution, that was not the case. The bug is presented only in the Mac OS version.

The bug

Consider the file zero.log created with the following Common Lisp code (actually for the rest of the post you don’t need to understand the code):

(with-open-file (out "zero.log" :element-type '(unsigned-byte 8)
			      :direction :output
			      :if-exists :supersede
			      :external-format :utf-8)
	   (loop for char across (format nil "AB_CDE~%F~%G~%")
		     do (if (equal char #\_)
			      (loop for i from 1 to 3 do
                     (write-byte 0 out))
			      (write-byte (char-code char) out))))

This file content could be inspected with hexdump command:

$ hexdump -C zero.log
00000000  41 42 00 00 00 43 44 45  0a 46 0a 47 0a     |AB...CDE.F.G.|
0000000d

That is, the file has three 0 bytes in the first line right after the B letter and before the C letter. Now we want to split this file one line per file.

The Linux version of split works as expected, it splits the file keeping the zero bytes unchanged.

$ split -1 zero.log
$ for f in x??; do echo "---Begin: $f"; cat $f; echo "---End: $f"; done
---Begin: xaa
ABCDE
---End: xaa
---Begin: xab
F
---End: xab
---Begin: xac
G
---End: xac

Moreover, the sum of bytes of the x?? files is equal the number of bytes in the zero.log file, 13 bytes.

Nevertheless, the Mac OS version of split produces an unexpected output. The letter F is merged with the begining of the first line althouth it is in the second line of the zero.log file. Besides that, the zero bytes causes the Mac OS split to ignore the rest of the first line of zero.log causing a lost of data. The sum of the bytes of the x?? files in Mac OS is only 6 bytes.

$ split -1 zero.log
$ for f in x??; do echo "---Begin: $f"; cat $f; echo "---End: $f"; done
---Begin: xaa
ABF
---End: xaa
---Begin: xab
G
---End: xab

Reporting the bug

I reported the bug to Apple using the Mac OS Feedback form.

The GeTFun Research Project

2013-01-17T00:00:00-02:00

January, 1 2013 marked the official beginning of the GeTFun project. I am very excited about this project and willing to contributed and share ideas with all collaborators. The first workshop of the project will happen during the 4th UNILOG 2013 in Rio de Janeiro.

Pacote R dicionariosIBGE

2012-09-20T00:00:00-03:00

Disponibilizei hoje no github e submeti para o CRAN a versão 1.5 do pacote dicionariosIBGE. Este pacote contém os dicionários das principais pesquisas do IBGE: PNAD (1983-2009), POF (1987-1996) e PME. Também incluimos nesta versão variáveis adicionais com rótulos para as variáveis categóricas de cada pesquisa.

Nesta nova versão, incorporamos a função le.pesquisa original do pacote IBGEPesq que foi desenvolvido no IBGE mas nunca submetido ao CRAN. O pacote IBGEPesq é distribuído pelo IBGE nos CDs e DVDs vendidos na loja virtual do IBGE e disponibilizo no site do IBGE. Vide link “Leitura em R” na página da última PNAD.

Fizemos várias otimizações na função le.pesquisa original e incluímos ainda um argumento extra para leitura dos rótulos das variáveis categóricas. A partir desta versão do dicionariosIBGE, o pacote IBGEPesq torna-se desnecessário para leitura dos microdados das pesquisas do IBGE contempladas pelo dicionariosIBGE.

Observo, no entanto, que a novidade de disponibilizarmos os rótulos para as variáveis categóricas e adaptarmos a função le.pesquisa para usar os rótulos para construir factors ainda é experimental. Pessoalmente, questiono sua utilidade em geral. Existem variáveis categóricas cujos rótulos são realmente úteis. Por exemplo, variáveis como a UF da tabela de PESSOA da PNAD de 2009. Certamente trabalharmos com um factor com rótulo “Rio de Janeiro” ao invés de apenas o valor 33 torna o manuseio dos dados mais fácil. No entanto, existem variáveis categóricas como a V2927 cujos rótulos são tão grandes e verbosos que provavelmente não facilitam em nada o trabalho com os dados. Vide:

> rotpes2009[rotpes2009$cod == "V2927",]
       cod valor                                  rotulo
V2927     1                     Custaria muito caro
V2927     2                         Era muito longe
V2927     3                     Por falta de provas
V2927     4                         Demoraria muito
V2927     5 Cabia as outras partes iniciarem a acao
V2927     6    Por medo de outras partes envolvidas
V2927     7     por meio de mediacao ou conciliacao
V2927     8                 Nao acredita na justica
V2927     9  Nao sabia que podia utilizar a Justica
V2927    10                                  Outros

De qualquer modo, ao invés de usar os rótulos que distribuímos no pacote, nada impede que os usuários do pacote de: (1) passarem para a função le.pesquisa seus próprios data.frames com rótulos, bastando fornecer um data.frame com os rótulos no formato esperado (três colunas: cod, valor, rotulo); ou (2) passar o valor NULL para os rótulos (default da função) retornando os dados como numéricos e/ou string e não factors.

O pacote foi desenvolvido e testado no MacOS mas deve funcionar sem problemas no Linux e Windows.

Finalmente, cabe destacar que desenvolvemos o pacote usando os dicionários que encontramos nos CDs e DVDs disponíveis na FGV. Já tivemos casos de diferentes CDs da mesma pesquisa, adquiridos em diferentes momentos do IBGE, terem conteúdos diferentes (diferenças nos dicionários e diferenças nos arquivos de dados). O IBGE parece produzir os CDs e DVDs das pesquisas por demanda, o que pode explicar as diferenças entre CDs da mesma pesquisa.

A falta de padrão do IBGE na distribuição dos arquivos das pesquisas é um grande problema para os pesquisadores e atrabalha bastante nossa iniciativa de facilitar a leitura dos dados do IBGE em R. Para contornar os problemas, poderíamos tentar distribuir os dados do IBGE já em formato RData, para carga no R diretamente. No entanto, além das possíveis questões legais (não está claro no site do IBGE qual a licença de uso adotada pelo IBGE), certamente a credibilidade dos dados é maior se os dados são obtidos diretamente do site ou mídia do IBGE.

O problema dos galões

2012-05-06T00:00:00-03:00

Na primeira prova do curso de estrutura de dados que dei este ano, coloquei a seguinte questão para os alunos.

Nós temos 3 galões de tamanho 10, 7 e 4 litros. Os galões de 7 e 4 litros começam cheios e o galão de 10 litros vazio. Só podemos realizar um tipo de operação com os galões: derramar todo o conteúdo de um galão em outro, parando apenas quando o galão sendo derramado ficar vazio ou o destino ficar cheio. Queremos saber se existe uma sequência de operações que termine com 2 litros no galão de 7 ou 4 litros. Pede-se:

Modele o problema como um problema de grafo, descrevendo precisamente a definição do grafo envolvido e descrevendo a solução em função do grafo.
Qual algorítmo de grafo deverá ser usado?

Este é um problema clássico que pode ser encontrado em vários livros de estrutura de dados e algorítmos (Ex 3.8 do Algorithms by Dasgupta, Papadimitriou e Vazirani Amazon, site do livro, Wolfram). Trata-se de ver os estados do sistema (a quantidaade de líquido em cada galão) como um nó de um grafo. As arestas representam as possíveis transições de estado após transferência de líquido entre dois galões.

Um formalismo bem interessante para implementar a solução deste problema é lógica de reescrita. Em particular, resolvi usar Maude. Maude é uma implementação bastante eficiente e conhecida de lógica de reescrita, o nome refere-se a linguagem e ao sistema ao mesmo tempo.

A implementação em Maude é muito simples:

mod GAL is
  inc INT .

  sorts Galon System .
  subsort Galon < System .

  op <_,_> : Int Int -> Galon .
  op __ : System System -> System [assoc comm id: null] . 
  op null : -> System .

  vars N1 N2 M1 M2 : Int .

  crl [transfer-1] :
     < N1 , M1 > < N2 , M2 > => 
     < 0 , M1 > < (N1 + N2) , M2 > 
   if N1 < (M2 - N2) .

  crl [transfer-2] :
     < N1 , M1 > < N2 , M2 > => 
     < (N1 - (M2 - N2)) , M1 > < M2 , M2 > 
   if N1 > (M2 - N2) .

  op initial : -> System .
  eq initial = < 0 , 10 > < 7 , 7 > < 4 , 4 > .
endm

Trata-se de uma especificação algébrica do estado do sistema como um multiset de galões onde cada galão é uma dupla de números inteiros: primeiro componente é a quantidade de líquido e segundo a capacidade. A operação initial serve apenas para criar uma constante que representa o estado inicial do sistema.

As duas regras de reescrita fazem deste módulo um módulo de sistema ou, mais formalmente, uma etoria de reescrita. Estas regras implementam as duas possibilidades de transferência de líquido entre um galão e outro. Na primeira regra, todo o líquido é transferido de um galão para outro esvaziando o galão origem. Na segunda, a transferência é interrompida quando o galão destino torna-se cheio. Isto poderia ainda ser simplificado para uso de apenas uma regra, certo?!

O interessante de implementar em Maude é que as regras de reescrita podem ser entendidas, computacionalmente, como transições de estado de um sistema. Logicamente, as regras podem ser entendidas como regras de inferência de um sistema de reescrita.

Na prática, podemos aplicar as reescritas de estado usando o comando rew e realizar uma busca por estados a partir de um estado inicial usando o comando search.

Para testarmos a implementação, podemos aplicar algumas regras a partir do estado initial. Por exemplo, para aplicarmos 4 regras de reescrita a partir do estado inicial usamos:

Maude> rew [4] initial .
rewrite [4] in GAL : initial .
rewrites: 33 in 0ms cpu (0ms real) (131474 rewrites/second)
result System: < 0,4 > < 4,10 > < 7,7 >

Note-se que não controlamos que regras são aplicadas (estratégia de aplicação). Para encontrarmos a solução, usamos:

search initial =>* < 2 , X:Int > S:System such that X:Int < 10 .

Este comando acima efetua uma busca (BFS, busca em largura), a partir do estado inicial, por algum estado atingido com zero ou mais transições (aplicações de alguma das duas regras que definimos), por um estado onde exista algum galão com dois litros e cuja capacidade seja menor que 10.

A resposta do sistema são 4 possíveis soluções:

Solution 1 (state 16)
states: 17  rewrites: 501 in 3ms cpu (3ms real) (139244 rewrites/second)
S:System --> < 2,10 > < 7,7 >
X:Int --> 4

Solution 2 (state 18)
states: 19  rewrites: 559 in 4ms cpu (4ms real) (127334 rewrites/second)
S:System --> < 0,7 > < 9,10 >
X:Int --> 4

Solution 3 (state 19)
states: 20  rewrites: 610 in 5ms cpu (5ms real) (119210 rewrites/second)
S:System --> < 4,4 > < 5,10 >
X:Int --> 7

Solution 4 (state 20)
states: 21  rewrites: 627 in 5ms cpu (5ms real) (112164 rewrites/second)
S:System --> < 0,4 > < 9,10 >
X:Int --> 7

No more solutions.
states: 21  rewrites: 721 in 6ms cpu (6ms real) (109824 rewrites/second)

Para examinarmos a primeira solução, pedimos para o sistema mostrar o caminho, isto é, as reescritas executadas.

Maude> show path 16 .
state 0, System: < 0,10 > < 4,4 > < 7,7 >
===[ crl ... [label transfer-1] . ]===>
state 1, System: < 0,4 > < 4,10 > < 7,7 >
===[ crl ... [label transfer-2] . ]===>
state 4, System: < 0,4 > < 1,7 > < 10,10 >
===[ crl ... [label transfer-2] . ]===>
state 8, System: < 1,7 > < 4,4 > < 6,10 >
===[ crl ... [label transfer-1] . ]===>
state 12, System: < 0,4 > < 5,7 > < 6,10 >
===[ crl ... [label transfer-2] . ]===>
state 14, System: < 2,10 > < 4,4 > < 5,7 >
===[ crl ... [label transfer-2] . ]===>
state 16, System: < 2,4 > < 2,10 > < 7,7 >

O estado encontrado é onde o galão de 4 litros está com 2 litros, o galão de 7 litros está completo e o galão de 10 litros está com 2 litros.

Bem legal, não acham!?

Lattes to BibTeX

2012-02-15T00:00:00-02:00

Disponibilizei hoje online no github uma transformação do Lattes para BibTeX, vejam o repositório:

http://github.com/arademaker/SLattes

Eu acabei fazendo esta transformação por dois motivos. O primeiro para meu uso pessoal, eu já estava querendo faz muito tempo conseguir gerar um BibTex com minhas produções. O segundo foi como parte do projeto Semantic Lattes. A idéia é que uma transformação dos dados do Lattes para algum padrão de referências como o XML/MODS da Library of Congress, ajuda a validar os dados do Lattes.

Intruções de como usar o transformador estão no README do repositório, mas como o texto lá está em inglês, segue a idéia geral. O que fiz foi uma transformação XSLT do XML/Lattes para o XML/MODS. Este último pode ser então facilmente convertido para BibTex usando o xml2bib, programa do pacote Bibutils disponivel no Linux e no MacOS (MacPorts). Para executar a transformação e validar um XML em relação ao seu DTD/Schema, ainda são necessários os programas xsltproc e xmllint.

Instalação dos programas necessários

Para quem usa o MacPorts no MacOS:

sudo port -v install bibtool bibutils

O xmllint e xsltproc já estão instalados no MacOS (acho que no XCode).

Para quem usa Linux/Ubuntu:

sudo apt-get install bibtool bibutils xsltproc libxml2-utils

Para quem usa Windows, consultar o site destas ferramentas, não trivial! Esquece o Windows e instala o Ubuntu! ;-)

Usando a transformação

Com as ferramentas instaladas, o primeiro passo é acesssar o sistema Lattes do CNPq, link atualizar, logar-se no sistema e escolher a opção de exportar para XML. Será iniciado o download de um arquivo ZIP. Abra ZIP e extraia o arquivo XML dentro dele que tem mesmo nome, seu lattes ID. Imagine então que vc renomeou este arquivo XML para LATTES.xml e o moveu para o mesmo diretório onde está o arquivo com lattes2mods.xsl que você pegou do repositório no github.

Agora basta rodar:

xsltproc lattes2mods.xsl LATTES.xml > LATTES.mods

E em seguida:

xml2bib -b -w LATTES.mods > LATTES.bib

Mas o interessante é antes de rodar o xml2bib, validar o arquivo mods gerado contra o XML Schema do MODS, disponibilizado no site da Biblioteca do Congresso Americano, baixe a versão 3.4:

xmllint --schema mods.xsd LATTTES.mods

Esta validação serve para verificar não apenas erros na estrutura do arquivo, que seriam bugs no meu código, mas também erros nos dados, em função de informações erradas (faltantes, em lugar errado etc) no Lattes.

Comentários são sempre bem vindos. Problemas podem ser reportados diretamente no github.

R Package SSOAP

2012-01-02T00:00:00-02:00

Last year, during a summer course that I gave at FGV, I taught the students how to use SOAP protocol do retrive data from Banco Central do Brasil using R. BCB has a system called SGS (Sistema Gerenciador de Séries Temporais) that has a SOAP interface.

At that time, the package SSOAP had a small bug that I contributed to fix. Today I found that my contribution was incorporated in version 0.5-5 of this package whish makes my repository at github outdated.

It took my a couple of minutes to test the new version of this package. Since I am running the last version of R, 2.14, the general procedure for install packages didn’t work.

> install.packages("SSOAP")
Warning message:
In getDependencies(pkgs, dependencies, available, lib) :
  package ‘SSOAP’ is not available (for R version 2.14.0)

I finnaly figured out how to install the last version from source using the Omegahat repository version with the command:

> install.packages("SSOAP", repos = "http://www.omegahat.org/R", 
                   dependencies = TRUE, 
                   type = "source")
trying URL 'http://www.omegahat.org/R/src/contrib/SSOAP_0.8-1.tar.gz'
Content type 'application/x-gzip' length 195424 bytes (190 Kb)
opened URL
==================================================
downloaded 190 Kb

* installing *source* package ‘SSOAP’ ...
** R
** inst
** preparing package for lazy loading
Creating a new generic function for ‘help’ in package ‘SSOAP’
Warning in .NonstandardGenericTest(body(fdef), name, stdGenericBody) :
  the supplied generic function definition for toSOAP does not
  seem to call 'standardGeneric'; no methods will be dispatched!
** help
*** installing help indices
** building package indices ...
** testing if installed package can be loaded

* DONE (SSOAP)

The downloaded packages are in
	‘/private/var/.../downloaded_packages’

After that, I was prepared to actually test the package running the code that I created during the course (lesson 7 directory aula-07). But some changes in RCurl package requires a change in how we ask for not verify the ssl certificate. That is, I had to replace the ssl.verifypeer = FALSE argument by a list of options in the call of the function ff@functions$getValoresSeriesXML. The last version of this script is now available as a gist here:

Note that the ssl.verifypeer argument is necessary because the certificate used in BCB website is invalid! What a shame!

GitHub Pages and Jekyll plugins

2011-12-01T00:00:00-02:00

Everyone that use Jekyll and wants to host the site at GitHub should know that GitHub Pages does not allow custom plugins, right? Using Jekyll for a little more than a blog site, like EMAp/FGV will require plugins. In my case, avoid the use of custom plugins is not an option.

The solution is trivial, one has to run Jekyll locally and post the produzed files into a master branch of a git repo, following the conventions described at GitHub Pages por person and organization pages. The problem that I faced was to choose the best way to organize and keep tracking of the source and produzed files.

I read a couple of posts with possible solutions. The solution by Charlie Park force us to have two distinct git repositories. I don’t like this approach because of that. Our website will be maintained by more than one person, having two distinct repositories since that I will not using all git features. The solution by Jean Denis is a little bit better but keeps me thinking about why he need to keep the produced files under version control in the two branches, gh-pages and the master.

My final solution is to keep the directory produced by jekyll out of git control. This simple thing allows me to switch the branches, from source to master, and still have access to the produced files, directory _site. Once in the master branch, I only have to move the files under _site/ to the root directory in the master branch and update the master branch before push it to GitHub.

git checkout source
// do whatever you need
git status / git add / git commit
jekyll
checkout master
cp -r _site/* . && rm -rf _site/ && touch .nojekyll
git status > git add > git commit
git push -all origin

Comentários sobre ECLM 2011 e ISWC 2011 (1/2)

2011-11-27T00:00:00-02:00

Desde que voltei da minha última viagem para participar da ECLM 2011 e ISWC 2011, estou pensando em escrever sobre o assunto. Por estar escrevendo em português, acho que tenho lá ainda alguma chance de contribuir com algo novo. Neste post, vou falar da ISWC 2011. Vou começar listando alguns blogs que já escreveram sobre estas conferências em inglês.

Das duas conferências, certamente a ISWC é a maior e, por isso, também foi a mais comentada. São vários os posts de pessoas que escreveram sobre ela. Ivan Herman escreveu Some notes on ISWC2011. Também sobre a ISWC-2011 vale a pena ler o post Notes from ISWC 2011 e a série de 5 posts de Juan Sequeda.

Como Ivan escreveu no post dele, diferentes pessoas certamente relatarão diferentes experiências da ISWC 2011. Me chamou atenção os comentários dele sobre os trabalhos apresentados relacionados à visualização de ontologias. Embora o assunto me interesse, acho que perdi os workshops ou seções relacionadas a este tema. Foi bom ter lido o post dele.

Da minha parte, gostei bastante da ISWC 2011. A conferência foi bem organizada, o hotel muito bom e a cidade muito agradável. Dos workshops, o mais interessante para mim certamente foi o Ontology Matching, afinal, é o assunto que mais me interessa e sobre o qual tenho artigos publicados com Isabel Cafezeiro e Hermann. Assistir ao workshop me motivou a voltar a este assunto e tentar implementar efetivamente as idéias que formalizamos nos artigos.

Das seções da conferência, gostei bastante da “Ontology Matching, Mapping” e da “KR - Semantics”. No mais, vale dizer que os posters também estavam ótimos e a idéia de cada poster ser apresentado em 1 minuto foi bem divertida embora apenas alguns apresentadores tenham entendido o espírito da coisa! Das apresentações dos convidados, o que mais fez sucesso foi Frank van Harmelen com o título 10 Years of Semantic Web: does it work in theory?. Para mim, sendo minha área de pesquisa exatamente lógicas e, em particular, nos últimos anos, lógicas de descritivas, ter uma apresentação sugerindo que a comunidade de web semântica deve voltar a atenção para os fundamentos teóricos da área, é bastante motivador. Infelizmente assisti apenas parte da apresentação. O painel “Semantic Web Death Match” foi meio sem graça, embora na sala, assistindo as discussões, tenho que dizer que foi uma experiência única participar do painel pelo twitter. No twitter as discussões foram até mais interessantes. Finalmente, da seção “MANCHustifications and Provenance”, tive a idéia de revisar o texto da minha tese que será publicado pela Springer. A idéia é que pode-se obter diretamente de uma prova formal, usando os sistemas dedutivos que apresento para algumas DL em minha tese, a tal “justification of an entailment”. O termo refere-se ao conjunto mínimo de axiomas usados para justificar uma conclusão lógica (qual seria a melhor tradução para “entailment”?). Obrigado Samantha Bail por me ajudar a confirmar a impressão que tive durante a apresentação dos trabalhos na seção.

Gráficos de séries temporais no R

2011-10-31T00:00:00-02:00

Pergunta de dois alunos: como postar duas séries temporáis usando o ggplot? Resolvi responder usando este post. Vou aproveitar então para mostrar como postar séries temporáis usando o ggplot, lattice e o plot padrão do R.

Criando os dados

Para começar, criei um objeto série temporal conforme exemplo da função ts do R. Este objeto na realidade é uma matriz, são três séries temporais ou uma série temporal multivariável.

> dados <- ts(matrix(rnorm(300), 100, 3), start=c(1961, 1), 
              frequency=12)
> dados[1:4,]
       Series 1   Series 2   Series 3
[1,]  1.4165848  2.1049293  1.0155993
[2,] -0.4264193 -0.2730903  0.8754992
[3,]  0.5120809 -0.4023986  1.9757084
[4,]  0.1375277 -0.5043973 -0.7795633

Plot básico

Se usarmos o comando padrão de plot do pacote basic do R, temos o seguinte plot.

> plot(ts)

Obviamente, neste e nos próximos exemplos, estou mostrando o uso mais básico das funções, sem me preocupar com nenhum ajuste de formatação, legenda, rótulos, cores etc.

No pacote lattice

No pacote Lattice, temos a função xyplot que contém vários parâmetros para geração do gráfico. Explorei apenas a forma de gerar uma série por painel e todas as séries em um painel.

> xyplot(dados)

> xyplot(dados, superpose = TRUE)

A página de help da função xyplot contém muito mais informação sobre os demais parâmetros da função. A função xyplot também tem um método específico para lidar com objetos da classe Zoo do pacote zoo.

No pacote ggplot

Finalmente, como fazer no ggplot? Este foi o mais difícil. Demorei bastante a encontrar referências via google. As mais relevantes que encontrei foram:

O último link é a dica de como transformar um objeto ts em um data.frame:

datas <- seq(as.Date(paste(c(start(dados),1), collapse="/")), 
             by = "month", length.out = length(dados))
dados.df <- data.frame(date = datas, value = dados)

E finalmente consegui plotar uma série das três com:

> ggplot(data=dados.df) + geom_line(aes(date, value.Series.1))

Para conseguir em um único gráfico as três séries temporais, tive mais trabalho. Primeiro em transformar os dados em um data.frame que pudesse ser entendido pelo ggplot.

> tmp <- stack(dados.df, select = -1)
> tmp$date <- dados.df[,1]

E finalmente, o novo plot:

> ggplot(data=dados.df) + geom_line(aes(date, value.Series.1))

Conclusão

Não existe pacote melhor ou pior, cada um é mais adequado para cada situação. No particular problema de plotar multiplas séries temporais, sem nenhuma dúvida, preferi a facilidade do lattice em lidar com objetos ts.

Verifying the ISSN's check digit in Common Lisp

2011-09-13T00:00:00-03:00

The code below is my first approach to create a lisp function that test the ISSN check digit. Unfortunately, the code runs only in Allegro CL due the requirement of regexp2 library. Nevertheless, the regexp2 library is easly replaced by an opensource regexp library, which makes this not a real constraint.

That is it! Comments are welcome!

Construindo tabelas verdade no R

2011-03-02T00:00:00-03:00

Durante a preparação de alguns exercícios de lógica, me deparei com a necessidade de construir tabelas verdade. Lembrando do pacote xtable do R, pensei como seria construir uma tabela verdade usando o R. Minha solução em R está no github, gist abaixo, com o exemplo de como seria a tabela da expressão

\[\neg (a \lor b) \lor c\]

Observem que a saída do primeiro comando xtable é bastante bizarra, certamente um bug do pacote xtable. Editei a saída mantendo apenas o início da tabela gerada e incluíndo “…” no final.

xtable(tt)

% latex table generated in R 2.11.1 by xtable 1.5-6 package
% Wed Mar  2 23:18:40 2011
\begin{table}[ht]
\begin{center}
\begin{tabular}{rllll}
  \hline
 & a & b & c & ! (a $|$ b) $|$ c \\ 
  \hline
1 & c(FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE) & 
    c(FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE) & 
    c(FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE) & 
    c(FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE) \\ 
2 & c(FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE) & 
...
  \hline
\end{tabular}
\end{center}
\end{table}

Para fazer com que cada célula da tabela tivesse apenas o valor lógico correspondente, não um vetor, converti o data.frame em caracteres antes de usar o xtable. Minha solução original convertia em números, Bruno Lopes me lembrou de converter em caracteres diretamente.

\begin{table}[ht]
\begin{center}
\begin{tabular}{llll}
  \hline
a & b & c & \~{} (a OR b) OR c \\ 
  \hline
FALSE & FALSE & FALSE & TRUE \\ 
  FALSE & FALSE & TRUE & TRUE \\ 
  FALSE & TRUE & FALSE & FALSE \\ 
  FALSE & TRUE & TRUE & TRUE \\ 
  TRUE & FALSE & FALSE & FALSE \\ 
  TRUE & FALSE & TRUE & TRUE \\ 
  TRUE & TRUE & FALSE & FALSE \\ 
  TRUE & TRUE & TRUE & TRUE \\ 
   \hline
\end{tabular}
\end{center}
\end{table}

Barras e Linhas no R

2010-11-18T00:00:00-02:00

Ontem um aluno me perguntou como produzir um gráfico de barras com linhas. Minha primeira idéia foi recorrer a pacotes como Lattice ou ggplot2, imaginando tratar-se de um gráfico pouco usual. Depois de um pouco de pesquisa, acabei descobrindo que o gráfico em questão não é tão usual assim e pode ser facilmente produzido com os comandos básicos de gráficos do R.

Digamos que seus dados sejam uma data.frame composto por duas variáveis.

dados <- data.frame(a = sample(1:100,10), b = sample(1:100,10))

O que desejamos é representar no gráfico os valores da variável a como barras e os valores da variável b como pontos conectados por linhas. O comando abaixo produz o gráfico de barras e retorna um vetor com as coordenadas x dos meios das barras produzidas.

a <- barplot(dados$a, ylim = c(0,100))

Agora é fácil criar os pontos e linhas:

points(a, dados$b, ylim= c(0,100))
lines(a, dados$b, ylim= c(0,100))

Image que seus dados são temporais, onde cada observação está relacionada a uma ano. Pode-se incluir os anos como rótulos do eixo “x” com o comando:

axis(1, at = a, labels = 2000:2009)

Datasets no Brasil

2010-01-30T00:00:00-02:00

Estão começando a surgir no Brasil iniciativas para real transparência no acesso aos dados do governo. A estruturação dos dados em formatos abertos (RDF, CSV etc), acompanhados de metadados e indexados em interfaces de busca e navegação que facilitem o download dos arquivos são para mim as condições necessárias para o livre acesso à informação. Uma destas iniciativas é o LeXML. Nos EUA existem os projetos data.gov e datasf.org.

Na linha oposta, estão serviços como o da ANP de levantamento de preços de combustíveis. Que tipo de pesquisa pode ser feita com estes dados? Para começar, só a construção de um datasets a partir deste site demanda um bom trabalho de desenvolvimento de um crawler e transformadores. Afinal, eu me pergunto, qual é o objetivo deste site da ANP? Se for para um cidadão comum pesquisar qual o melhor posto para abastecer seu carro, a interface deixa a desejar. Se for para a sociedade acompanhar os preços de combustíveis no Brasil, isto implica acessibilidade as séries de dados, e todos meus comentários anteriores fazem sentido, não?

m	s	x	y
9	10	1	9
8	9	1	8
7	8	1	7
6	7	1	6
5	6	1	5
4	5	1	4
3	4	1	3
2	3	1	2
1	2	1	1
18	11	2	9
16	10	2	8
14	9	2	7
12	8	2	6
10	7	2	5
8	6	2	4
6	5	2	3
4	4	2	2
27	12	3	9
24	11	3	8
21	10	3	7
18	9	3	6
15	8	3	5
12	7	3	4
9	6	3	3
36	13	4	9
32	12	4	8
28	11	4	7
24	10	4	6
20	9	4	5
16	8	4	4
45	14	5	9
40	13	5	8
35	12	5	7
30	11	5	6
25	10	5	5
54	15	6	9
48	14	6	8
42	13	6	7
36	12	6	6
63	16	7	9
56	15	7	8
49	14	7	7
72	17	8	9
64	16	8	8
81	18	9	9

m	s	x	y
36	12	6	6
36	13	4	9
24	10	4	6
24	11	3	8
12	7	3	4
12	8	2	6
16	8	4	4
16	10	2	8
18	9	3	6
18	11	2	9
4	4	2	2
4	5	1	4
6	5	2	3
6	7	1	6
8	6	2	4
8	9	1	8
9	6	3	3
9	10	1	9

m	s	x	y
9	6	3	3
8	6	2	4
6	5	2	3
4	5	1	4
8	9	1	8
18	9	3	6
16	8	4	4
12	8	2	6
6	7	1	6
12	7	3	4
18	11	2	9
24	11	3	8
9	10	1	9
16	10	2	8
24	10	4	6

m	s	x	y
24	10	4	6
24	11	3	8
12	7	3	4
12	8	2	6
16	10	2	8
16	8	4	4
18	11	2	9
18	9	3	6
6	7	1	6
6	5	2	3
8	9	1	8
8	6	2	4
9	10	1	9
9	6	3	3

m	s	x	y
9	6	3	3
8	6	2	4
8	9	1	8
18	9	3	6
16	8	4	4
12	8	2	6
6	7	1	6
12	7	3	4
18	11	2	9
24	11	3	8
9	10	1	9
16	10	2	8
24	10	4	6

m	s	x	y
24	10	4	6
24	11	3	8
12	7	3	4
12	8	2	6
16	10	2	8
16	8	4	4
18	11	2	9
18	9	3	6
8	9	1	8
8	6	2	4
9	10	1	9
9	6	3	3

m	s	x	y
9	6	3	3
8	6	2	4
8	9	1	8
18	9	3	6
16	8	4	4
12	8	2	6
18	11	2	9
24	11	3	8
9	10	1	9
16	10	2	8
24	10	4	6

m	s	x	y
9	10	1	9
8	9	1	8
7	8	1	7
6	7	1	6
5	6	1	5
4	5	1	4
3	4	1	3
2	3	1	2
1	2	1	1
18	11	2	9
16	10	2	8
14	9	2	7
12	8	2	6
10	7	2	5
8	6	2	4
6	5	2	3
4	4	2	2
27	12	3	9
24	11	3	8
21	10	3	7
18	9	3	6
15	8	3	5
12	7	3	4
9	6	3	3
36	13	4	9
32	12	4	8
28	11	4	7
24	10	4	6
20	9	4	5
16	8	4	4
45	14	5	9
40	13	5	8
35	12	5	7
30	11	5	6
25	10	5	5
54	15	6	9
48	14	6	8
42	13	6	7
36	12	6	6
63	16	7	9
56	15	7	8
49	14	7	7
72	17	8	9
64	16	8	8
81	18	9	9

m	s	x	y
36	12	6	6
36	13	4	9
24	10	4	6
24	11	3	8
12	7	3	4
12	8	2	6
16	8	4	4
16	10	2	8
18	9	3	6
18	11	2	9
4	4	2	2
4	5	1	4
6	5	2	3
6	7	1	6
8	6	2	4
8	9	1	8
9	6	3	3
9	10	1	9

m	s	x	y
9	6	3	3
8	6	2	4
6	5	2	3
4	5	1	4
8	9	1	8
18	9	3	6
16	8	4	4
12	8	2	6
6	7	1	6
12	7	3	4
18	11	2	9
24	11	3	8
9	10	1	9
16	10	2	8
24	10	4	6

m	s	x	y
24	10	4	6
24	11	3	8
12	7	3	4
12	8	2	6
16	10	2	8
16	8	4	4
18	11	2	9
18	9	3	6
6	7	1	6
6	5	2	3
8	9	1	8
8	6	2	4
9	10	1	9
9	6	3	3

m	s	x	y
9	6	3	3
8	6	2	4
8	9	1	8
18	9	3	6
16	8	4	4
12	8	2	6
6	7	1	6
12	7	3	4
18	11	2	9
24	11	3	8
9	10	1	9
16	10	2	8
24	10	4	6

m	s	x	y
24	10	4	6
24	11	3	8
12	7	3	4
12	8	2	6
16	10	2	8
16	8	4	4
18	11	2	9
18	9	3	6
8	9	1	8
8	6	2	4
9	10	1	9
9	6	3	3

m	s	x	y
9	6	3	3
8	6	2	4
8	9	1	8
18	9	3	6
16	8	4	4
12	8	2	6
18	11	2	9
24	11	3	8
9	10	1	9
16	10	2	8
24	10	4	6

m	s	x	y
9	10	1	9
8	9	1	8
7	8	1	7
6	7	1	6
5	6	1	5
4	5	1	4
3	4	1	3
2	3	1	2
1	2	1	1
18	11	2	9
16	10	2	8
14	9	2	7
12	8	2	6
10	7	2	5
8	6	2	4
6	5	2	3
4	4	2	2
27	12	3	9
24	11	3	8
21	10	3	7
18	9	3	6
15	8	3	5
12	7	3	4
9	6	3	3
36	13	4	9
32	12	4	8
28	11	4	7
24	10	4	6
20	9	4	5
16	8	4	4
45	14	5	9
40	13	5	8
35	12	5	7
30	11	5	6
25	10	5	5
54	15	6	9
48	14	6	8
42	13	6	7
36	12	6	6
63	16	7	9
56	15	7	8
49	14	7	7
72	17	8	9
64	16	8	8
81	18	9	9

m	s	x	y
36	12	6	6
36	13	4	9
24	10	4	6
24	11	3	8
12	7	3	4
12	8	2	6
16	8	4	4
16	10	2	8
18	9	3	6
18	11	2	9
4	4	2	2
4	5	1	4
6	5	2	3
6	7	1	6
8	6	2	4
8	9	1	8
9	6	3	3
9	10	1	9

m	s	x	y
9	6	3	3
8	6	2	4
6	5	2	3
4	5	1	4
8	9	1	8
18	9	3	6
16	8	4	4
12	8	2	6
6	7	1	6
12	7	3	4
18	11	2	9
24	11	3	8
9	10	1	9
16	10	2	8
24	10	4	6

m	s	x	y
24	10	4	6
24	11	3	8
12	7	3	4
12	8	2	6
16	10	2	8
16	8	4	4
18	11	2	9
18	9	3	6
6	7	1	6
6	5	2	3
8	9	1	8
8	6	2	4
9	10	1	9
9	6	3	3

m	s	x	y
9	6	3	3
8	6	2	4
8	9	1	8
18	9	3	6
16	8	4	4
12	8	2	6
6	7	1	6
12	7	3	4
18	11	2	9
24	11	3	8
9	10	1	9
16	10	2	8
24	10	4	6

m	s	x	y
24	10	4	6
24	11	3	8
12	7	3	4
12	8	2	6
16	10	2	8
16	8	4	4
18	11	2	9
18	9	3	6
8	9	1	8
8	6	2	4
9	10	1	9
9	6	3	3

m	s	x	y
9	6	3	3
8	6	2	4
8	9	1	8
18	9	3	6
16	8	4	4
12	8	2	6
18	11	2	9
24	11	3	8
9	10	1	9
16	10	2	8
24	10	4	6