Skip to content
GitLab

deeppavlov.deprecated removed

Merged Andrei Glinskii requested to merge cleansing into dev
Compare
and
30 files
+ 4
- 1285
deepp‎avlov‎
depre‎cated‎
ag‎ent‎
__ini‎t__.py‎ +0 -4
agen‎t.py‎ +0 -154
filt‎er.py‎ +0 -50
proces‎sor.py‎ +0 -46
rich_co‎ntent.py‎ +0 -159
age‎nts‎
defaul‎t_agent‎
__ini‎t__.py‎ +0 -1
default_‎agent.py‎ +0 -95
fil‎ters‎
__ini‎t__.py‎ +0 -1
transparen‎t_filter.py‎ +0 -45
hello_b‎ot_agent‎
__ini‎t__.py‎ +0 -0
hello_bot‎_agent.py‎ +0 -40
proce‎ssors‎
__ini‎t__.py‎ +0 -3
default_rich_con‎tent_processor.py‎ +0 -47
highest_confide‎nce_selector.py‎ +0 -41
random_se‎lector.py‎ +0 -41
rich_c‎ontent‎
__ini‎t__.py‎ +0 -1
default_ric‎h_content.py‎ +0 -203
__ini‎t__.py‎ +0 -0
sk‎ill‎
__ini‎t__.py‎ +0 -1
skil‎l.py‎ +0 -49
ski‎lls‎
defaul‎t_skill‎
__ini‎t__.py‎ +0 -1
default_‎skill.py‎ +0 -94
pattern_mat‎ching_skill‎
__ini‎t__.py‎ +0 -1
pattern_matc‎hing_skill.py‎ +0 -100
similarity_m‎atching_skill‎
__ini‎t__.py‎ +0 -1
similarity_mat‎ching_skill.py‎ +0 -106
__ini‎t__.py‎ +0 -0
__ini‎t__.py‎ +0 -0
_met‎a.py‎ +1 -1
READ‎ME.md‎ +3 -0
deeppavlov/deprecated/agent/__init__.py deleted 100644 → 0
+ 0
- 4
from .agent import Agent, SkillWrapper
from .filter import Filter
from .processor import Processor
from .rich_content import RichControl, RichMessage
deeppavlov/deprecated/agent/agent.py deleted 100644 → 0
+ 0
- 154
# Copyright 2017 Neural Networks and Deep Learning lab, MIPT
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from abc import ABCMeta, abstractmethod
from collections import defaultdict
from typing import List, Dict, Tuple, Optional
from deeppavlov.core.models.component import Component
from deeppavlov.utils.connector.dialog_logger import DialogLogger
class Agent(Component, metaclass=ABCMeta):
"""Abstract class for agents.
Agent is an entity which receives inputs from the outer word, processes
them and returns response to each input. Usually agent implements real-life
task, business or user case. Agent encapsulates skills instances, management
of skills inference and skills inference results processing. Also agent
provides management both for history and state for each utterance and uses
only incoming utterances IDs to distinguish them.
Args:
skills: List of initiated agent skills instances.
Attributes:
skills: List of initiated Skill or Component instances.
Components API should should implement API of Skill abstract class.
history: Histories for each each dialog with agent indexed
by dialog ID. Each history is represented by list of incoming
and outcoming replicas of the dialog casted to str and updated automatically.
states: States for each skill with agent indexed by dialog ID. Each
state updated automatically after each wrapped skill inference.
So we highly recommend use this attribute only for reading and
not to use it for your custom skills management.
wrapped_skills: Skills wrapped to SkillWrapper objects. SkillWrapper
object gives to Skill __call__ signature of Agent __call__ and
handles automatic state management for skill. All skills are
wrapped to SkillsWrapper automatically during agent initialisation.
We highly recommend to use wrapped skills for skills inference.
dialog_logger: DeepPavlov dialog logging facility.
"""
def __init__(self, skills: List[Component]) -> None:
self.skills = skills
self.history: Dict = defaultdict(list)
self.states: Dict = defaultdict(lambda: [None] * len(self.skills))
self.wrapped_skills: List[SkillWrapper] = \
[SkillWrapper(skill, skill_id, self) for skill_id, skill in enumerate(self.skills)]
self.dialog_logger: DialogLogger = DialogLogger()
def __call__(self, utterances_batch: list, utterances_ids: Optional[list] = None) -> list:
"""Wraps _call method and updates utterances history.
Args:
utterances_batch: Batch of incoming utterances.
utterances_ids: Batch of dialog IDs corresponding to incoming utterances.
Returns:
responses: A batch of responses corresponding to the
utterance batch received by agent.
"""
responses_batch = self._call(utterances_batch, utterances_ids)
batch_size = len(utterances_batch)
ids = utterances_ids or list(range(batch_size))
for utt_batch_idx, utt_id in enumerate(ids):
self.history[utt_id].append(str(utterances_batch[utt_batch_idx]))
self.dialog_logger.log_in(utterances_batch[utt_batch_idx], utt_id)
self.history[utt_id].append(str(responses_batch[utt_batch_idx]))
self.dialog_logger.log_out(responses_batch[utt_batch_idx], utt_id)
return responses_batch
@abstractmethod
def _call(self, utterances_batch: list, utterances_ids: Optional[list] = None) -> list:
"""Processes batch of utterances and returns corresponding responses batch.
Each call of Agent processes incoming utterances and returns response
for each utterance Batch of dialog IDs can be provided, in other case
utterances indexes in incoming batch are used as dialog IDs.
Args:
utterances_batch: Batch of incoming utterances.
utterances_ids: Batch of dialog IDs corresponding to incoming utterances.
Returns:
responses: A batch of responses corresponding to the
utterance batch received by agent.
"""
pass
class SkillWrapper:
"""Skill instances wrapper for internal use in Agent.
SkillWrapper gives to skill interface of Agent and handles automatic state
management for skill.
Args:
skill: Wrapped skill.
skill_id: Skill index in Agent.skills list.
agent: Agent instance.
Attributes:
skill: Wrapped skill.
skill_id: Skill index in Agent.skills list.
agent: Agent instance.
"""
def __init__(self, skill: Component, skill_id: int, agent: Agent) -> None:
self.skill = skill
self.skill_id = skill_id
self.agent = agent
def __call__(self, utterances_batch: list, utterances_ids: Optional[list] = None) -> Tuple[list, list]:
"""Wraps __call__ method of Skill instance.
Provides skill __call__ with signature of Agent __call__ and handles
automatic state management for skill.
Args:
utterances_batch: Batch of incoming utterances.
utterances_ids: Batch of dialog IDs corresponding to incoming utterances.
Returns:
response: A batch of arbitrary typed skill inference results.
confidence: A batch of float typed confidence levels for each of
skill inference result.
states: Optional. A batch of arbitrary typed states for each
response.
"""
history_batch = [self.agent.history[utt_id] for utt_id in utterances_ids]
states_batch = [self.agent.states[utt_id][self.skill_id] for utt_id in utterances_ids]
predicted, confidence, *states = self.skill(utterances_batch, history_batch, states_batch)
states = states[0] if states else [None] * len(predicted)
for utt_id, state in zip(utterances_ids, states):
self.agent.states[utt_id][self.skill_id] = state
return predicted, confidence
deeppavlov/deprecated/agent/filter.py deleted 100644 → 0
+ 0
- 50
# Copyright 2017 Neural Networks and Deep Learning lab, MIPT
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from abc import ABCMeta, abstractmethod
from deeppavlov.core.models.component import Component
class Filter(Component, metaclass=ABCMeta):
"""Abstract class for filters. Filter is a DeepPavlov component,
which is used in Agent to select utterances from incoming batch
to be processed for each Agent skill.
"""
@abstractmethod
def __call__(self, utterances_batch: list, history_batch: list) -> list:
"""Returns skills-utterances application matrix.
Returns skills-utterances application matrix which contains
information about Agent skills to be applied to each utterance
from incoming batch.
Args:
utterances_batch: A batch of utterances of any type.
history_batch: A batch of list typed histories
for each utterance.
Returns:
response: Skills-utterances application matrix,
for example:
[[True, False, True, True],
[False, True, True, True]]
Where each inner dict corresponds to one of the Agent
skills and each value in the inner dict contains information
about whether the skill will be applied to the utterance
with the same position in the utterances_batch.
"""
pass
deeppavlov/deprecated/agent/processor.py deleted 100644 → 0
+ 0
- 46
# Copyright 2017 Neural Networks and Deep Learning lab, MIPT
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from abc import ABCMeta, abstractmethod
from deeppavlov.core.models.component import Component
class Processor(Component, metaclass=ABCMeta):
"""Abstract class for processors. Processor is a DeepPavlov component,
which is used in Agent to process skills responses and give one final
response for each utterance.
"""
# TODO: change *responses to [[], [], ...] argument
@abstractmethod
def __call__(self, utterances_batch: list, history_batch: list, *responses: list) -> list:
"""Returns final response for each incoming utterance.
Processes Agent skills and generates one final response for each
utterance in incoming batch.
Args:
utterances_batch: A batch of utterances of any type
history_batch: A batch of list typed histories
for each utterance
responses: Each response positional argument corresponds to
response of one of Agent skills and is represented by
batch (list) of (response, confidence) tuple structures.
Returns:
responses: A batch of responses corresponding to the
utterance batch received by agent.
"""
pass
deeppavlov/deprecated/agent/rich_content.py deleted 100644 → 0
+ 0
- 159
# Copyright 2017 Neural Networks and Deep Learning lab, MIPT
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from abc import ABCMeta, abstractmethod
from typing import Union
class RichItem(metaclass=ABCMeta):
"""Base class for rich content elements.
Every rich content element
is presumed to return its state (including state of nested controls)
at least in json format (mandatory) as well as in the formats compatible
with other channels.
"""
@abstractmethod
def json(self) -> Union[list, dict]:
"""Returns json compatible state of the control instance including
its nested controls.
Returns:
control: Json representation of control state.
"""
pass
def ms_bot_framework(self):
"""Returns MS Bot Framework compatible state of the control instance
including its nested controls.
Returns:
control: MS Bot Framework representation of control state.
"""
return None
def telegram(self):
"""Returns Telegram compatible state of the control instance
including its nested controls.
Returns:
control: Telegram representation of control state.
"""
return None
def alexa(self):
"""Returns Amazon Alexa compatible state of the control instance
including its nested controls.
Returns:
control: Amazon Alexa representation of control state.
"""
return None
class RichControl(RichItem, metaclass=ABCMeta):
"""Base class for rich controls.
Rich control can be a button, buttons box, plain text, image, etc.
All rich control classes should be derived from RichControl.
Args:
control_type: Name of the rich control type.
Attributes:
control_type: Name of the rich control type.
content: Arbitrary used control content holder.
control_json: Control json representation template, which
contains control type and content fields.
"""
def __init__(self, control_type: str) -> None:
self.control_type: str = control_type
self.content = None
self.control_json: dict = {'type': control_type, 'content': None}
def __str__(self) -> str:
return ''
class RichMessage(RichItem):
"""Container for rich controls.
All rich content elements returned by agent as a result of single
inference should be embedded into RichMessage instance in the order
these elements should be displayed.
Attributes:
controls: Container for RichControl instances.
"""
def __init__(self) -> None:
self.controls: list = []
def __str__(self) -> str:
result = '\n'.join(filter(bool, map(str, self.controls)))
return result
def add_control(self, control: RichControl):
"""Adds RichControl instance to RichMessage.
Args:
control: RichControl instance.
"""
self.controls.append(control)
def json(self) -> list:
"""Returns list of json compatible states of the RichMessage instance
nested controls.
Returns:
json_controls: Json representation of RichMessage instance
nested controls.
"""
json_controls = [control.json() for control in self.controls]
return json_controls
def ms_bot_framework(self) -> list:
"""Returns list of MS Bot Framework compatible states of the
RichMessage instance nested controls.
Returns:
ms_bf_controls: MS Bot Framework representation of RichMessage instance
nested controls.
"""
ms_bf_controls = [control.ms_bot_framework() for control in self.controls]
return ms_bf_controls
def telegram(self) -> list:
"""Returns list of Telegram compatible states of the RichMessage
instance nested controls.
Returns:
telegram_controls: Telegram representation of RichMessage instance nested
controls.
"""
telegram_controls = [control.telegram() for control in self.controls]
return telegram_controls
def alexa(self) -> list:
"""Returns list of Amazon Alexa compatible states of the RichMessage
instance nested controls.
Returns:
alexa_controls: Amazon Alexa representation of RichMessage instance nested
controls.
"""
alexa_controls = [control.alexa() for control in self.controls]
return alexa_controls