def test_basic_phonoprob(unspecified_test_corpus):
    expected = {
        'atema': 0.1011173499,
        'enuta': 0.1011173499,
        'ta': 0.4353651056,
        'mata': 0.1881114313,
        'nata': 0.1782478499
    }
    with CanonicalVariantContext(unspecified_test_corpus, 'transcription',
                                 'token') as c:
        for k, v in expected.items():
            res = phonotactic_probability_vitevitch(
                c, unspecified_test_corpus.find(k), 'unigram')
        assert (abs(v - res) < 0.0001)

    expected = {
        'atema': 0.0798992942,
        'enuta': 0.0798992942,
        'ta': 0.1507780332,
        'mata': 0.0626335622,
        'nata': 0.0494821204
    }
    with CanonicalVariantContext(unspecified_test_corpus, 'transcription',
                                 'token') as c:
        for k, v in expected.items():
            res = phonotactic_probability_vitevitch(
                c, unspecified_test_corpus.find(k), 'bigram')
        assert (abs(v - res) < 0.0001)
Пример #2
0
    def run(self):
        if self.name == 'functional_load':
            try:
                results = minpair_fl(self.kwargs['corpus'],
                                     self.kwargs['segment_pair'],
                                     stop_check=self.kwargs['stop_check'],
                                     call_back=self.kwargs['call_back'])
                self.dataReady.emit(results)
            except Exception as e:
                message = '{}:{}'.format(self.name, e)
                self.errorEncountered.emit(message)
                return

        elif self.name == 'string_similarity':
            try:
                results = string_similarity(
                    self.kwargs['corpus'],
                    self.kwargs['query'],
                    self.kwargs['algorithm'],
                    stop_check=self.kwargs['stop_check'],
                    call_back=self.kwargs['call_back'])
                self.dataReady.emit(results)
            except Exception as e:
                message = '{}:{}'.format(self.name, e)
                self.errorEncountered.emit(message)
                return

        elif self.name == 'phonotactic_probability':
            try:
                results = phonotactic_probability_vitevitch(
                    self.kwargs['corpus'],
                    self.kwargs['query'],
                    self.kwargs['sequence_type'],
                    probability_type=self.kwargs['probability_type'],
                    stop_check=self.kwargs['stop_check'],
                    call_back=self.kwargs['call_back'])
                self.dataReady.emit(results)
            except Exception as e:
                message = '{}:{}'.format(self.name, e)
                self.errorEncountered.emit(message)
                return

        elif self.name == 'kullback_leibler':
            try:
                results = KullbackLeibler(self.kwargs['corpus'],
                                          self.kwargs['seg1'],
                                          self.kwargs['seg2'],
                                          self.kwargs['side'],
                                          stop_check=self.kwargs['stop_check'],
                                          call_back=self.kwargs['call_back'])
                self.dataReady.emit(results)
            except Exception as e:
                message = '{}:{}'.format(self.name, e)
                self.errorEncountered.emit(message)
                return

        else:
            raise UnLuckyException(
                'No analysis function called {} could be found'.format(
                    self.name))
def test_basic_phonoprob(unspecified_test_corpus):
    expected = {'atema':0.1011173499,
                'enuta':0.1011173499,
                'ta':0.4353651056,
                'mata':0.1881114313,
                'nata':0.1782478499}
    with CanonicalVariantContext(unspecified_test_corpus, 'transcription', 'token') as c:
        for k,v in expected.items():
            res = phonotactic_probability_vitevitch(c, unspecified_test_corpus.find(k), 'unigram')
        assert(abs(v - res) < 0.0001)

    expected = {'atema':0.0798992942,
                'enuta':0.0798992942,
                'ta':0.1507780332,
                'mata':0.0626335622,
                'nata':0.0494821204}
    with CanonicalVariantContext(unspecified_test_corpus, 'transcription', 'token') as c:
        for k,v in expected.items():
            res = phonotactic_probability_vitevitch(c, unspecified_test_corpus.find(k), 'bigram')
        assert(abs(v - res) < 0.0001)
Пример #4
0
    def run(self):
        if self.name == 'functional_load':
            try:
                results = minpair_fl(self.kwargs['corpus'], self.kwargs['segment_pair'],
                                     stop_check = self.kwargs['stop_check'],
                                     call_back = self.kwargs['call_back'])
                self.dataReady.emit(results)
            except Exception as e:
                message = '{}:{}'.format(self.name,e)
                self.errorEncountered.emit(message)
                return

        elif self.name == 'string_similarity':
            try:
                results = string_similarity(self.kwargs['corpus'], self.kwargs['query'], self.kwargs['algorithm'],
                                                        stop_check = self.kwargs['stop_check'],
                                                            call_back = self.kwargs['call_back'])
                self.dataReady.emit(results)
            except Exception as e:
                message = '{}:{}'.format(self.name,e)
                self.errorEncountered.emit(message)
                return

        elif self.name == 'phonotactic_probability':
            try:
                results = phonotactic_probability_vitevitch(self.kwargs['corpus'],self.kwargs['query'],
                                                            self.kwargs['sequence_type'],
                                                            probability_type=self.kwargs['probability_type'],
                                                            stop_check = self.kwargs['stop_check'],
                                                            call_back = self.kwargs['call_back'])
                self.dataReady.emit(results)
            except Exception as e:
                message = '{}:{}'.format(self.name,e)
                self.errorEncountered.emit(message)
                return

        elif self.name == 'kullback_leibler':
            try:
                results = KullbackLeibler(self.kwargs['corpus'], self.kwargs['seg1'], self.kwargs['seg2'], self.kwargs['side'],
                                          stop_check = self.kwargs['stop_check'],
                                            call_back = self.kwargs['call_back'])
                self.dataReady.emit(results)
            except Exception as e:
                message = '{}:{}'.format(self.name,e)
                self.errorEncountered.emit(message)
                return

        else:
            raise UnLuckyException('No analysis function called {} could be found'.format(self.name))