alex.ml package

Subpackages

• alex.ml.bn package
  • Submodules
  • alex.ml.bn.autopath module
  • alex.ml.bn.factor module
  • alex.ml.bn.lbp module
  • alex.ml.bn.node module
  • alex.ml.bn.test_factor module
  • alex.ml.bn.test_lbp module
  • alex.ml.bn.test_node module
  • alex.ml.bn.utils module
  • Module contents
• alex.ml.ep package
  • Submodules
  • alex.ml.ep.node module
  • alex.ml.ep.test module
  • alex.ml.ep.turn module
  • Module contents
• alex.ml.gmm package
  • Submodules
  • alex.ml.gmm.gmm module
  • Module contents
• alex.ml.lbp package
  • Submodules
  • alex.ml.lbp.node module
  • Module contents

Submodules

alex.ml.exceptions module

exception alex.ml.exceptions.FFNNException

Bases: alex.AlexException

exception alex.ml.exceptions.NBListException

Bases: alex.AlexException

alex.ml.features module

This module contains generic code for working with feature vectors (or, in general, collections of features).

class alex.ml.features.Abstracted

Bases: object

all_instantiations(do_abstract=False)

get_concrete()

get_generic()

instantiate(type_, value, do_abstract=False)

Example: Let self represent

da1(a1=T1:v1)&da2(a2=T2:v2)&da3(a3=T1:v3).

Calling self.instantiate(“T1”, “v1”) results in

da1(a1=T1)&da2(a2=v2)&da3(a3=v3) ..if do_abstract == False

da1(a1=T1)&da2(a2=v2)&da3(a3=T1_other) ..if do_abstract == True

Calling self.instantiate(“T1”, “x1”) results in

da1(a1=x1)&da2(a2=v2)&da3(a3=v3) ..if do_abstract == False

da1(a1=T1_other)&da2(a2=v2)&da3(a3=T1_other)

..if do_abstract == True.

insts_for_type(type_)

insts_for_typeval(type_, value)

iter_instantiations()

iter_triples()

iter_typeval()

Iterates the abstracted items in self, yielding combined representations of the type and value of each such token. An abstract method of this class.

join_typeval(type_, val)

classmethod make_other(type_)

other_val = '[OTHER]'

replace_typeval(combined, replacement)

splitter = '='

to_other()

class alex.ml.features.AbstractedTuple2

Bases: alex.ml.features.AbstractedFeature

class alex.ml.features.Features(*args, **kwargs)

Bases: object

A mostly abstract class representing features of an object.

Attributes:

features: mapping of the features to their values set: set of the features

classmethod do_with_abstract(feature, meth, *args, **kwargs)

get_feature_coords_vals(feature_idxs)

Builds the feature vector based on the provided mapping of features onto their indices. Returns the vector as a two lists, one of feature coordinates, one of feature values.

Arguments:

feature_idxs: a mapping { feature : feature index }

get_feature_vector(feature_idxs)

Builds the feature vector based on the provided mapping of features onto their indices.

Arguments:

feature_idxs: a mapping { feature : feature index }

classmethod iter_abstract(feature)

iter_instantiations()

iteritems()

Iterates tuples of this object’s features and their values.

classmethod join(feature_sets, distinguish=True)

Joins a number of sets of features, keeping them distinct.

Arguments:

distinguish – whether to treat the feature sets as of different

types (distinguish=True) or just merge features from them by adding their values (distinguish=False). Default is True.

Returns a new instance of JoinedFeatures.

prune(to_remove=None, min_val=None)

Discards specified features.

Arguments:

to_remove – collection of features to be removed min_val – threshold for feature values in order for them to be

retained (those not meeting the threshold are pruned)

class alex.ml.features.JoinedFeatures(feature_sets)

Bases: alex.ml.features.Features

JoinedFeatures are indexed by tuples (feature_sets_index, feature) where feature_sets_index selects the required set of features. Sets of features are numbered with the same indices as they had in the list used to initialise JoinedFeatures.

Attributes:

features: mapping { (feature_set_index, feature) : value of feature } set: set of the (feature_set_index, feature) tuples generic: mapping { (feature_set_index, abstracted_feature) :

generic_feature }

instantiable: mapping { feature : generic part of feature } for

features from self.features.keys() that are abstracted

iter_instantiations()

class alex.ml.features.ReplaceableTuple2

Bases: tuple

iter_combined()

replace(old, new)

to_other()

alex.ml.features.make_abstract(replaceable, iter_meth=None, replace_meth=None, splitter='=', make_other=None)

alex.ml.features.make_abstracted_tuple(abstr_idxs)

Example usage:

AbTuple2 = make_abstract_tuple((2,)) ab_feat = AbTuple2((dai.dat, dai.name,

‘=’.join(dai.name.upper(), dai.value)))

# ... ab_feat.instantiate(‘food’, ‘chinese’) ab_feat.instantiate(‘food’, ‘indian’)

alex.ml.ffnn module

class alex.ml.ffnn.FFNN

Bases: object

Implements simple feed-forward neural network with:

– input layer - activation function linear – hidden layers - activation function tanh – output layer - activation function softmax

add_layer(w, b)

Add next layer into the network.

Parameters:

• w – next layer weights
• b – next layer biases

Returns:

none

load(file_name)

Loads saved NN.

Parameters:file_name – file name of the saved NN Returns:None

predict(input)

Returns the output of the last layer.

As it is output of a layer with softmax activation function, the output is a vector of probabilities of

the classes being predicted.

Parameters:input – input vector for the first NN layer. Returns:return the output of the last activation layer

save(file_name)

Saves the NN into a file.

Parameters:file_name – name of the file where the NN will be saved Returns:None

set_input_norm(m, std)

sigmoid(y)

softmax(y)

tanh(y)

alex.ml.hypothesis module

This module collects classes representing the uncertainty about the actual value of a base type instance.

class alex.ml.hypothesis.ConfusionNetwork

Bases: alex.ml.hypothesis.Hypothesis

Confusion network. In this representation, each fact breaks down into a sequence of elementary acts.

add(probability, fact)

Append a fact to the confusion network.

add_merge(p, fact, combine=u'max')

Add a fact and if it exists merge it according to the given combine strategy.

extend(conf_net)

classmethod from_fact(fact)

Constructs a deterministic confusion network that asserts the given `fact’. Note that `fact’ has to be an iterable of elementary acts.

get_prob(fact)

Get the probability of the fact.

merge(conf_net, combine=u'max')

Merges facts in the current and the given confusion networks.

Arguments:

combine – can be one of {‘new’, ‘max’, ‘add’, ‘arit’, ‘harm’}, and

determines how two probabilities should be merged (default: ‘max’)

XXX As of now, we know that different values for the same slot are contradictory (and in general, the set of contradicting attr-value pairs could be larger). We should therefore consider them alternatives to each other.

normalise()

Makes sure that all probabilities add up to one. They should implicitly sum to one: p + (1-p) == 1.0

prune(prune_prob=0.005)

Prune all low probability dialogue act items.

remove(fact_to_remove)

sort(reverse=True)

update_prob(probability, fact)

Update the probability of a fact.

exception alex.ml.hypothesis.ConfusionNetworkException

Bases: exceptions.Exception

class alex.ml.hypothesis.Hypothesis

Bases: object

This is the base class for all forms of probabilistic hypotheses representations.

classmethod from_fact(fact)

Constructs a deterministic hypothesis that asserts the given `fact’.

class alex.ml.hypothesis.NBList

Bases: alex.ml.hypothesis.Hypothesis

This class represents the uncertainty using an n-best list.

When updating an N-best list, one should do the following.

1. add utterances or parse a confusion network
2. merge and normalise, in either order

add(probability, fact)

Finds the last hypothesis with a lower probability and inserts the new item before that one. Optimised for adding objects from the highest probability ones to the lowest probability ones.

add_other(other)

The N-best list is extended to include the other object to represent those object values that are not enumerated in the list.

Returns self.

classmethod from_fact(fact)

get_best()

Returns the most probable value of the object.

merge()

Adds up probabilities for the same hypotheses. Returns self.

normalise()

Scales the list to sum to one.

alex.ml.logarithmetic module

alex.ml.logarithmetic.add(a, b)

Computes pairwise addition of two vectors in the log domain.

This is equivalent to [a1+b1, a2+b2, ...] in the linear domain..

alex.ml.logarithmetic.devide(a, b)

Computes pairwise division between vectors a and b in the log domain.

This is equivalent to [a1/b1, a2/b2, ...] in the linear domain.

alex.ml.logarithmetic.dot(a, b)

Computes dot product in the log domain.

This is equivalent to a1*b1+a2*b2+... in the linear domain.

alex.ml.logarithmetic.linear_to_log(a)

Converts a vector from the linear domain to the log domain.

alex.ml.logarithmetic.log_to_linear(a)

Converts a vector from the log domain to the linear domain.

alex.ml.logarithmetic.multiply(a, b)

Computes pairwise multiplication between vectors a and b in the log domain.

This is equivalent to [a1*b1, a2*b2, ...] in the linear domain.

alex.ml.logarithmetic.normalise(a)

normalises the input probability vector to sum to one in the log domain.

This is equivalent to a/sum(a) in the linear domain.

alex.ml.logarithmetic.sub(a, b)

Computes pairwise subtraction of two vectors in the log domain.

This is equivalent to [a1-b1, a2-b2, ...] in the linear domain.

alex.ml.logarithmetic.sum(a, axis=None)

alex.ml.test_hypothesis module

class alex.ml.test_hypothesis.TestConfusionNetwork(methodName='runTest')

Bases: unittest.case.TestCase

test_iter()

test_remove()

alex.ml.tffnn module

Module contents