#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# corpus trainer, v1.0
#
# Jaemok Jeong([email protected]), 2014/05/14

import re
import collections
import json
import sys

# train.txt와 train.qry로부터 word별 확률 model을 만든다. 
#
# model 1 : train.qry의 정답 자료에 corpusN/answerN 가중치 부여 
# model 2 : train.qry의 정답 자료에 corpus에서 제일 많이 나온 단어수 가중치 부여 
# model 3 : train.qry의 정답 자료에 corpusN 가중치 부여 
#
# 결과는 dictionary 형태로 train.model로 저장한다. 

def train():
    corpus_fname = len(sys.argv)>1 and sys.argv[1] or "../res/train.txt"
    query_fname = len(sys.argv)>2 and sys.argv[2] or "../res/train.qry"
    model_fname = len(sys.argv)>3 and sys.argv[3] or "../oth/train.model"

    print "Make model from '%s' and '%s'\n" % (corpus_fname, query_fname)

    try:
        fcorpus = open(corpus_fname, "r")
        fquery = open(query_fname, "r")
    except IOError:
        print "File open Error"
        sys.exit(1)

    # train.txt 파일로부터 단어의 빈도 조사
    dict_corpus = collections.Counter()
    for line in fcorpus:
        words = re.findall(r'\w+',line.strip().lower())
        
        for w in words:  # single corpus
            dict_corpus[w] += 1
    corpusN = float(sum(dict_corpus.itervalues()))

    # train.qry 파일로부터 정답의 빈도 조사
    dict_answer = collections.Counter()
    for line in fquery:
        (ques,ans) = line.strip().lower().split('\t')
        words = re.findall(r'\w+',ans)
        
        for w in words:
            dict_answer[w] += 1
    answerN = float(sum(dict_answer.itervalues()))

    print "- corpus (wordN,corpusN) = %d, %d" % (len(dict_corpus),corpusN)
    print "- answer (wordN,corpusN) = %d, %d" % (len(dict_answer),answerN)
    
    # print "* most common 7 (corpus)"
    # print " ", dict_corpus.most_common(7)
    # print "* most common 7 (answer)"
    # print " ", dict_answer.most_common(7)
    
    # 1. train.qry의 정답 자료에 corpusN/answerN 가중치 부여
    # 2. train.qry의 정답 자료에 corpus에서 제일 많이 나온 단어수 가중치 부여 
    # 3. train.qry의 정답 자료에 corpusN 가중치 부여
    models = []
    for mod in (corpusN/answerN, dict_corpus.most_common(1)[0][1]+1,corpusN):
        d = {}
        for key in set(dict_corpus.keys()+dict_answer.keys()):
            val = 0
            if key in dict_corpus:
                val += dict_corpus[key]
            if key in dict_answer:
                val += dict_answer[key]*mod
            d[key] = val / (corpusN+answerN*mod)
        d['$n'] = corpusN+answerN*mod
        models.append(d)

    train_model = { '1': models[0],'2': models[1], '3': models[2] }
    
    with open(model_fname, "w") as f:
        f.write(json.dumps(train_model))

    print "\nWriting '%s'" % model_fname

if __name__ == '__main__':
    train()

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# tester.py, v1.0
#
# Jaemok Jeong([email protected]), 2014/05/14

# Reference :
#
#  "Natural Language Corpus Data" from the book "Beautiful Data" (Segaran and Hammerbacher, 2009)
#   http://oreilly.com/catalog/9780596157111/

import operator
import json
import time
import sys
import os

MAX_CORPUS = 20

def Pw(key):
    """각 단어의 빈도 확률
    저장된 dict_model의 확률 table 값을 참조:"""
    if key in dict_model: return dict_model[key]
    else: return 10./(dict_model['$n'] * 10**len(key))

def memoize(f):
  class memodict(dict):
      __slots__ = ()
      def __missing__(self, key):
          self[key] = ret = f(key)
          return ret
  return memodict().__getitem__

@memoize
def segment(text):
    """가장 최적으로 잘려진 단어 리스트를 반환
    Recursion을 이용하여 단어를 분리 후, 각 list의 각 단어 확률의 곱이 최대가 되는 Pair를 결과로 반환 
    중복계산을 막기 위해 memoize decorator를 이용하여 중간 결과를 dictionary에 저장
    """
    if not text: return []
    cs = ([f]+segment(r) for f,r in [(text[:i+1], text[i+1:]) for i in range(min(len(text), MAX_CORPUS))])
    return max(cs, key=lambda words: reduce(operator.mul, (Pw(w) for w in words)))

if __name__ == '__main__':
    global dict_model

    start = time.clock()

    model = len(sys.argv)>1 and sys.argv[1] or '3'
    ifname = len(sys.argv)>2 and sys.argv[2] or '../res/test.qry'
    outdir = len(sys.argv)>3 and sys.argv[3] or '../ans'
    modelname = len(sys.argv)>4 and sys.argv[4] or '../oth/train.model'

    ofname = os.path.join(outdir, os.path.splitext(os.path.basename(ifname))[0]+".ans."+model)
    train_model = json.loads(open(modelname, 'r').read())
    print "Using model-%s in %s" % (model, modelname)
    print "Reading %s" % ifname
    
    dict_model = train_model[model]

    of = open(ofname,'w')
    cnt = 0
    with open(ifname, 'r') as f:
        for line in f:
            # (q,a) = line.strip().split('\t')
            # ans = " ".join(segment(q))
            ans = " ".join(segment(line.strip()))
            cnt += 1
            # if ans != a:
            #     print q, ":", "[", a, "]", ans
            #     cnt += 1
            of.write(ans+"\n")
    end = time.clock()
    of.close()
    print "Writing %s" % ofname
    print "Elapsed time: %.2gs, Total cnt: %d" % ((end-start), cnt)