centroids.py 3.32 KB
Newer Older
1
2
3
4
5
6
7
8
from senpy.plugins import EmotionConversionPlugin
from senpy.models import EmotionSet, Emotion, Error

import logging
logger = logging.getLogger(__name__)


class CentroidConversion(EmotionConversionPlugin):
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
    def __init__(self, info):
        if 'centroids' not in info:
            raise Error('Centroid conversion plugins should provide '
                        'the centroids in their senpy file')
        if 'onyx:doesConversion' not in info:
            if 'centroids_direction' not in info:
                raise Error('Please, provide centroids direction')

            cf, ct = info['centroids_direction']
            info['onyx:doesConversion'] = [{
                'onyx:conversionFrom': cf,
                'onyx:conversionTo': ct
            }, {
                'onyx:conversionFrom': ct,
                'onyx:conversionTo': cf
            }]

        if 'aliases' in info:
            aliases = info['aliases']
            ncentroids = {}
            for k1, v1 in info['centroids'].items():
                nv1 = {}
                for k2, v2 in v1.items():
                    nv1[aliases.get(k2, k2)] = v2
                ncentroids[aliases.get(k1, k1)] = nv1
            info['centroids'] = ncentroids
35

36
        super(CentroidConversion, self).__init__(info)
37

38
39
40
41
42
43
44
45
        self.dimensions = set()
        for c in self.centroids.values():
            self.dimensions.update(c.keys())
        self.neutralPoints = self.get("neutralPoints", dict())
        if not self.neutralPoints:
            for i in self.dimensions:
                self.neutralPoints[i] = self.get("neutralValue", 0)

46
47
48
49
50
51
    def _forward_conversion(self, original):
        """Sum the VAD value of all categories found."""
        res = Emotion()
        for e in original.onyx__hasEmotion:
            category = e.onyx__hasEmotionCategory
            if category in self.centroids:
52
                for dim, value in self.centroids[category].items():
53
54
55
56
57
58
59
60
                    try:
                        res[dim] += value
                    except Exception:
                        res[dim] = value
        return res

    def _backwards_conversion(self, original):
        """Find the closest category"""
61
62
63
64
65
66
67
68
        centroids = self.centroids
        neutralPoints = self.neutralPoints
        dimensions = self.dimensions

        def distance_k(centroid, original, k):
            # k component of the distance between the value and a given centroid
            return (centroid.get(k, neutralPoints[k]) - original.get(k, neutralPoints[k]))**2

69
        def distance(centroid):
70
71
72
            return sum(distance_k(centroid, original, k) for k in dimensions)

        emotion = min(centroids, key=lambda x: distance(centroids[x]))
73
74
75
76
77
78
79

        result = Emotion(onyx__hasEmotionCategory=emotion)
        return result

    def convert(self, emotionSet, fromModel, toModel, params):

        cf, ct = self.centroids_direction
80
81
        logger.debug(
            '{}\n{}\n{}\n{}'.format(emotionSet, fromModel, toModel, params))
82
        e = EmotionSet()
83
        if fromModel == cf and toModel == ct:
84
            e.onyx__hasEmotion.append(self._forward_conversion(emotionSet))
85
        elif fromModel == ct and toModel == cf:
86
87
88
89
90
            for i in emotionSet.onyx__hasEmotion:
                e.onyx__hasEmotion.append(self._backwards_conversion(i))
        else:
            raise Error('EMOTION MODEL NOT KNOWN')
        yield e