def compose(self, data, arg_space):
"""
Uses a lexical function composition model to compose elements.
Args:
data: data to be composed. List of tuples, each containing 3
strings: (function_word, arg, composed_phrase). function_word and
arg are the elements to be composed and composed_phrase is the
string associated to their composition. function_word elements
are interpreted in self.function_space.
arg_space: argument space, of type Space. arg elements of data are
interpreted in this space.
Returns:
composed space: a new object of type Space, containing the
phrases obtained through composition.
"""
start = time.time()
assert_is_instance(arg_space, Space)
arg1_list, arg2_list, phrase_list = self.valid_data_to_lists(
data, (self._function_space.row2id, arg_space.row2id, None))
composed_vec_list = []
for i in range(len(arg1_list)):
arg1_vec = self._function_space.get_row(arg1_list[i])
arg2_vec = arg_space.get_row(arg2_list[i])
matrix_type = get_type_of_largest([arg1_vec, arg2_vec])
[arg1_vec, arg2_vec] = resolve_type_conflict([arg1_vec, arg2_vec],
matrix_type)
composed_ph_vec = self._compose(arg1_vec, arg2_vec,
self._function_space.element_shape)
composed_vec_list.append(composed_ph_vec)
result_element_shape = self._function_space.element_shape[0:-1]
composed_ph_mat = composed_ph_vec.nary_vstack(composed_vec_list)
log.print_name(logger, self, 1, "\nComposed with composition model:")
log.print_info(logger, 3,
"Composed total data points:%s" % len(arg1_list))
log.print_info(
logger, 3,
"Functional shape of the resulted (composed) elements:%s" %
(result_element_shape, ))
log.print_matrix_info(logger, composed_ph_mat, 4,
"Resulted (composed) semantic space:")
log.print_time_info(logger, time.time(), start, 2)
return Space(composed_ph_mat,
phrase_list,
self.composed_id2column,
element_shape=result_element_shape)
def compose(self, data, arg_space):
"""
Uses a lexical function composition model to compose elements.
Args:
data: data to be composed. List of tuples, each containing 3
strings: (function_word, arg, composed_phrase). function_word and
arg are the elements to be composed and composed_phrase is the
string associated to their composition. function_word elements
are interpreted in self.function_space.
arg_space: argument space, of type Space. arg elements of data are
interpreted in this space.
Returns:
composed space: a new object of type Space, containing the
phrases obtained through composition.
"""
start = time.time()
assert_is_instance(arg_space, Space)
arg1_list, arg2_list, phrase_list = self.valid_data_to_lists(data,
(self._function_space.row2id,
arg_space.row2id,
None))
composed_vec_list = []
for i in xrange(len(arg1_list)):
arg1_vec = self._function_space.get_row(arg1_list[i])
arg2_vec = arg_space.get_row(arg2_list[i])
matrix_type = get_type_of_largest([arg1_vec, arg2_vec])
[arg1_vec, arg2_vec] = resolve_type_conflict([arg1_vec, arg2_vec],
matrix_type)
composed_ph_vec = self._compose(arg1_vec, arg2_vec,
self._function_space.element_shape)
composed_vec_list.append(composed_ph_vec)
result_element_shape = self._function_space.element_shape[0:-1]
composed_ph_mat = composed_ph_vec.nary_vstack(composed_vec_list)
log.print_name(logger, self, 1, "\nComposed with composition model:")
log.print_info(logger, 3, "Composed total data points:%s" % len(arg1_list))
log.print_info(logger, 3, "Functional shape of the resulted (composed) elements:%s"
% (result_element_shape,))
log.print_matrix_info(logger, composed_ph_mat, 4,
"Resulted (composed) semantic space:")
log.print_time_info(logger, time.time(), start, 2)
return Space(composed_ph_mat, phrase_list, self.composed_id2column,
element_shape = result_element_shape)
def vstack(cls, space1, space2):
"""
Classmethod. Stacks two semantic spaces.
The rows in the two spaces are concatenated.
Args:
space1, space2: spaces to be stacked, of type Space
Returns:
Stacked space, type Space.
Raises:
ValueError: if the spaces have different number of columns
or their columns are not identical
"""
if space1.cooccurrence_matrix.shape[
1] != space2.cooccurrence_matrix.shape[1]:
raise ValueError("Inconsistent shapes: %s, %s" %
(space1.cooccurrence_matrix.shape[1],
space2.cooccurrence_matrix.shape[1]))
if space1.id2column != space2.id2column:
raise ValueError("Identical columns required")
new_row2id = add_items_to_dict(space1.row2id.copy(), space2.id2row)
new_id2row = space1.id2row + space2.id2row
matrix_type = get_type_of_largest(
[space1.cooccurrence_matrix, space2.cooccurrence_matrix])
[new_mat1, new_mat2] = resolve_type_conflict(
[space1.cooccurrence_matrix, space2.cooccurrence_matrix],
matrix_type)
new_mat = new_mat1.vstack(new_mat2)
log.print_info(logger, 1, "\nVertical stack of two spaces")
log.print_matrix_info(logger, space1.cooccurrence_matrix, 2,
"Semantic space 1:")
log.print_matrix_info(logger, space2.cooccurrence_matrix, 2,
"Semantic space 2:")
log.print_matrix_info(logger, new_mat, 2, "Resulted semantic space:")
return Space(new_mat,
new_id2row,
list(space1.id2column),
new_row2id,
space1.column2id.copy(),
operations=[])
def vstack(cls, space1, space2):
"""
Classmethod. Stacks two semantic spaces.
The rows in the two spaces are concatenated.
Args:
space1, space2: spaces to be stacked, of type Space
Returns:
Stacked space, type Space.
Raises:
ValueError: if the spaces have different number of columns
or their columns are not identical
"""
if space1.cooccurrence_matrix.shape[1] != space2.cooccurrence_matrix.shape[1]:
raise ValueError("Inconsistent shapes: %s, %s"
% (space1.cooccurrence_matrix.shape[1],
space2.cooccurrence_matrix.shape[1]))
if space1.id2column != space2.id2column:
raise ValueError("Identical columns required")
new_row2id = add_items_to_dict(space1.row2id.copy(), space2.id2row)
new_id2row = space1.id2row + space2.id2row
matrix_type = get_type_of_largest([space1.cooccurrence_matrix,
space2.cooccurrence_matrix])
[new_mat1, new_mat2] = resolve_type_conflict([space1.cooccurrence_matrix,
space2.cooccurrence_matrix],
matrix_type)
new_mat = new_mat1.vstack(new_mat2)
log.print_info(logger, 1, "\nVertical stack of two spaces")
log.print_matrix_info(logger, space1.cooccurrence_matrix, 2,
"Semantic space 1:")
log.print_matrix_info(logger, space2.cooccurrence_matrix, 2,
"Semantic space 2:")
log.print_matrix_info(logger, new_mat, 2, "Resulted semantic space:")
return Space(new_mat, new_id2row, list(space1.id2column), new_row2id,
space1.column2id.copy(), operations=[])
def train(self, train_data, arg_space, phrase_space):
"""
Trains a lexical function composition model to learn a function
space and sets the function_space parameter.
Args:
train_data: list of string tuples. Each tuple contains 3
string elements: (function_word, arg, phrase).
arg_space: argument space, of type Space. arg elements of
train data are interpreted in this space.
phrase space: phrase space, of type Space. phrase elements of
the train data are interpreted in this space.
Training tuples which contain strings not found in their
respective spaces are ignored. Function words containing less than
_MIN_SAMPLES training instances are ignored. For example, if
_MIN_SAMPLES=2 and function word "red" occurs in only one phrase, "red"
is ignored.
The id2column attribute of the resulted composed space is set to
be equal to that of the phrase space given as an input.
"""
start = time.time()
self._has_intercept = self._regression_learner.has_intercept()
if not isinstance(arg_space, Space):
raise ValueError("expected one input spaces!")
result_mats = []
train_data = sorted(train_data, key=lambda tup: tup[0])
function_word_list, arg_list, phrase_list = self.valid_data_to_lists(train_data,
(None,
arg_space.row2id,
phrase_space.row2id))
#partitions the sorted input data
keys, key_ranges = get_partitions(function_word_list, self._MIN_SAMPLES)
if not keys:
raise ValueError("No valid training data found!")
assert(len(arg_space.element_shape) == 1)
if self._has_intercept:
new_element_shape = phrase_space.element_shape + (arg_space.element_shape[0] + 1,)
else:
new_element_shape = phrase_space.element_shape + (arg_space.element_shape[0],)
for i in xrange(len(key_ranges)):
idx_beg, idx_end = key_ranges[i]
print ("Training lexical function...%s with %d samples"
% (keys[i], idx_end - idx_beg))
arg_mat = arg_space.get_rows(arg_list[idx_beg:idx_end])
phrase_mat = phrase_space.get_rows(phrase_list[idx_beg:idx_end])
#convert them to the same type
matrix_type = get_type_of_largest([arg_mat, phrase_mat])
[arg_mat, phrase_mat] = resolve_type_conflict([arg_mat, phrase_mat],
matrix_type)
result_mat = self._regression_learner.train(arg_mat, phrase_mat).transpose()
result_mat.reshape((1, np.prod(new_element_shape)))
result_mats.append(result_mat)
new_space_mat = arg_mat.nary_vstack(result_mats)
self.composed_id2column = phrase_space.id2column
self._function_space = Space(new_space_mat, keys, [],
element_shape=new_element_shape)
log.print_composition_model_info(logger, self, 1, "\nTrained composition model:")
log.print_info(logger, 3, "Trained: %s lexical functions" % len(keys))
log.print_info(logger, 3, "With total data points:%s" % len(function_word_list))
log.print_matrix_info(logger, arg_space.cooccurrence_matrix, 3,
"Semantic space of arguments:")
log.print_info(logger, 3, "Shape of lexical functions learned:%s"
% (new_element_shape,))
log.print_matrix_info(logger, new_space_mat, 3,
"Semantic space of lexical functions:")
log.print_time_info(logger, time.time(), start, 2)
def train(self, train_data, arg_space, phrase_space):
"""
Trains a lexical function composition model to learn a function
space and sets the function_space parameter.
Args:
train_data: list of string tuples. Each tuple contains 3
string elements: (function_word, arg, phrase).
arg_space: argument space, of type Space. arg elements of
train data are interpreted in this space.
phrase space: phrase space, of type Space. phrase elements of
the train data are interpreted in this space.
Training tuples which contain strings not found in their
respective spaces are ignored. Function words containing less than
_MIN_SAMPLES training instances are ignored. For example, if
_MIN_SAMPLES=2 and function word "red" occurs in only one phrase, "red"
is ignored.
The id2column attribute of the resulted composed space is set to
be equal to that of the phrase space given as an input.
"""
start = time.time()
self._has_intercept = self._regression_learner.has_intercept()
if not isinstance(arg_space, Space):
raise ValueError("expected one input spaces!")
result_mats = []
train_data = sorted(train_data, key=lambda tup: tup[0])
function_word_list, arg_list, phrase_list = self.valid_data_to_lists(
train_data, (None, arg_space.row2id, phrase_space.row2id))
#partitions the sorted input data
keys, key_ranges = get_partitions(function_word_list,
self._MIN_SAMPLES)
if not keys:
raise ValueError("No valid training data found!")
assert (len(arg_space.element_shape) == 1)
if self._has_intercept:
new_element_shape = phrase_space.element_shape + (
arg_space.element_shape[0] + 1, )
else:
new_element_shape = phrase_space.element_shape + (
arg_space.element_shape[0], )
for i in range(len(key_ranges)):
idx_beg, idx_end = key_ranges[i]
print(("Training lexical function...%s with %d samples" %
(keys[i], idx_end - idx_beg)))
arg_mat = arg_space.get_rows(arg_list[idx_beg:idx_end])
phrase_mat = phrase_space.get_rows(phrase_list[idx_beg:idx_end])
#convert them to the same type
matrix_type = get_type_of_largest([arg_mat, phrase_mat])
[arg_mat,
phrase_mat] = resolve_type_conflict([arg_mat, phrase_mat],
matrix_type)
result_mat = self._regression_learner.train(
arg_mat, phrase_mat).transpose()
result_mat.reshape((1, np.prod(new_element_shape)))
result_mats.append(result_mat)
new_space_mat = arg_mat.nary_vstack(result_mats)
self.composed_id2column = phrase_space.id2column
self._function_space = Space(new_space_mat,
keys, [],
element_shape=new_element_shape)
log.print_composition_model_info(logger, self, 1,
"\nTrained composition model:")
log.print_info(logger, 3, "Trained: %s lexical functions" % len(keys))
log.print_info(logger, 3,
"With total data points:%s" % len(function_word_list))
log.print_matrix_info(logger, arg_space.cooccurrence_matrix, 3,
"Semantic space of arguments:")
log.print_info(
logger, 3,
"Shape of lexical functions learned:%s" % (new_element_shape, ))
log.print_matrix_info(logger, new_space_mat, 3,
"Semantic space of lexical functions:")
log.print_time_info(logger, time.time(), start, 2)
