コード例 #1
0
ファイル: tryfold.py プロジェクト: prozacchiwawa/icfp2016
def isUnitSquare(rational_points):
    # xxx rpoints and points must correspond xxx    
    points = [ p.toFloat() for p in rational_points ]
    hull = ConvexHull(points)
    hull_points = [ rational_points[i] for i in hull.vertices ]
    line1 = Segment(Point(hull_points[0][0],hull_points[0][1]), Point(hull_points[1][0], hull_points[1][1]))
    line2 = Segment(Point(hull_points[1][0],hull_points[1][1]), Point(hull_points[2][0], hull_points[2][1]))

    # hull_points are guaranteed to be in counterclockwise order
    angle = None
    if line1.no_slope() and (not line2.no_slope() and line2.slope() == 0):
        angle = pi / 2
    elif line2.no_slope() and (not line1.no_slope() and line1.slope() == 0):
        angle = pi / 2
    else:
        l1f = line1.toFloat()
        l2f = line2.toFloat()
        print "lines %s %s" % (l1f, l2f)
        l1d = FloatPoint(l1f[1][0]-l1f[0][0],l1f[1][1]-l1f[0][1])
        l2d = FloatPoint(l2f[1][0]-l2f[0][0],l2f[1][1]-l2f[0][1])
        angle = atan2(l2d[1], l2d[0]) - atan2(l1d[1], l1d[0])
        
    area = poly_area_indexed(rational_points, hull.vertices)
    num_points = len(hull_points)
    angle_delta = fmod(angle - (pi/2), 2*pi)
    print "IsSquare: area:", area, "Num Points: ", num_points, "Angle Delta from 90 degrees, in radians: ", angle_delta
    return area == 1 and num_points == 4 and abs(angle_delta) < epsilon
コード例 #2
0
ファイル: decoder.py プロジェクト: sikor/goView
def _as_segment(data):
    p1 = data[tags.p1]
    p2 = data[tags.p2]
    result = Segment(p1, p2)
    if tags.color in data:
        result.color = _as_color(data[tags.color])
    return result
コード例 #3
0
ファイル: shell.py プロジェクト: ehsteve/foxsi-optics-sim
    def __init__(self,
                 base=[0, 0, 0],
                 seglen=30.0,
                 ang=0.00643732691573,  # focal length of 2m
                 r=5.151,
                 focal=200.0, conic=False):
        '''
        Constructor

        Parameters:
            base:    the center point of the wide end of the segment
            seglen:  the axial length of each segment
            ang:     angle between the shell axis and the side of the front
                     segment
            r:       radius of the shell where the two segments meet
        '''
        if conic is False:
            # Paraboloid segment
            self.front = Segmentp(base=base, focal=focal, seglen=seglen, ang=ang, r1=r)
            backBase = [base[0], base[1], base[2] + seglen]
            # Hyperboloid segment
            self.back = Segmenth(base=backBase, focal=focal, seglen=seglen, ang=ang, r0=r)
        else:
            self.front = Segment(base=base, seglen=seglen, ang=ang, r1=r)
            backBase = [base[0], base[1], base[2]+seglen]
            self.back = Segment(base=backBase, seglen=seglen, ang=3*ang, r0=r)
コード例 #4
0
def create_non_intersecting_segments(pts1, pts2, segs2, angles, ref):
    """Creates list with the Segments that are visible from ref for the case
    when the line segment in pts1 is in front of the line segment in pts2.

    Args:
        pts1 (list[np.array]): list of 2D points that are the intersection of
            the rays from ref in the directions indicated by angles with the
            Segment closest to ref
        pts2 (list[np.array]): list of 2D points that are the intersection of
            the rays from ref in the directions indicated by angles with the
            Segment farthest to ref
        segs2 (list[Segment]): list of Segment between the points in pts2
        angles (list[float]): list of directions (radians) of the rays from ref
            the angles are obtained from the two extremes of each original
            Segment. The list always has 4 elements (even if repeated)
        ref (np.array): reference point
    """
    segments = []
    segment = Segment(pts1[1], pts1[2], angles[1], angles[2], ref)
    if pts1[0] is not None:
        segment.merge(Segment(pts1[0], pts1[1], angles[0], angles[1], ref))
    if pts1[3] is not None:
        segment.merge(Segment(pts1[2], pts1[3], angles[2], angles[3], ref))
    segments.append(segment)
    if segs2[0] is not None:
        segments = [Segment(pts2[0], pts2[1], angles[0], angles[1], ref)] + segments
    if segs2[2] is not None:
        segments.append(Segment(pts2[2], pts2[3], angles[2], angles[3], ref))
    return segments
コード例 #5
0
ファイル: track.py プロジェクト: jacekdalkowski/bike-timer
 def row_to_object(row):
     track = Track()
     track.id = row.id
     track.name = row.name
     track.segments_old = [Segment.row_to_object(segment_row) for segment_row in row.segments_old]
     track.segments_current = [Segment.row_to_object(segment_row) for segment_row in row.segments_current]
     track.valid_time_start = row.valid_time_start
     track.valid_time_stop = row.valid_time_stop
     return track
コード例 #6
0
ファイル: test_segment.py プロジェクト: kdelwat/LangEvolve
def test_meets_conditions():
    segment = Segment(['syllabic', 'voice'], ['consonantal', 'continuant'])

    assert segment.meets_conditions({})
    assert segment.meets_conditions({'positive': ['syllabic']})
    assert segment.meets_conditions({'positive': ['syllabic', 'voice'],
                                     'negative': ['continuant']})
    assert not segment.meets_conditions({'positive': ['lateral'],
                                         'negative': ['continuant']})
コード例 #7
0
ファイル: main.py プロジェクト: oniboni/A-34
def main():

    # cheap hex counter simulation :)
    test_input = "01 23 45 67 89 ab cd ef"   # "01 b0 c4 81 a6 c5 81 a0 5f 01 b7 5f"

    logic = LogicNet(int('b', 16))
    for char in test_input.replace(' ', ''):
        logic.read_input(int(char, 16))
        segment = Segment(logic.follow_paths())
        # print segment.print_segment()

    segment.print_chars()
コード例 #8
0
ファイル: loadcommander.py プロジェクト: LeanMind/macholibre
    def parse_segment(self, lc):
        name = strip(self.f.read(16))
        vmaddr = get_int(self.f) if self.macho.is_32_bit() else get_ll(self.f)
        vmsize = get_int(self.f) if self.macho.is_32_bit() else get_ll(self.f)
        offset = get_int(self.f) if self.macho.is_32_bit() else get_ll(self.f)
        segsize = get_int(self.f) if self.macho.is_32_bit() else get_ll(self.f)
        maxprot = get_int(self.f)
        initprot = get_int(self.f)
        nsects = get_int(self.f)
        flags = get_int(self.f)

        if self.macho.is_little():
            vmaddr = little(vmaddr, 'I') if self.macho.is_32_bit() \
                else little(vmaddr, 'Q')
            vmsize = little(vmsize, 'I') if self.macho.is_32_bit() \
                else little(vmsize, 'Q')
            offset = little(offset, 'I') if self.macho.is_32_bit() \
                else little(offset, 'Q')
            segsize = little(segsize, 'I') if self.macho.is_32_bit() \
                else little(segsize, 'Q')
            maxprot = little(maxprot, 'I')
            initprot = little(initprot, 'I') 
            nsects = little(nsects, 'I')
            flags = little(flags, 'I')

        maxprot = dictionary.protections[maxprot & 0b111]
        initprot = dictionary.protections[initprot & 0b111]        

        entropy = self.get_segment_entropy(offset, segsize)

        segment = Segment(cmd=lc.cmd, size=lc.size, name=name,
                          vmaddr=vmaddr, vmsize=vmsize, offset=offset,
                          segsize=segsize, maxprot=maxprot, initprot=initprot,
                          nsects=nsects, entropy=entropy)

        if self.macho.is_32_bit():
            sect_size = 68
        else:
            sect_size = 80
        for i in range(segment.nsects):
            if self.f.tell() + sect_size > self.file_size:
                data = {
                    'offset': self.f.tell(),
                    'file_size': self.file_size
                }
                a = Abnormality(title='SECTION OUT OF BOUNDS', data=data)
                break
            sect = self.parse_section()
            segment.add_sect(sect)

        self.parse_segment_flags(segment, flags)
        self.macho.add_lc(segment)
コード例 #9
0
    def parseSegment(self, lc):
        name = strip(self._f.read(16))
        vmaddr = getInt(self._f) if self._macho.is32Bit() else getLL(self._f)
        vmsize = getInt(self._f) if self._macho.is32Bit() else getLL(self._f)
        offset = getInt(self._f) if self._macho.is32Bit() else getLL(self._f)
        segsize = getInt(self._f) if self._macho.is32Bit() else getLL(self._f)
        maxprot = getInt(self._f)
        initprot = getInt(self._f)
        nsects = getInt(self._f)
        flags = getInt(self._f)

        if self._macho.isLittle():
            vmaddr = little(vmaddr, 'I') if self._macho.is32Bit() \
                else little(vmaddr, 'Q')
            vmsize = little(vmsize, 'I') if self._macho.is32Bit() \
                else little(vmsize, 'Q')
            offset = little(offset, 'I') if self._macho.is32Bit() \
                else little(offset, 'Q')
            segsize = little(segsize, 'I') if self._macho.is32Bit() \
                else little(segsize, 'Q')
            maxprot = little(maxprot, 'I')
            initprot = little(initprot, 'I') 
            nsects = little(nsects, 'I')
            flags = little(flags, 'I')

        maxprot = dictionary.protections[maxprot & 0b111]
        initprot = dictionary.protections[initprot & 0b111]        

        segment = Segment(cmd=lc.getCmd(), size=lc.getSize(), name=name,
                          vmaddr=vmaddr, vmsize=vmsize, offset=offset,
                          segsize=segsize, maxprot=maxprot, initprot=initprot,
                          nsects=nsects)

        if self._macho.is32Bit():
            sect_size = 68
        else:
            sect_size = 80
        for i in range(segment.getNSects()):
            if self._f.tell() + sect_size > self._file_size:
                data = {
                    'offset': self._f.tell(),
                    'file_size': self._file_size
                }
                a = Abnormality(title='SECTION OUT OF BOUNDS', data=data)
                break
            sect = self.parseSection()
            segment.addSect(sect)

        self.parseSegmentFlags(segment, flags)
        self._macho.addLC(segment)
コード例 #10
0
ファイル: json.py プロジェクト: Parisson/pyannote-core
def object_hook(d):
    """
    Usage
    -----
    >>> import simplejson as json
    >>> with open('file.json', 'r') as f:
    ...   json.load(f, object_hook=object_hook)
    """

    from segment import Segment
    from timeline import Timeline
    from annotation import Annotation
    from transcription import Transcription

    if PYANNOTE_JSON_SEGMENT in d:
        return Segment.from_json(d)

    if PYANNOTE_JSON_TIMELINE in d:
        return Timeline.from_json(d)

    if PYANNOTE_JSON_ANNOTATION in d:
        return Annotation.from_json(d)

    if PYANNOTE_JSON_TRANSCRIPTION in d:
        return Transcription.from_json(d)

    return d
コード例 #11
0
    def __init__(self, track, comp_location, start, orig_duration, new_duration):
        """Create a time-stetched segment. 

        It acts like a :py:class:`radiotool.composer.Segment` but you
        can specify the target duration. The segment will then
        resample its frames to meet this duration.

        :param track: Track to slice
        :type track: :py:class:`radiotool.composer.Track`
        :param float comp_location: Location in composition to play this segment (in seconds)
        :param float start: Start of segment (in seconds)
        :param float orig_duration: Original duration of segment (in seconds)
        :param float new_duration: Target (stretched) duration of segment (in seconds)
        """
        Segment.__init__(self, track, comp_location, start, new_duration)
        self.orig_duration = int(orig_duration * self.samplerate)
コード例 #12
0
ファイル: parse.py プロジェクト: kdelwat/LangEvolve
def token_to_segment(token, segment_list, diacritic_list):
    '''Converts a string token in IPA to Segment object, given
    a list of dictionaries representing segments and the same representing
    diacritics.'''

    diacritic_strings = [segment['IPA'] for segment in diacritic_list]

    # Isolate the base IPA segment string
    base_string = ''.join(filter(lambda x: x not in diacritic_strings,
                                 token))

    # Isolate an iterable of diacritics present
    diacritics = [diacritic for diacritic in diacritic_list
                  if diacritic['IPA'] in token]

    # Initialise the base Segment
    segment = Segment.from_dictionary(find_segment(base_string,
                                                   segment_list))

    # Add each diacritic feature to the segment
    for diacritic in diacritics:
        diacritic_segment = Segment(diacritic['applies'].get('positive', []),
                                    diacritic['applies'].get('negative', []))
        segment = segment + diacritic_segment

    return segment
コード例 #13
0
ファイル: module.py プロジェクト: humatic/foxsi-optics-sim
 def __init__(self,
              base = [0,0,0],
              seglen = 30.0,
              focal = 200.0,
              radii = [5.151,4.9,4.659,4.429,4.21,4.0,3.799],
              angles = None
              ):
     '''
     Constructor  
     
     Parameters:
         base:    the center point of the wide end of the segment
         seglen:  the axial length of each segment
         focal:   the focal length, measured from the center of the module
         radii:   a list of radii, one for each shell from biggest to smallest
         angles:  optional parameter to overwrite the shell angles computed by constructor
     '''
     if angles is None:
         angles = calcShellAngle(radii,focal) 
     elif len(radii) != len(angles):
         raise ValueError('number of radii and number of angles do not match')
     
     self.shells = []
     for i,r in enumerate(radii):
         self.shells.append(Shell(base=base, seglen=seglen, ang=angles[i], r=r))
     
     # inner core (blocks rays going through center of module)
     r0 = self.shells[-1].back.r0
     r1 = r0 - seglen * tan(4*angles[-1])
     ang = atan((r0-r1)/(2*seglen))
     self.core = Segment(base=base, seglen=2*seglen, ang=ang, r0=r0)
     self.coreFaces = [Circle(center=base,normal=[0,0,1],radius=r0),
                       Circle(center=[base[0],base[1],base[2]+2*seglen],normal=[0,0,-1],radius=r1)]
コード例 #14
0
ファイル: test_segment.py プロジェクト: kdelwat/LangEvolve
def test_initialisation():
    feature_dictionary = {'stress': '+', 'long': '-', 'continuant': '0',
                          'IPA': 'b'}

    segment = Segment.from_dictionary(feature_dictionary)

    assert segment.positive == ['stress']
    assert segment.negative == ['long']
コード例 #15
0
ファイル: annotation.py プロジェクト: kLm8/pyannote-core
 def from_json(cls, data):
     uri = data.get(PYANNOTE_URI, None)
     modality = data.get(PYANNOTE_MODALITY, None)
     annotation = cls(uri=uri, modality=modality)
     for s, track, label in data[PYANNOTE_JSON_ANNOTATION]:
         segment = Segment.from_json(s)
         annotation[segment, track] = label
     return annotation
コード例 #16
0
ファイル: shell.py プロジェクト: humatic/foxsi-optics-sim
 def __init__(self,
              base = [0,0,0],
              seglen = 30.0,
              ang = 0.00643866102405, # focal length of 2m
              r = 5.151
              ):
     '''
     Constructor
     
     Parameters:
         base:    the center point of the wide end of the segment
         seglen:  the axial length of each segment
         ang:     angle between the shell axis and the side of the front segment
         r:       radius of the shell where the two segments meet
     '''
     self.front = Segment(base=base, seglen=seglen, ang=ang, r1=r)
     backBase = [base[0], base[1], base[2]+seglen]
     self.back = Segment(base=backBase, seglen=seglen, ang=3*ang, r0=r)
コード例 #17
0
ファイル: test_segment.py プロジェクト: kdelwat/LangEvolve
def test_addition():
    feature_dictionary = {'stress': '+', 'syllabic': '-', 'continuant': '0',
                          'IPA': 'b'}

    segment = Segment.from_dictionary(feature_dictionary)

    syllabic_diacritic = Segment(['syllabic'], ['voice'])

    addition = segment + syllabic_diacritic
    assert addition.positive == ['stress', 'syllabic']
    assert addition.negative == ['voice']
コード例 #18
0
ファイル: annotation.py プロジェクト: gw17/pyannote-core
    def from_json(cls, data):

        uri = data.get(PYANNOTE_URI, None)
        modality = data.get(PYANNOTE_MODALITY, None)
        annotation = cls(uri=uri, modality=modality)
        for one in data[PYANNOTE_JSON_CONTENT]:
            segment = Segment.from_json(one[PYANNOTE_SEGMENT])
            track = one[PYANNOTE_TRACK]
            label = one[PYANNOTE_LABEL]
            annotation[segment, track] = label

        return annotation
コード例 #19
0
ファイル: run.py プロジェクト: jacekdalkowski/bike-timer
 def row_to_object(row):
     run = Run()
     run.id = row.id
     run.user_id = row.run_info.user_id
     run.user_bt_name = row.run_info.user_bt_name
     run.segment = Segment.row_to_object(row.run_info.segment)
     print 'type of time start cell'
     print str(type(row.run_info.time_start))
     run.time_start = row.run_info.time_start
     run.time_stop = row.run_info.time_stop
     run.time_span_ms = row.run_info.time_span_ms
     return run
コード例 #20
0
def benchmark_match_accuracy(segments, diacritics, filename):
    '''Convert all given segments to feature strings, then convert back to
    segments. Use the given feature string file. Return the percentage accuracy
    of the conversion.

    '''
    feature_strings = load_feature_strings(path.join(base_directory, 'engine',
                                                     'data', filename))

    print('Loaded {0} feature strings'.format(len(feature_strings)))

    base_matches = []
    matches = []

    deparse.initialise_cache()

    for segment in segments:
        base_segment = Segment.from_dictionary(segment)

        base_matches.append((segment['IPA'],
                             deparse.segment_match(feature_strings,
                                                   base_segment)))
        matches.append((segment['IPA'], deparse.segment_match(feature_strings,
                                                              base_segment)))

        for diacritic in diacritics:
            IPA_representation = segment['IPA'] + diacritic['IPA']

            if base_segment.meets_conditions(diacritic['conditions']):
                diacritic_segment = base_segment + Segment(diacritic['applies'].get('positive', []),
                                                           diacritic['applies'].get('negative', []))

                matches.append((IPA_representation,
                                deparse.segment_match(feature_strings,
                                                      diacritic_segment)))

    print('Calculating base accuracy...')
    base_successes = 0
    for match in base_matches:
        if match[0] == match[1]:
            base_successes += 1
        else:
            print('\tExpected {0}, deparsed {1}'.format(match[0], match[1]))

    print('Calculating diacritic accuracy...')
    successes = len([match for match in matches if match[0] == match[1]])

    return (base_successes / len(base_matches)), (successes / len(matches))
コード例 #21
0
ファイル: test_segment.py プロジェクト: kdelwat/LangEvolve
def test_setters():
    feature_dictionary = {'stress': '+', 'long': '-', 'continuant': '0',
                          'IPA': 'b'}

    segment = Segment.from_dictionary(feature_dictionary)

    segment.add_positive('long')
    assert segment.positive == ['stress', 'long']
    assert segment.negative == []

    segment.add_negative('stress')
    assert segment.positive == ['long']
    assert segment.negative == ['stress']

    segment.add_negative('stress')
    assert segment.positive == ['long']
    assert segment.negative == ['stress']
コード例 #22
0
def _travel_path(origin_id, start_id):
	path = []
	branch_encounted = False
	head = start_id
	while True:
		path.append(head)
		b = Segment.by_id(head)
		if not b:
			b = Block.by_id(head)
		if origin_id == head:
			break
		if b.has_return():
			break
		if b.branch() and not b.branch().has_return():
			branch_encounted = True
			break
		head = b.passthru().id
	return path, branch_encounted
コード例 #23
0
def _new_segment(segment, segments, included_in, members):
	id = segment.id
	segments.append(segment.id)

	m = []
	if segment.type == Segment.BRANCH:
		m = segment.left[:]
		m.extend(segment.right[:])
	elif segment.type == Segment.LOOP:
		m = segment.body[:]

	sm = []
	for block_id in m:
		if Segment.by_id(block_id):
			if block_id not in included_in: # temporary
				included_in[block_id] = id
			sm.extend(members[block_id])
			sm.remove(block_id) # remove dup
	
	m.append(id)
	m.extend(sm)
	members[id] = m
コード例 #24
0
track_features_small = pickle.load(open('trackToFeatureTuples.p', 'rb'))
clusters = km.kmeans(track_features_small, 10)

track_features_full = j.constructNamesToDict()
cluster_num = 0

for cluster in clusters:
    # list of Segment objects
    cluster_30segments = []
    starts = []
    for track in cluster:
        segments = track_features_full[track]["segments"]

        segment30 = []
        for i in xrange(len(segments)):
            s = Segment(track, i, segments[i])
            segment30.append(s)
            if (i + 1) % 30 == 0:
                cluster_30segments.append(segment30)
                if i + 1 == 30:
                    starts.append(segment30)
                segment30 = []

    start = random.choice(starts)

    sp = mashupSearchProblem(cluster_30segments, start, 5, sc.segmentsCost)
    ucs_alg = ucs.UniformCostSearch()
    ucs_alg.solve(sp)
    mashup = [s for s in start] + [s for a in ucs_alg.actions for s in a]

    segment_titles = []
コード例 #25
0
ファイル: timeline.py プロジェクト: gw17/pyannote-core
 def from_json(cls, data):
     uri = data.get(PYANNOTE_URI, None)
     segments = [Segment.from_json(s) for s in data[PYANNOTE_JSON_CONTENT]]
     return cls(segments=segments, uri=uri)
コード例 #26
0
ファイル: timeline.py プロジェクト: Parisson/pyannote-core
 def from_json(cls, data):
     segments = [Segment.from_json(s) for s in data[PYANNOTE_JSON_TIMELINE]]
     uri = data.get(PYANNOTE_URI, None)
     return cls(segments=segments, uri=uri)
コード例 #27
0
ファイル: shell.py プロジェクト: humatic/foxsi-optics-sim
class Shell:
    '''
    A shell consists of two segments, one in the front and one behind. The base location
    of the front segment has a smaller z value than that of the back segement. Thus, rays
    coming from sources in the negative z range will enter the front end first.
    '''

    def __init__(self,
                 base = [0,0,0],
                 seglen = 30.0,
                 ang = 0.00643866102405, # focal length of 2m
                 r = 5.151
                 ):
        '''
        Constructor
        
        Parameters:
            base:    the center point of the wide end of the segment
            seglen:  the axial length of each segment
            ang:     angle between the shell axis and the side of the front segment
            r:       radius of the shell where the two segments meet
        '''
        self.front = Segment(base=base, seglen=seglen, ang=ang, r1=r)
        backBase = [base[0], base[1], base[2]+seglen]
        self.back = Segment(base=backBase, seglen=seglen, ang=3*ang, r0=r)
        
    def getSurfaces(self):
        '''
        Returns a list of surfaces
        '''
        return [self.front,self.back]
        
    def plot2D(self, axes, color = 'b'):
        '''
        Plots a 2d cross section of the shell 
        '''
        self.front.plot2D(axes, color)
        self.back.plot2D(axes, color)
 
        # plot rays
        ang = self.front.ang
        r = self.back.r1
        z = self.back.base[2]
        d = r*tan((pi/2)-4*ang)
        axes.plot((2*z,2*z+d),(r,0),'y:')
        axes.plot((2*z,2*z+d),(-r,0),'y:')   
    
    def plot3D(self, axes, color = 'b'):
        '''
        Generates a 3d plot of the shell in the given figure
        '''
        self.front.plot3D(axes,color)
        self.back.plot3D(axes,color)
        
    def targetFront(self,a,b):
        '''
        Takes two list arguments of equal size, the elements of which range from 0 to 1.
        Returns an array of points that exist on the circle defined by the wide end of 
        the shell. 
        '''
        return self.front.targetFront(a,b)
    
    def targetBack(self,a,b):
        '''
        Takes two list arguments of equal size, the elements of which range from 0 to 1.
        Returns an array of points that exist on the circle defined by the small end of 
        the shell. 
        '''
        return self.back.targetBack(a,b)
     
        
コード例 #28
0
ファイル: scene.py プロジェクト: nycholas/polygon-area
 def createSegment(self, vt1, vt2):
     segment = Segment(self)
     segment.setPos(vt1, vt2)
     return segment
コード例 #29
0
ファイル: classfier.py プロジェクト: reedboat/applib
 def __init__(self, host, port):
     self.load()
     self.segmentor= Segment(host, port)
コード例 #30
0
ファイル: set_class.py プロジェクト: janrygl/sir
def set_process(sentences, delimiter='<!>', line_break='\n', option=None):
    dep_out = False
    phr_out = False
    relaxed_out = False
    laa_out = False
    collx_out = False
    use_collx = False
    phrases = False
    print_tree = False
    phr_verbs_path = ''
    pos_tags = True
    desamb_hacks = False
    
    grammar = os.path.join(set_path, 'grammar.set')
    lw_collx = os.path.join(set_path, 'data', 'lemma-word')
    ll_collx = os.path.join(set_path, 'data', 'lemma-lemma')
    lt_collx = os.path.join(set_path, 'data', 'lemma-tag')
    ls_collx = os.path.join(set_path, 'data', 'lemma-semclass')
    ss_collx = os.path.join(set_path, 'data', 'semclass-semclass')    

    if   option == '-d': dep_out = True    
    elif option == '-p': phr_out = True    
    elif option == '--cout': collx_out = True
    elif option == '--phrases': phrases = True
    elif option == '--laa': laa_out = True
    

    phr_verbs = {}
    if phr_verbs_path:
        for line in open(phr_verbs_path):
            llist = line.split()
            if llist[0] not in phr_verbs: phr_verbs[llist[0]] = []
            phr_verbs[llist[0]].append(tuple(llist[1:]))

    grammar = Grammar(grammar)
    if use_collx:
        parser = Parser(grammar, lw_collx_root=lw_collx,
            ll_collx_root=ll_collx, lt_collx_root=lt_collx,
            ls_collx_root=ls_collx, ss_collx_root=ss_collx)
    else:
        parser = Parser(grammar)

    def sigusr1_handler(*args):
        #open('/tmp/set-sigusr1-last-sentence', 'w').write(''.join(lines))
        sys.exit(1)

    signal.signal(signal.SIGUSR1, sigusr1_handler)
    chunks =  sentences.split(delimiter)
    signal.alarm(len(chunks) * 10)

    f = TextFile()
    for sentence in chunks:
        sentence_chunks = [w.replace('\t', ' ') 
            for w in sentence.split(line_break) if w and w[0] != "<"]
        if len(sentence_chunks) == 0:
            continue
        s = Segment(sentence_chunks, pos_tags=pos_tags,
            desamb_hacks=desamb_hacks, phr_verbs=phr_verbs)
        parser.parse(s)
        if dep_out: s.print_dep_tree(root=False, file=f)
        if laa_out: s.print_laa_tree(file=f)
        if phr_out: s.print_phr_tree(file=f)
        if relaxed_out: s.print_relaxed_tree(file=f)
        if collx_out: s.print_collx_out(file=f)
        if print_tree: s.print_tree(file=f)
        if phrases: s.print_phrases(file=f)
        f.write('\n')
    return f.get()
コード例 #31
0
ファイル: classfier.py プロジェクト: reedboat/applib
class Classfier():
    segmentor = None
    features={}
    categorys={}
    model={}

    def __init__(self, host, port):
        self.load()
        self.segmentor= Segment(host, port)

    def __del__(self):
        if self.segmentor:
            self.segmentor = None
        self.features = None 
        self.categorys = None
        self.model = None

    def load(self):
        feature_file='thrift/etc/feature.txt'
        category_file='thrift/etc/catid.txt'
        model_file='thrift/data/knn.model'

# load centoroid
        for line in open(model_file):
            line = line.strip()
            if not line:
                break
            index, rest=line.split('|')
            centoroid = {}
            for part in rest.split(" "):
                k, v = part.split(':')
                centoroid[int(k)] = float(v)
            self.model[int(index)] = centoroid
        
# load features
        for line in open(feature_file):
            line=line.strip()
            parts = line.split("\t")
            feature = {
                "index": int(parts[0]),
                "idf" : float(parts[2])
            }
            word = parts[1]
            self.features[word] = feature

# load category
        for line in open(category_file):
            line = line.strip()
            catid, leaf, root = line.split("\t")
            self.categorys[int(catid)] = leaf
    

    def predict(self, content):
        features = self.text2Feature(content)
        return self.maxProbCat(features);

    def segment(self, content):
        self.segmentor.connect()
        result  = self.segmentor.segment(content)
        self.segmentor.close()
        return self.segmentor.parse(result)

    def similarity(self, docFeatures, centoroid):
        value = 0.0
        for k,v in enumerate(docFeatures):
            item = docFeatures[v]
            if (centoroid.has_key(v)):
                value += item['weight'] * centoroid[v] 
        return value

    def text2Feature(self, content):
        keywords = self.segment(content)
        #print keywords
        features = {}
        for wordTf in keywords:
            word, tf = wordTf.split(':')
            tf = float(tf)
            if self.features.has_key(word):
                feature = self.features[word]
                index = feature["index"]
                idf   = feature["idf"]
                features[index] = {"word":word, "weight":tf*idf}
        #print features
        return features

    def maxProbCat(self, features):
        maxScore = 0.0
        probCat  = -1
        #docDotProduct = math.sqrt(sum(f.weight * f.weight for f in features))
        #if docDotProduct == 0:
            #return probCat

        for k, v in enumerate(self.model):
            score = self.similarity(features, self.model[v]);
            #print self.categorys[v], int(score * 10000)
            if score > maxScore:
                maxScore = score
                probCat = v

        label = self.categorys[probCat]
        return label