Novo programa

Pois é. No último post eu estava aprendendo como programar em Python... Agora o negócio é pra valer. Este é o primeiro programa que estamos usando para ler um corpus de quase 200.000 frases e extrair as marcações sintáticas de cada palavra em relação à palavra à qual esta está subordinada. Tipo, no caso de "João viu o macaco", eu tenho que mostrar as informações como viu: sujeito(João), viu: objeto(macaco). Estamos focando em substantivos e verbos. Depois de fazer essa lista, vamos processar um outro corpus que, ao invés de marcações sintáticas, possui marcações semânticas, isto é, diz se "macaco" no caso acima se trata do animal ou da ferramenta usada para trocar pneus de automóveis... Com isso, vamos cruzar as duas informações e procurar por "campos semânticos", isto é, conjunto de palavras que possuem uma certa similaridade e são usadas em determinados contextos, criando um banco de dados que possa vir ser usado no futuro como base de um programa de tradução automática, por exemplo. Por enquanto, ainda está bem cru, mas não parece impossível que cheguemos lá. A propósito, resolvemos fazer juntos esse projeto, eu e o carinha que também trabalha lá no laboratório de lingüística computacional, o Kim Munhyeong. Ah, e outro detalhe, a pesquisa é com um corpus de língua coreana. o.O

Aí vai o leitor/processador do primeiro corpus:

#!/usr/bin/python
#encoding: utf-8
import sys, re, codecs

class ForestWalker:
 def __init__(self, file):
  self.file = file
 def __iter__(self):
  return self
 def readtree(self):
  # read sentence form line
  line = self.readline()
  tree = Tree(line.split(' ')[0])
  # make list of nodes
  list_of_nodes = []
  line = self.readline()
  while (line):
   (ord, dep, tag1, tag2, wordform, morph_string) = line.split("\t") 
   morphs = self.parse_morph_string(morph_string)
   word = Word(ord, wordform, morphs, morph_string)
   list_of_nodes.append(Node(ord, dep, tag1, tag2, word))
   line = self.readline()
  # make tree with list of nodes
  # set parent-child relations
  for n in list_of_nodes:
   if n.dep == n.ord:
    tree.set_root(n)
   else:
    p = list_of_nodes[int(n.dep)-1]
    n.parent = p
    p.add_a_child(n)
  tree.nodes = list_of_nodes
  return tree
 def parse_morph_string(self, morph_string):
  morphs = []
  m = morph_string
  for m in morph_string.split('+'):
   m = m.strip()
   if m == "" :
    pass
   else :
    if m == "/SW":
     form, pos = "+", "SW"
    elif m[0:2] == "//":
     form, pos = "/", m[2:]
    else :
     try :
      form, pos = m.split("/")
      if pos == "" : pos = "_ERR_"
     except :
      form, pos = m, "_ERR_" 
    morphs.append(Morph(form,pos))
  return morphs
 def readline(self):
  line = self.file.readline()
  # EOF
  if (line == '') : sys.exit(0)
  return line.strip()
  fields = line.strip().split("\t")
  if len(fields) == 6 :
   return fields
  else :
   return line.strip() 
 def next(self):
  return self.readtree()

class TreeBank:
 pass
 
class Tree:
 def __init__(self, id):
  self.id = id
  self.nodes = []
  self.root = None
  self.terminals = []
 def set_root(self, node):
  self.root = node
 def get_terminals(self):
  if self.terminals :
   pass
  else:
   for n in self.nodes:
    if not n.children :
     self.terminals.append(n)
  return self.terminals

class Node:
 def __init__(self, ord, dep, tag1, tag2, word):
  self.parent = None
  self.children = []
  self.ord = ord
  self.dep = dep
  self.tag1 = tag1
  self.tag2 = tag2
  self.form = word.form
  self.word = word
 def add_a_child(self, node):
  self.children.append(node)

class Morph:
 def __init__(self, form, pos):
  self.form = form
  self.pos = pos

class Word:
 def __init__(self, ord, form, morphs, morph_string):
  self.ord = ord
  self.form = form
  self.morphs = morphs
  self.morph_string = morph_string
 def add_morph(self, morph):
  self.morphs.append(morph)
 def has_pos(self, pos):
  for m in self.morphs:
   if m.pos == pos :
    return True
  return False
 def __str__(self):
  str = ""
  for m in self.morphs:
   if str == "":
    str = m.form
   elif m.pos[0] == "S" :
    str += m.form
   else :
    str += "-" + m.form
  return str
  #return reduce(lambda x,y: x.form+"-"+y.form, self.morphs)

class Encode:
 def __init__(self, stdout, enc):
  self.stdout = stdout
  self.encoding = enc
 def write(self, s):
  self.stdout.write(s.encode(self.encoding))

def get_output_string1(morphs) :
 str = ""
 pos_arr = []
 morphform_arr = []
 for m in morphs:
  pos_arr.append(m.pos)
  morphform_arr.append(m.form)
 str = ''.join(morphform_arr)
 return str

def get_output_string2(morphs) :
 str = ""
 pos_arr = []
 morphform_arr = []
 for m in morphs:
  pos_arr.append(m.pos)
  morphform_arr.append(m.form)
 str = ''.join(morphform_arr)
 return str

def get_verbform(words):
 v = re.compile(r".*?/")
 w = ''.join(words)
 arr = v.findall(w)
 str = ''.join(arr)
 return str
 
sys.stdout = Encode(sys.stdout, "utf8")

for s in ForestWalker(codecs.open(sys.argv[1], encoding="utf8")):
 for n in s.nodes:
  if re.compile(r'[ NV][PSQ]_[^C]').match(n.tag2):
   if n.parent:
    tg = re.compile('.*?_')
    if re.compile(r'N.?').match(n.parent.tag2):
     print "%s\t%s\t%sN" % (get_output_string1(n.word.morphs), tg.sub(r'', n.tag2), n.parent.word.morph_string.split(r'/')[0])
    elif re.compile(r'V.?').match(n.parent.tag2):
     print "%s\t%s\t%sV" % (get_output_string1(n.word.morphs), tg.sub(r'', n.tag2), get_verbform(n.parent.word.morph_string))

Na verdade, o programa em si, são só as últimas linhas. Todas as classes presentes aqui, são de outro projeto chamado KLTK (Korean Language Toolkit), feito por um doutorando daqui. Esse KLTK está sendo feito nos moldes do NLTK (Natural Language Toolkit) para o processamento da língua coreana e do novo dicionário eletrônico que foi feito recentemente, o Grande Dicionário Eletrônico Sejong... Como diria o Thiago, tá mais pra o Milenar Grande Dicionário... hehe

Faltam 2 dias para apresentar o projeto e 8 dias para entregar o paper com tudo bonitinho. Parece que ainda falta um século...

Um abraço pra quem não está ocupado e pra quem está também. ;)

Fui...