Пример #1
0
 def __load__(self):
     if super(TextGridTierResource, self).__load__() < 0:
         return -1
     if self.__tiernames__ is None:
         print "No tiername has been set."
         print "No TierFrame can be created."
         return -1
     if self.__cached_object__ is None:
         self.__cached_object__ = open_intervalframe_from_textgrid(self.get_filepath())[self.__tiernames__]
     return 0
Пример #2
0
    def setUp(self):
        self.dict1 = open_intervalframe_from_textgrid('data/r1-20120704-cam1-'
                                                      'head-sk'
                                                      '.TextGrid', 'utf-8')
        self.dict2 = open_intervalframe_from_textgrid('data/r1-20120704-cam1-'
                                                      'head-zm.TextGrid',
                                                      'utf-8')
        self.dict3 = open_intervalframe_from_textgrid('data/mytextgrid'
                                                      '.TextGrid', 'utf-8')
        self.dict4 = dict()
        self.dict4['speaker A'] = self.dict3['speaker A'][0:4].copy(deep=True)
        self.dict4['speaker B'] = self.dict3['speaker B'][0:4].copy(deep=True)
        shift_tiers(self.dict4, 1)
        self.tier1 = self.dict1['HeadSK']
        self.tier2 = self.dict2['HeadZM']
        self.stream = open_streamframe_from_xiofile('data/fseeksmaller.xio.gz',
                                                    "lab-labtop/irioKinect 2",
                                                     window_size=5,
                                                    with_fields=None,
                                                    without_fields=None,
                                                    discard_duplicates=True,
                                                    start_time=0,
                                                    end_time=500,
                                                    timestamp_offset=None)
        self.ifr = create_intervalframe_from_streamframe(self.stream,
                                                         'soundAngle',
                                                         lambda x: True \
                                                            if x <- 0.7323895 \
                                                            else False,
                                                         10)

        self.iframe = open_intervalframe_from_textgrid('data/mytextgrid.Text'
                                                       'Grid', 'utf-8')
        self.speaker_a = self.iframe['speaker A']
        self.speaker_b = self.iframe['speaker B']
        self.overlap_ab_shouldbe = [{'end_time': 3.47134775993, 'start_time':
                                     3.4540353413, 'text': u'exactly and at '
                                     'the very end of the corridor is just '
                                     'the bathroom/I see yes'},
                                    {'end_time': 3.8781895978200001, 'start_'
                                     'time': 3.7223778301200001,
                                     'text': u'exactly and at the very end of '
                                     'the corridor is just the bathroom/yes'},
                                    {'end_time': 7.3163672878900003,
                                     'start_time': 6.9095254500000003,
                                     'text': u'that you quasi such have so '
                                     'zack zack zack/yes'},
                                    {'end_time': 7.5933659860300002,
                                     'start_time': 7.4029293810599999,
                                     'text': u'that you quasi such have so '
                                              'zack zack zack/yes'},
                                    {'end_time': 11.168380433799999,
                                     'start_time': 10.8740693171,
                                     'text': u'know you ?/yes I think I'},
                                    {'end_time': 11.644471946299999,
                                     'start_time': 11.2895673643,
                                     'text': u'if this the corridor is here a '
                                              'room there a room there a room '
                                              'there and above/yes I think I'},
                                    {'end_time': 14.892213031400001,
                                     'start_time': 13.1073713208,
                                     'text': u'if this the corridor is here a '
                                     'room there a room there a room there '
                                     'and above/there a room there there and '
                                     'then there yes'},
                                    {'end_time': 15.558741148799999,
                                     'start_time': 15.376960753100001,
                                     'text': u'that is perfect/yes'},
                                    {'end_time': 17.679512431399999,
                                     'start_time': 17.4544509891,
                                     'text': u'yes/sure'},
                                    {'end_time': 27.8435647606,
                                     'start_time': 27.5492536438,
                                     'text': u'twentyfive/so I would already '
                                     'gladly a large room have'}]

        self.right_overlap_ab = pd.DataFrame(self.overlap_ab_shouldbe,
                                             columns=['start_time', 'end_time',
                                                      'text'])

        self.union_dict = [{'end_time': 2.5191647350899999, 'start_time': 0.0,
                            'text': 'union'},
                           {'end_time': 6.1304666115000002, 'start_time': \
                            2.80481964254,
                            'text': 'union'},
                           {'end_time': 9.5669817102499994,
                            'start_time': 6.7796823102500001,
                            'text': 'union'},
                           {'end_time': 15.0393685898, 'start_time': \
                            10.7528823866, 'text': 'union'},
                           {'end_time': 16.1646758009,
                            'start_time': 15.281742450599999,
                            'text': 'union'},
                           {'end_time': 17.3159516401,
                            'start_time': 17.064921569900001,
                            'text': 'union'},
                           {'end_time': 17.714137268599998,
                            'start_time': 17.4457947798,
                            'text': 'union'},
                           {'end_time': 19.393441876099999,
                            'start_time': 17.826667989699999,
                            'text': 'union'}]

        self.union_mustbe = pd.DataFrame(self.union_dict, columns=['start_'
                                         'time', 'end_time', 'text'])

        self.invert = [{'start_time': 0., 'end_time': 547.016,
           'text': 'nod'},
          {'start_time': 547.464, 'end_time': 549.507,
           'text': 'nod/turn-aw'},
          {'start_time': 549.988, 'end_time': 556.808,
           'text': 'turn-aw/nod-2'},
          {'start_time': 557.404, 'end_time': 561.428,
           'text': 'nod-2/nod-3'},
          {'start_time': 563.345, 'end_time': 600.000,
           'text': 'nod-3'}]

        self.inversion = pd.DataFrame(self.invert, columns=['start_'
                                      'time', 'end_time', 'text'])


        self.tier1_inverted = [{'end_time': 547.01599999999996,
                                'start_time': 0.0, 'text': u'nod'},
                               {'end_time': 549.50699999999995,
                                'start_time': 547.46400000000006,
                                'text': u'nod/turn-aw'},
                               {'end_time': 556.80799999999999,
                                'start_time': 549.98800000000006,
                                'text': u'turn-aw/nod-2'},
                               {'end_time': 561.428, 'start_time': 557.404,
                                'text': u'nod-2/nod-3'},
                               {'end_time': 567.51099999999997,
                                'start_time': 563.34500000000003,
                                'text': u'nod-3/slide-right'},
                               {'end_time': 578.17100000000005,
                                'start_time': 568.02300000000002,
                                'text': u'slide-right/nod-4'},
                               {'end_time': 586.03599999999994,
                                'start_time': 579.53499999999997,
                                'text': u'nod-4/nod-3'},
                               {'end_time': 604.73699999999997,
                                'start_time': 587.10699999999997,
                                'text': u'nod-3/nod-4-turn-aw-tw'},
                               {'end_time': 609.11800000000005,
                                'start_time': 607.35699999999997,
                                'text': u'nod-4-turn-aw-tw/nod-4'},
                               {'end_time': 617.30899999999997,
                                'start_time': 611.16600000000005,
                                'text': u'nod-4/nod-5'}]

        self.invert_tier1 = pd.DataFrame(self.tier1_inverted,
                                  columns=['start_time', 'end_time', 'text'])

        self.empty = pd.DataFrame([])

        self.withna = [{'start_time': 3, 'end_time': 6, 'text': 'hi'},
                       {'start_time': 7, 'end_time': 8.5},
                       {'start_time': 9, 'end_time': 13, 'text': 'bye'}]

        self.emptyint = pd.DataFrame(self.withna, columns=['start_time',
                                                           'end_time', 'text'])

        self.emptyshouldbe = [{'end_time': 3.0, 'start_time': 0, 'text': 'hi'},
                              {'end_time': 7.0, 'start_time': 6,
                               'text': 'hi/empty'},
                              {'end_time': 9.0, 'start_time': 8.5,
                               'text': 'empty/bye'}]

        self.emptyshouldbepd = pd.DataFrame(self.emptyshouldbe, columns= \
                                            ['start_time', 'end_time', 'text'])

        self.no_overlap1 = [{'start_time': 3, 'end_time': 5, 'text': 'eins'},
                            {'start_time': 9, 'end_time': 15, 'text': 'zwei'},
                            {'start_time': 19, 'end_time': 21, 'text': 'drei'}]

        self.no_overlap2 = [{'start_time': 0, 'end_time': 2.5, 'text': 'vier'},
                            {'start_time': 6, 'end_time': 7, 'text': 'fuenf'},
                            {'start_time': 23, 'end_time': 27, 'text': 'sechs'}]

        self.pd_no_overlap1 = pd.DataFrame(self.no_overlap1,
                                     columns=['start_time', 'end_time', 'text'])

        self.pd_no_overlap2 = pd.DataFrame(self.no_overlap2,
                                     columns=['start_time', 'end_time', 'text'])

        self.convert = [{'start_time': 4, 'end_time': 5, 'text': 'eins'},
                        {'start_time': 9, 'end_time': 15, 'text': 'zwei'},
                        {'start_time': 19, 'end_time': 21, 'text': 'drei'}]

        self.convert_pd = pd.DataFrame(self.convert,
                                     columns=['start_time', 'end_time', 'text'])


        convert_times_of_tier(self.convert_pd, lambda y: int(1000 * y))

        self.converted = [{'start_time': 4000, 'end_time': 5000,
                           'text': 'eins'}, {'start_time': 9000,
                           'end_time': 15000, 'text': 'zwei'},
                          {'start_time': 19000, 'end_time': 21000,
                           'text': 'drei'}]

        self.converted_pd = pd.DataFrame(self.converted,
                                     columns=['start_time', 'end_time', 'text'])

        self.tiers_shifted_a = [{'end_time': 4.47134775993,
                                 'start_time': 3.80481964254,
                                 'text': u'I see yes'},
                                {'end_time':4.8781895978200001,
                                 'start_time': 4.7223778301200001,
                                 'text': u'yes'},
                                {'end_time': 8.3163672878900003,
                                 'start_time': 7.9095254500000003,
                                 'text': u'yes'},
                                {'end_time': 8.5933659860300002,
                                 'start_time': 8.4029293810599999,
                                 'text': u'yes'}]

        self.tiers_shifted_pd = pd.DataFrame(self.tiers_shifted_a,
                                     columns=['start_time', 'end_time', 'text'])

        self.shift_dict = [{'start_time': 3, 'end_time': 5, 'text': 'eins'},
                           {'start_time': 9, 'end_time': 15, 'text': 'zwei'},
                           {'start_time': 19, 'end_time': 21, 'text': 'drei'}]

        self.shift = pd.DataFrame(self.shift_dict,
                                  columns=['start_time', 'end_time', 'text'])

        shift_tier(self.shift, 1)

        self.shifted_dict = [{'start_time': 4, 'end_time': 6, 'text': 'eins'},
                           {'start_time': 10, 'end_time': 16, 'text': 'zwei'},
                           {'start_time': 20, 'end_time': 22, 'text': 'drei'}]


        self.shifted = pd.DataFrame(self.shifted_dict,
                                     columns=['start_time', 'end_time', 'text'])

        for col in self.dict4['speaker A'].columns:
            self.dict4['speaker A'].loc[:, col] = \
            self.dict4['speaker A'][col].map(lambda x: str(x))
        for col in self.tiers_shifted_pd.columns:
            self.tiers_shifted_pd.loc[:, col] = \
            self.tiers_shifted_pd[col].map(lambda x: str(x))

        self.withPoint = open_intervalframe_from_textgrid('data/r1_12_15with'
                                                          'Point.TextGrid',
                                                          'utf-8')

        self.points = self.withPoint['P'][0:4].copy(deep=True)
        shift_tier(self.points, 10)

        for col in self.points.columns:
            self.points.loc[:, col] = self.points[col].map(lambda x: str(x))

        self.points_shifted = [{'mark': 'A', 'time': 12.804819642542952},
                               {'mark': 'B', 'time': 13.454035341299345},
                               {'mark': 'A', 'time': 13.722377830118717},
                               {'mark': 'B', 'time': 16.779682310252952}]

        self.points_shifted_pd = pd.DataFrame(self.points_shifted,
                                     columns=['time', 'mark'])


        for col in self.points_shifted_pd.columns:
            self.points_shifted_pd.loc[:, col] = \
            self.points_shifted_pd[col].map(lambda x: str(x))

        self.labeljoin = open_intervalframe_from_textgrid('data/joinlabels'
                                                          '.TextGrid', 'utf-8')

        self.streamdict1 = [{'value': u'nod_start'},
                        {'value': u'nod_end'},
                        {'value': u'turn-aw_start'},
                        {'value': u'turn-aw_end'},
                        {'value': u'nod-2_start'},
                        {'value': u'nod-2_end'},
                        {'value': u'nod-3_start'},
                        {'value': u'nod-3'},
                        {'value': u'nod-3_end'}]

        self.stream1 = pd.DataFrame(self.streamdict1, columns=['value'])
        self.stream1.index = [547.016, 547.464, 549.507, 549.988, 556.808,
                              557.404, 561.428, 562.428, 563.345]

        self.inv1 = [{'end_time': '547.016', 'start_time': '300.0',
                      'text': u'nod'},
                     {'end_time': '549.507', 'start_time': '547.464',
                      'text': u'nod/turn-aw'},
                     {'end_time': '556.808', 'start_time': '549.988',
                      'text': u'turn-aw/nod-2'},
                     {'end_time': '561.428', 'start_time': '557.404',
                      'text': u'nod-2/nod-3'},
                     {'end_time': '700.0', 'start_time': '563.345',
                      'text': u'nod-3'}]

        self.inverted1 = pd.DataFrame(self.inv1,
                                    columns=['start_time', 'end_time', 'text'])

        self.inv1_str = invert_intervalframe(self.tier1[0:4], 300, 700)
        for col in self.inv1_str:
            self.inv1_str.loc[:, col] = \
            self.inv1_str[col].map(lambda x: str(x))


        self.inv_default_conc = [{'end_time': '549.507',
                                  'start_time': '547.464', 'text': u'nod'},
                            {'end_time': '556.808',
                             'start_time': '549.988', 'text': u'turn-aw+nod-2'},
                            {'end_time': '561.428',
                             'start_time': '557.404', 'text': u'nod-2'}]

        self.inv_def_pd = pd.DataFrame(self.inv_default_conc,
                                     columns=['start_time', 'end_time', 'text'])
        self.inv_def_str = invert_intervalframe(self.tier1[0:4],
                                                     concat_delimiter='+')
        for col in self.inv_def_str:
            self.inv_def_str.loc[:, col] = \
            self.inv_def_str[col].map(lambda x: str(x))
Пример #3
0
    def setUp(self):
        self.dict1 = open_intervalframe_from_textgrid(
            'data/r1-20120704-cam1-'
            'head-sk'
            '.TextGrid', 'utf-8')
        self.dict2 = open_intervalframe_from_textgrid(
            'data/r1-20120704-cam1-'
            'head-zm.TextGrid', 'utf-8')
        self.dict3 = open_intervalframe_from_textgrid(
            'data/mytextgrid'
            '.TextGrid', 'utf-8')
        self.dict4 = dict()
        self.dict4['speaker A'] = self.dict3['speaker A'][0:4].copy(deep=True)
        self.dict4['speaker B'] = self.dict3['speaker B'][0:4].copy(deep=True)
        shift_tiers(self.dict4, 1)
        self.tier1 = self.dict1['HeadSK']
        self.tier2 = self.dict2['HeadZM']
        self.stream = open_streamframe_from_xiofile('data/fseeksmaller.xio.gz',
                                                    "lab-labtop/irioKinect 2",
                                                    window_size=5,
                                                    with_fields=None,
                                                    without_fields=None,
                                                    discard_duplicates=True,
                                                    start_time=0,
                                                    end_time=500,
                                                    timestamp_offset=None)
        self.ifr = create_intervalframe_from_streamframe(self.stream,
                                                         'soundAngle',
                                                         lambda x: True \
                                                            if x <- 0.7323895 \
                                                            else False,
                                                         10)

        self.iframe = open_intervalframe_from_textgrid(
            'data/mytextgrid.Text'
            'Grid', 'utf-8')
        self.speaker_a = self.iframe['speaker A']
        self.speaker_b = self.iframe['speaker B']
        self.overlap_ab_shouldbe = [{
            'end_time':
            3.47134775993,
            'start_time':
            3.4540353413,
            'text':
            u'exactly and at '
            'the very end of the corridor is just '
            'the bathroom/I see yes'
        }, {
            'end_time':
            3.8781895978200001,
            'start_'
            'time':
            3.7223778301200001,
            'text':
            u'exactly and at the very end of '
            'the corridor is just the bathroom/yes'
        }, {
            'end_time':
            7.3163672878900003,
            'start_time':
            6.9095254500000003,
            'text':
            u'that you quasi such have so '
            'zack zack zack/yes'
        }, {
            'end_time':
            7.5933659860300002,
            'start_time':
            7.4029293810599999,
            'text':
            u'that you quasi such have so '
            'zack zack zack/yes'
        }, {
            'end_time': 11.168380433799999,
            'start_time': 10.8740693171,
            'text': u'know you ?/yes I think I'
        }, {
            'end_time':
            11.644471946299999,
            'start_time':
            11.2895673643,
            'text':
            u'if this the corridor is here a '
            'room there a room there a room '
            'there and above/yes I think I'
        }, {
            'end_time':
            14.892213031400001,
            'start_time':
            13.1073713208,
            'text':
            u'if this the corridor is here a '
            'room there a room there a room there '
            'and above/there a room there there and '
            'then there yes'
        }, {
            'end_time': 15.558741148799999,
            'start_time': 15.376960753100001,
            'text': u'that is perfect/yes'
        }, {
            'end_time': 17.679512431399999,
            'start_time': 17.4544509891,
            'text': u'yes/sure'
        }, {
            'end_time':
            27.8435647606,
            'start_time':
            27.5492536438,
            'text':
            u'twentyfive/so I would already '
            'gladly a large room have'
        }]

        self.right_overlap_ab = pd.DataFrame(
            self.overlap_ab_shouldbe,
            columns=['start_time', 'end_time', 'text'])

        self.union_dict = [{'end_time': 2.5191647350899999, 'start_time': 0.0,
                            'text': 'union'},
                           {'end_time': 6.1304666115000002, 'start_time': \
                            2.80481964254,
                            'text': 'union'},
                           {'end_time': 9.5669817102499994,
                            'start_time': 6.7796823102500001,
                            'text': 'union'},
                           {'end_time': 15.0393685898, 'start_time': \
                            10.7528823866, 'text': 'union'},
                           {'end_time': 16.1646758009,
                            'start_time': 15.281742450599999,
                            'text': 'union'},
                           {'end_time': 17.3159516401,
                            'start_time': 17.064921569900001,
                            'text': 'union'},
                           {'end_time': 17.714137268599998,
                            'start_time': 17.4457947798,
                            'text': 'union'},
                           {'end_time': 19.393441876099999,
                            'start_time': 17.826667989699999,
                            'text': 'union'}]

        self.union_mustbe = pd.DataFrame(
            self.union_dict, columns=['start_'
                                      'time', 'end_time', 'text'])

        self.invert = [{
            'start_time': 0.,
            'end_time': 547.016,
            'text': 'nod'
        }, {
            'start_time': 547.464,
            'end_time': 549.507,
            'text': 'nod/turn-aw'
        }, {
            'start_time': 549.988,
            'end_time': 556.808,
            'text': 'turn-aw/nod-2'
        }, {
            'start_time': 557.404,
            'end_time': 561.428,
            'text': 'nod-2/nod-3'
        }, {
            'start_time': 563.345,
            'end_time': 600.000,
            'text': 'nod-3'
        }]

        self.inversion = pd.DataFrame(
            self.invert, columns=['start_'
                                  'time', 'end_time', 'text'])

        self.tier1_inverted = [{
            'end_time': 547.01599999999996,
            'start_time': 0.0,
            'text': u'nod'
        }, {
            'end_time': 549.50699999999995,
            'start_time': 547.46400000000006,
            'text': u'nod/turn-aw'
        }, {
            'end_time': 556.80799999999999,
            'start_time': 549.98800000000006,
            'text': u'turn-aw/nod-2'
        }, {
            'end_time': 561.428,
            'start_time': 557.404,
            'text': u'nod-2/nod-3'
        }, {
            'end_time': 567.51099999999997,
            'start_time': 563.34500000000003,
            'text': u'nod-3/slide-right'
        }, {
            'end_time': 578.17100000000005,
            'start_time': 568.02300000000002,
            'text': u'slide-right/nod-4'
        }, {
            'end_time': 586.03599999999994,
            'start_time': 579.53499999999997,
            'text': u'nod-4/nod-3'
        }, {
            'end_time': 604.73699999999997,
            'start_time': 587.10699999999997,
            'text': u'nod-3/nod-4-turn-aw-tw'
        }, {
            'end_time': 609.11800000000005,
            'start_time': 607.35699999999997,
            'text': u'nod-4-turn-aw-tw/nod-4'
        }, {
            'end_time': 617.30899999999997,
            'start_time': 611.16600000000005,
            'text': u'nod-4/nod-5'
        }]

        self.invert_tier1 = pd.DataFrame(
            self.tier1_inverted, columns=['start_time', 'end_time', 'text'])

        self.empty = pd.DataFrame([])

        self.withna = [{
            'start_time': 3,
            'end_time': 6,
            'text': 'hi'
        }, {
            'start_time': 7,
            'end_time': 8.5
        }, {
            'start_time': 9,
            'end_time': 13,
            'text': 'bye'
        }]

        self.emptyint = pd.DataFrame(
            self.withna, columns=['start_time', 'end_time', 'text'])

        self.emptyshouldbe = [{
            'end_time': 3.0,
            'start_time': 0,
            'text': 'hi'
        }, {
            'end_time': 7.0,
            'start_time': 6,
            'text': 'hi/empty'
        }, {
            'end_time': 9.0,
            'start_time': 8.5,
            'text': 'empty/bye'
        }]

        self.emptyshouldbepd = pd.DataFrame(self.emptyshouldbe, columns= \
                                            ['start_time', 'end_time', 'text'])

        self.no_overlap1 = [{
            'start_time': 3,
            'end_time': 5,
            'text': 'eins'
        }, {
            'start_time': 9,
            'end_time': 15,
            'text': 'zwei'
        }, {
            'start_time': 19,
            'end_time': 21,
            'text': 'drei'
        }]

        self.no_overlap2 = [{
            'start_time': 0,
            'end_time': 2.5,
            'text': 'vier'
        }, {
            'start_time': 6,
            'end_time': 7,
            'text': 'fuenf'
        }, {
            'start_time': 23,
            'end_time': 27,
            'text': 'sechs'
        }]

        self.pd_no_overlap1 = pd.DataFrame(
            self.no_overlap1, columns=['start_time', 'end_time', 'text'])

        self.pd_no_overlap2 = pd.DataFrame(
            self.no_overlap2, columns=['start_time', 'end_time', 'text'])

        self.convert = [{
            'start_time': 4,
            'end_time': 5,
            'text': 'eins'
        }, {
            'start_time': 9,
            'end_time': 15,
            'text': 'zwei'
        }, {
            'start_time': 19,
            'end_time': 21,
            'text': 'drei'
        }]

        self.convert_pd = pd.DataFrame(
            self.convert, columns=['start_time', 'end_time', 'text'])

        convert_times_of_tier(self.convert_pd, lambda y: int(1000 * y))

        self.converted = [{
            'start_time': 4000,
            'end_time': 5000,
            'text': 'eins'
        }, {
            'start_time': 9000,
            'end_time': 15000,
            'text': 'zwei'
        }, {
            'start_time': 19000,
            'end_time': 21000,
            'text': 'drei'
        }]

        self.converted_pd = pd.DataFrame(
            self.converted, columns=['start_time', 'end_time', 'text'])

        self.tiers_shifted_a = [{
            'end_time': 4.47134775993,
            'start_time': 3.80481964254,
            'text': u'I see yes'
        }, {
            'end_time': 4.8781895978200001,
            'start_time': 4.7223778301200001,
            'text': u'yes'
        }, {
            'end_time': 8.3163672878900003,
            'start_time': 7.9095254500000003,
            'text': u'yes'
        }, {
            'end_time': 8.5933659860300002,
            'start_time': 8.4029293810599999,
            'text': u'yes'
        }]

        self.tiers_shifted_pd = pd.DataFrame(
            self.tiers_shifted_a, columns=['start_time', 'end_time', 'text'])

        self.shift_dict = [{
            'start_time': 3,
            'end_time': 5,
            'text': 'eins'
        }, {
            'start_time': 9,
            'end_time': 15,
            'text': 'zwei'
        }, {
            'start_time': 19,
            'end_time': 21,
            'text': 'drei'
        }]

        self.shift = pd.DataFrame(self.shift_dict,
                                  columns=['start_time', 'end_time', 'text'])

        shift_tier(self.shift, 1)

        self.shifted_dict = [{
            'start_time': 4,
            'end_time': 6,
            'text': 'eins'
        }, {
            'start_time': 10,
            'end_time': 16,
            'text': 'zwei'
        }, {
            'start_time': 20,
            'end_time': 22,
            'text': 'drei'
        }]

        self.shifted = pd.DataFrame(self.shifted_dict,
                                    columns=['start_time', 'end_time', 'text'])

        for col in self.dict4['speaker A'].columns:
            self.dict4['speaker A'].loc[:, col] = \
            self.dict4['speaker A'][col].map(lambda x: str(x))
        for col in self.tiers_shifted_pd.columns:
            self.tiers_shifted_pd.loc[:, col] = \
            self.tiers_shifted_pd[col].map(lambda x: str(x))

        self.withPoint = open_intervalframe_from_textgrid(
            'data/r1_12_15with'
            'Point.TextGrid', 'utf-8')

        self.points = self.withPoint['P'][0:4].copy(deep=True)
        shift_tier(self.points, 10)

        for col in self.points.columns:
            self.points.loc[:, col] = self.points[col].map(lambda x: str(x))

        self.points_shifted = [{
            'mark': 'A',
            'time': 12.804819642542952
        }, {
            'mark': 'B',
            'time': 13.454035341299345
        }, {
            'mark': 'A',
            'time': 13.722377830118717
        }, {
            'mark': 'B',
            'time': 16.779682310252952
        }]

        self.points_shifted_pd = pd.DataFrame(self.points_shifted,
                                              columns=['time', 'mark'])

        for col in self.points_shifted_pd.columns:
            self.points_shifted_pd.loc[:, col] = \
            self.points_shifted_pd[col].map(lambda x: str(x))

        self.labeljoin = open_intervalframe_from_textgrid(
            'data/joinlabels'
            '.TextGrid', 'utf-8')

        self.streamdict1 = [{
            'value': u'nod_start'
        }, {
            'value': u'nod_end'
        }, {
            'value': u'turn-aw_start'
        }, {
            'value': u'turn-aw_end'
        }, {
            'value': u'nod-2_start'
        }, {
            'value': u'nod-2_end'
        }, {
            'value': u'nod-3_start'
        }, {
            'value': u'nod-3'
        }, {
            'value': u'nod-3_end'
        }]

        self.stream1 = pd.DataFrame(self.streamdict1, columns=['value'])
        self.stream1.index = [
            547.016, 547.464, 549.507, 549.988, 556.808, 557.404, 561.428,
            562.428, 563.345
        ]

        self.inv1 = [{
            'end_time': '547.016',
            'start_time': '300.0',
            'text': u'nod'
        }, {
            'end_time': '549.507',
            'start_time': '547.464',
            'text': u'nod/turn-aw'
        }, {
            'end_time': '556.808',
            'start_time': '549.988',
            'text': u'turn-aw/nod-2'
        }, {
            'end_time': '561.428',
            'start_time': '557.404',
            'text': u'nod-2/nod-3'
        }, {
            'end_time': '700.0',
            'start_time': '563.345',
            'text': u'nod-3'
        }]

        self.inverted1 = pd.DataFrame(
            self.inv1, columns=['start_time', 'end_time', 'text'])

        self.inv1_str = invert_intervalframe(self.tier1[0:4], 300, 700)
        for col in self.inv1_str:
            self.inv1_str.loc[:, col] = \
            self.inv1_str[col].map(lambda x: str(x))

        self.inv_default_conc = [{
            'end_time': '549.507',
            'start_time': '547.464',
            'text': u'nod'
        }, {
            'end_time': '556.808',
            'start_time': '549.988',
            'text': u'turn-aw+nod-2'
        }, {
            'end_time': '561.428',
            'start_time': '557.404',
            'text': u'nod-2'
        }]

        self.inv_def_pd = pd.DataFrame(
            self.inv_default_conc, columns=['start_time', 'end_time', 'text'])
        self.inv_def_str = invert_intervalframe(self.tier1[0:4],
                                                concat_delimiter='+')
        for col in self.inv_def_str:
            self.inv_def_str.loc[:, col] = \
            self.inv_def_str[col].map(lambda x: str(x))
Пример #4
0
    def setUp(self):
        self.f = open_streamframe_from_xiofile(
            "data/fseeksmaller.xio.gz",
            "lab-labtop/irioKinect 2",
            window_size=5,
            with_fields=[],
            without_fields=[],
            discard_duplicates=True,
            start_time=0,
            end_time=13,
            relative=True,
            timestamp_offset=10,
        )

        self.f2 = open_streamframe_from_xiofile(
            "data/fseeksmaller.xio.gz",
            "lab-labtop/irioKinect",
            window_size=5,
            with_fields=[],
            without_fields=[],
            discard_duplicates=True,
            start_time=0,
            end_time=13,
            relative=True,
            timestamp_offset=10,
        )
        # self.outtake_from_stream = self.f.ix[1341393414826]['framenumber']
        self.fraw = open_streamframe_from_xiofile(
            "data/fseeksmaller.xio.gz",
            "lab-labtop/irioKinect 2",
            window_size=5,
            with_fields=[],
            without_fields=[],
            discard_duplicates=True,
            start_time=0,
            end_time=13,
            relative=True,
            timestamp_offset="raw",
        )
        self.ff = open_streamframe_from_xiofile(
            "data/fseeksmaller.xio.gz",
            "lab-labtop/irioKinect 2",
            window_size=5,
            with_fields=[],
            without_fields=[],
            discard_duplicates=True,
            start_time=0,
            end_time=13,
            relative=True,
        )

        save_streamframe_to_xiofile({"lab-labtop/irioKinect 2": self.f}, "data/sf_to_xio.xio.gz")

        save_streamframe_to_xiofile(
            {"lab-labtop/irioKinect 2": self.f, "lab-labtop/irioKinect": self.f2}, "data/sf_to_xio2.xio.gz"
        )

        self.rsn = open_streamframe_from_xiofile("data/fseeksmaller.xio.gz", "wrong/sensor/name")

        self.outtake_from_xio = XIOFile("data/sf_to_xio.xio.gz", indexing=True)

        self.outtake_from_xio_2 = XIOFile("data/sf_to_xio2.xio.gz", indexing=True)

        self.q = [
            ex for ex in quantize(self.outtake_from_xio.xio_quicklinegen(0, 13, True, True), "lab-labtop/irioKinect 2")
        ][0]["soundAngle"]

        self.ivf = open_intervalframe_from_textgrid(
            "data/r1_12_15with" "Point.TextGrid", encoding="utf-8", asobjects=False, include_empty_intervals=False
        )["P"]
        self.cv = convert_pointtier_to_streamframe(self.ivf)
        self.pf = convert_streamframe_to_pointtier(self.f)
        self.outtake_from_pf = convert_streamframe_to_pointtier(self.f)["soundAngle"].ix[0]["time"]

        self.if_from_tg = open_intervalframe_from_textgrid(
            "data/r1-20120704-" "cam1-head-zm.TextGrid",
            encoding="utf-8",
            asobjects=False,
            include_empty_intervals=False,
        )

        self.if_from_tg_tier = self.if_from_tg.values()[0]

        save_intervalframe_to_textgrid(self.if_from_tg, "data/testif.TextGrid", encoding="utf-8")
        self.tg = tgt.read_textgrid("data/testif.TextGrid", encoding="utf-8", include_empty_intervals=False)

        self.ic1 = open_intervalframe_from_increco("data/test.inc_reco")

        self.ic2 = open_intervalframe_from_increco("data/test.inc_reco", lastonly=True)
Пример #5
0
ranges1 = [
    line.strip() for line in open(
        "/media/data/jh/simple_rnn_disf/rnn_disf_detection/data/disfluency_detection/swda_divisions_disfluency_detection/SWDisfHeldoutASR_ranges.text"
    )
]
ranges2 = [
    line.strip() for line in open(
        "/media/data/jh/simple_rnn_disf/rnn_disf_detection/data/disfluency_detection/swda_divisions_disfluency_detection/SWDisfTestASR_ranges.text"
    )
]

for ranges in [ranges1, ranges2]:
    final_file.write("\n\n")
    for r in ranges:
        for s in ["A", "B"]:
            iframe = open_intervalframe_from_textgrid("{0}{1}.TextGrid".format(
                r, s))
            hyp = " ".join(iframe['Hyp']['text'])
            ref = " ".join(iframe['Ref']['text'])
            wer = wer(ref, hyp)
            cost = wer(ref, hyp, macro=True)
            print r, s, wer
            print >> final_file, r, s, wer, cost
final_file.close()

#Based on the results, output the 'good' ASR results
results = open("wer_test.text")

no_ho = 0
no_test = 0
ingood = True
file = open(
Пример #6
0
    def setUp(self):
        self.f = open_streamframe_from_xiofile('data/fseeksmaller.xio.gz',
                                               "lab-labtop/irioKinect 2",
                                               window_size=5, with_fields=[],
                                               without_fields=[],
                                               discard_duplicates=True,
                                               start_time=0, end_time=13,
                                               relative=True,
                                               timestamp_offset=10)

        self.f2 = open_streamframe_from_xiofile('data/fseeksmaller.xio.gz',
                                                "lab-labtop/irioKinect",
                                                window_size=5, with_fields=[],
                                                without_fields=[],
                                                discard_duplicates=True,
                                                start_time=0, end_time=13,
                                                relative=True,
                                                timestamp_offset=10)
        #self.outtake_from_stream = self.f.ix[1341393414826]['framenumber']
        self.fraw = open_streamframe_from_xiofile('data/fseeksmaller.xio.gz',
                                                  "lab-labtop/irioKinect 2",
                                                  window_size=5, with_fields=[],
                                                  without_fields=[],
                                                  discard_duplicates=True,
                                                  start_time=0, end_time=13,
                                                  relative=True,
                                                  timestamp_offset='raw')
        self.ff = open_streamframe_from_xiofile('data/fseeksmaller.xio.gz',
                                                "lab-labtop/irioKinect 2",
                                                window_size=5, with_fields=[],
                                                without_fields=[],
                                                discard_duplicates=True,
                                                start_time=0, end_time=13,
                                                relative=True)

        save_streamframe_to_xiofile({"lab-labtop/irioKinect 2": self.f},
                                    'data/sf_to_xio.xio.gz')

        save_streamframe_to_xiofile({"lab-labtop/irioKinect 2": self.f,
                                     "lab-labtop/irioKinect": self.f2},
                                    'data/sf_to_xio2.xio.gz')

        self.rsn = open_streamframe_from_xiofile('data/fseeksmaller.xio.gz',
                                                "wrong/sensor/name")

        self.outtake_from_xio = XIOFile('data/sf_to_xio.xio.gz',
                                        indexing=True)

        self.outtake_from_xio_2 = XIOFile('data/sf_to_xio2.xio.gz',
                                          indexing=True)

        self.q = [ex for ex in quantize(self.outtake_from_xio.xio_quicklinegen\
                                                  (0, 13, True, True),
                                  "lab-labtop/irioKinect 2")][0]['soundAngle']

        self.ivf = open_intervalframe_from_textgrid('data/r1_12_15with'
                                                    'Point.TextGrid',
                                                    encoding='utf-8',
                                                    asobjects = False,
                                         include_empty_intervals = False)['P']
        self.cv = convert_pointtier_to_streamframe(self.ivf)
        self.pf = convert_streamframe_to_pointtier(self.f)
        self.outtake_from_pf = \
          convert_streamframe_to_pointtier(self.f)['soundAngle'].ix[0]['time']

        self.if_from_tg = open_intervalframe_from_textgrid('data/r1-20120704-'
                          'cam1-head-zm.TextGrid',
                          encoding='utf-8',
                          asobjects = False,
                          include_empty_intervals = False)

        self.if_from_tg_tier =  self.if_from_tg.values()[0]

        save_intervalframe_to_textgrid(self.if_from_tg,
                                       'data/testif.TextGrid',
                                       encoding='utf-8')
        self.tg = tgt.read_textgrid('data/testif.TextGrid',
                                    encoding='utf-8',
                                    include_empty_intervals=False)

        self.ic1 = open_intervalframe_from_increco('data/test.inc_reco')

        self.ic2 = open_intervalframe_from_increco('data/test.inc_reco',
                                                   lastonly=True)