Merge pull request #8 from deeplearningunb/database-json

Ultimo pull request

actions/actions.py

@@ -7,13 +7,19 @@
 
 # This is a simple example for a custom action which utters "Hello World!"
 
+import json
 from os import name
 from typing import Any, Text, Dict, List
 
 
 from pathlib import Path
 from rasa_sdk import Action, Tracker
 from rasa_sdk.executor import CollectingDispatcher
+
+# Import para o json
+from rasa_sdk.knowledge_base.storage import InMemoryKnowledgeBase
+from rasa_sdk.knowledge_base.actions import ActionQueryKnowledgeBase
+
 from rasa_sdk.events import SlotSet
 
 
@@ -63,110 +69,79 @@ def run(self, dispatcher: CollectingDispatcher,
                 text=f"Seu nome, {username}!")
         return []
 
-# class ActionAskName(Action):
+
+# class ActionReceiveContent(Action):
 
 #     def name(self) -> Text:
-#         return "action_facility_search"
+#         return "action_receive_content"
 
 #     def run(self, dispatcher: CollectingDispatcher,
 #             tracker: Tracker,
 #             domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
 
-#         facility = tracker.get.slot("facility_type")
-#         estado = "Goias"
-#         dispatcher.utter_message(
-#             "Aqui é a sua localidade {}.{}".format(facility, estado))
+#         text = tracker.latest_message['text']
+#         dispatcher.utter_message(text=f"Eu irei falar sobre {text}!")
 
-#         return [SlotSet("estado", estado)]
+#         return [SlotSet("content_name", text)]
 
 
-# class ActionAskName(Action):
-#     knowledge = Path("data/content.txt").read_text().split("/n")
+# class ActionContentDefinition(Action):
 
 #     def name(self) -> Text:
-#         return "action_definition"
+#         return "action_content_definition"
 
 #     def run(self, dispatcher: CollectingDispatcher,
 #             tracker: Tracker,
 #             domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
 
-#         for blob in tracker.latest_message['entities']:
-#             print(tracker.latest_message)
-#             if blob['entity'] == 'content_name':
-#                 name = blob['value']
-#                 if name in self.knowledge:
-#                     dispatcher.utter_message(text=f"Sim, eu sei sobre {name}")
-#                 else:
-#                     dispatcher.utter_message(
-#                         text=f"Eu não sei sobre {name}, desculpe.")
+#         content = tracker.get_slot("content_name")
+#         if not content:
+#             dispatcher.utter_message(
+#                 text=f"Eu não sei qual conteúdo você quer que eu ensine")
+#         else:
+#             contentlow = content.lower()
+#             if contentlow == "ann":
+#                 dispatcher.utter_message(
+#                     text=f"{content} significa artificial neural network, traduzido para português como rede neural artificial. A rede neural artificial é uma rede artificial que utiliza uma série de neurônios para aprender, sendo este um sistema de hardware e/ou software padronizado após a operação de neurônios no cérebro humano.!")
+#             elif contentlow == "cnn":
+#                 dispatcher.utter_message(
+#                     text=f"{content} significa Convolutional Neural Network, traduzido para português como rede neural convolucional. Uma Rede Neural Convolucional (ConvNet / Convolutional Neural Network / CNN) é um algoritmo de Aprendizado Profundo que pode captar uma imagem de entrada, atribuir importância (pesos e vieses que podem ser aprendidos) a vários aspectos / objetos da imagem e ser capaz de diferenciar um do outro. O pré-processamento exigido em uma ConvNet é muito menor em comparação com outros algoritmos de classificação. Enquanto nos métodos primitivos os filtros são feitos à mão, com treinamento suficiente, as ConvNets têm a capacidade de aprender esses filtros / características.")
+#             elif contentlow == "rnn":
+#                 dispatcher.utter_message(
+#                     text=f"{content} significa recurrent neural network, trauduzido para português como rede neural recorrente. Uma Rede Neural Recorrente (RNN) é um algoritmo de Aprendizado Profundo que pode captar uma sequência de dados e ser capaz de aprender a reconhecer essa sequência. As conexões entre os nós formam um grafo direcionado ao longo de uma sequência temporal. Isso permite que ele exiba um comportamento dinâmico temporal. Derivado de redes neurais feedforward, os RNNs podem usar seu estado interno (memória) para processar sequências de entradas de comprimento variável.")
+#             elif contentlow == "sae":
+#                 dispatcher.utter_message(
+#                     text=f"{content} significa 'Sequential Autoencoder', ou seja, uma rede autoencoder sequencial. A rede autoencoder sequencial é uma rede neural que aprende a reconhecer uma sequência de dados, usando um processo de treinamento de recursos de aprendizagem não supervisionados por cada camada, o que resulta em uma precisão de previsão consideravelmente melhorada do modelo de calibração.")
+#             elif contentlow == "som":
+#                 dispatcher.utter_message(
+#                     text=f"{content} signfica Self Organizing Map, traduzindo para português temos Mapa Auto Organizável, esta é uma rede neural que aprende a reconhecer um mapa de dados, usando um processo de treinamento de recursos de aprendizagem não supervisionados por cada camada, o que resulta em uma precisão de previsão consideravelmente melhorada do modelo de calibração.")
 
 #         return []
 
-class ActionReceiveContent(Action):
+class ActionContentCheck(Action):
+    knowledge = Path("data/content.txt").read_text().split(',')
 
     def name(self) -> Text:
-        return "action_receive_content"
+        return "action_check_knowledge"
 
     def run(self, dispatcher: CollectingDispatcher,
             tracker: Tracker,
             domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
 
-        text = tracker.latest_message['text']
-        dispatcher.utter_message(text=f"Eu irei falar sobre {text}!")
-
-        return [SlotSet("content_name", text)]
-
-
-class ActionContentDefinition(Action):
-
-    def name(self) -> Text:
-        return "action_content_definition"
-
-    def run(self, dispatcher: CollectingDispatcher,
-            tracker: Tracker,
-            domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
-
-        content = tracker.get_slot("content_name")
-        if not content:
-            dispatcher.utter_message(
-                text=f"Eu não sei qual conteúdo você quer que eu ensine")
-        else:
-            contentlow = content.lower()
-            if contentlow == "ann":
-                dispatcher.utter_message(
-                    text=f"{content} significa artificial neural network, traduzido para português como rede neural artificial. A rede neural artificial é uma rede artificial que utiliza uma série de neurônios para aprender, sendo este um sistema de hardware e/ou software padronizado após a operação de neurônios no cérebro humano.!")
-            elif contentlow == "cnn":
-                dispatcher.utter_message(
-                    text=f"{content} significa Convolutional Neural Network, traduzido para português como rede neural convolucional. Uma Rede Neural Convolucional (ConvNet / Convolutional Neural Network / CNN) é um algoritmo de Aprendizado Profundo que pode captar uma imagem de entrada, atribuir importância (pesos e vieses que podem ser aprendidos) a vários aspectos / objetos da imagem e ser capaz de diferenciar um do outro. O pré-processamento exigido em uma ConvNet é muito menor em comparação com outros algoritmos de classificação. Enquanto nos métodos primitivos os filtros são feitos à mão, com treinamento suficiente, as ConvNets têm a capacidade de aprender esses filtros / características.")
-            elif contentlow == "rnn":
-                dispatcher.utter_message(
-                    text=f"{content} significa recurrent neural network, trauduzido para português como rede neural recorrente. Uma Rede Neural Recorrente (RNN) é um algoritmo de Aprendizado Profundo que pode captar uma sequência de dados e ser capaz de aprender a reconhecer essa sequência. As conexões entre os nós formam um grafo direcionado ao longo de uma sequência temporal. Isso permite que ele exiba um comportamento dinâmico temporal. Derivado de redes neurais feedforward, os RNNs podem usar seu estado interno (memória) para processar sequências de entradas de comprimento variável.")
-            elif contentlow == "sae":
-                dispatcher.utter_message(
-                    text=f"{content} significa 'Sequential Autoencoder', ou seja, uma rede autoencoder sequencial. A rede autoencoder sequencial é uma rede neural que aprende a reconhecer uma sequência de dados, usando um processo de treinamento de recursos de aprendizagem não supervisionados por cada camada, o que resulta em uma precisão de previsão consideravelmente melhorada do modelo de calibração.")
-            elif contentlow == "som":
-                dispatcher.utter_message(
-                    text=f"{content} signfica Self Organizing Map, traduzindo para português temos Mapa Auto Organizável, esta é uma rede neural que aprende a reconhecer um mapa de dados, usando um processo de treinamento de recursos de aprendizagem não supervisionados por cada camada, o que resulta em uma precisão de previsão consideravelmente melhorada do modelo de calibração.")
+        for blob in tracker.latest_message['entities']:
+            print(tracker.latest_message)
+            if blob['entity'] == 'content_name':
+                name = blob['value']
+                if name in self.knowledge:
+                    dispatcher.utter_message(text=f"Sim, eu sei sobre {name}")
+                else:
+                    dispatcher.utter_message(
+                        text=f"Eu não sei sobre {name}, desculpe.")
 
         return []
 
 
-# class ActionCheckKnowledge(Action):
-#     knowledge = Path("data/content.txt").read_text().split("/n")
-
-#     def name(self) -> Text:
-#         return "action_check_knowledge"
-
-#     def run(self, dispatcher: CollectingDispatcher,
-#             tracker: Tracker,
-#             domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
-
-#         for blob in tracker.latest_message['entities']:
-#             print(tracker.latest_message)
-#             name = blob['value']
-#             if name in self.knowledge:
-#                 dispatcher.utter_message(text=f"Sim, eu sei {name}.")
-#             else:
-#                 dispatcher.utter_message(
-#                     text=f"Eu não sei {name}, desulpe.")
-#         return[]
+class MyKnowledgeBaseAction(ActionQueryKnowledgeBase):
+    def __init__(self):
+        knowledge_base = InMemoryKnowledgeBase("data/contentdb.json")
+        super().__init__(knowledge_base)

config.yml

@@ -15,7 +15,6 @@ pipeline:
     min_ngram: 1
     max_ngram: 4
   - name: DIETClassifier
-    entity_recognition: false
     epochs: 100
     constrain_similarities: true
   - name: EntitySynonymMapper

content/IKNOW.md

@@ -38,24 +38,19 @@
 
     Definição
     ---------
-        CNN significa Convolutional Neural Network, traduzido para português como rede neural convolucional.
-        Uma Rede Neural Convolucional (ConvNet / Convolutional Neural Network / CNN) é um algoritmo de Aprendizado Profundo que pode captar uma imagem de entrada, atribuir importância (pesos e vieses que podem ser aprendidos) a vários aspectos / objetos da imagem e ser capaz de diferenciar um do outro. O pré-processamento exigido em uma ConvNet é muito menor em comparação com outros algoritmos de classificação. Enquanto nos métodos primitivos os filtros são feitos à mão, com treinamento suficiente, as ConvNets têm a capacidade de aprender esses filtros / características.
+        CNN significa Convolutional Neural Network, traduzido para português como rede neural convolucional.Uma Rede Neural Convolucional (ConvNet / Convolutional Neural Network / CNN) é um algoritmo de Aprendizado Profundo que pode captar uma imagem de entrada, atribuir importância (pesos e vieses que podem ser aprendidos) a vários aspectos / objetos da imagem e ser capaz de diferenciar um do outro. O pré-processamento exigido em uma ConvNet é muito menor em comparação com outros algoritmos de classificação. Enquanto nos métodos primitivos os filtros são feitos à mão, com treinamento suficiente, as ConvNets têm a capacidade de aprender esses filtros / características.
 
     Arquitetura
     -----------
-        A arquitetura de uma ConvNet é análoga àquela do padrão de conectividade de neurônios no cérebro humano e foi inspirada na organização do Visual Cortex. Os neurônios individuais respondem a estímulos apenas em uma região restrita do campo visual conhecida como Campo Receptivo. Uma coleção desses campos se sobrepõe para cobrir toda a área visual. Os neurônios são conectados entre si para formar uma rede.
-
-        As Redes Neurais Convolucionais são compostas por quatro camadas primárias: CONV, POOL, RELU e FC. Pegando essas camadas e empilhando-as em um determinado padrão rende uma arquitetura CNN.
+        A arquitetura de uma ConvNet é análoga àquela do padrão de conectividade de neurônios no cérebro humano e foi inspirada na organização do Visual Cortex. Os neurônios individuais respondem a estímulos apenas em uma região restrita do campo visual conhecida como Campo Receptivo. Uma coleção desses campos se sobrepõe para cobrir toda a área visual. Os neurônios são conectados entre si para formar uma rede.As Redes Neurais Convolucionais são compostas por quatro camadas primárias: CONV, POOL, RELU e FC. Pegando essas camadas e empilhando-as em um determinado padrão rende uma arquitetura CNN.
 
     Ativadores
     ----------
         Em um CNN, aplicamos uma função de ativação não linear, como ReLU, ELU ou qualquer uma das outras variantes Leaky ReLU. Normalmente denotamos camadas de ativação como RELU em diagramas de rede, uma vez que as ativações de ReLU são mais comumente usadas, também podemos simplesmente declarar ACT - em ambos os casos, estamos deixando claro que uma função de ativação está sendo aplicada dentro da arquitetura de rede.
 
     Camadas
     -------
-        A camada CONV é o bloco de construção central de uma Rede Neural Convolucional. Os parâmetros de camada CONV consistem em um conjunto de filtros k aprendendo (ou seja, "kernels"), onde cada filtro tem uma largura e uma altura, e são quase sempre quadrados. Estes filtros são pequenos (em termos de suas dimensões espaciais), mas se estendem por toda a profundidade do volume.
-
-        Depois de cada camada CONV em uma CNN, aplicamos uma função de ativação não linear, as camadas de ativação não são tecnicamente "camadas" (devido ao fato de que nenhum parâmetro/pesos são aprendidos dentro de uma camada de ativação) e às vezes são omitidos dos diagramas de arquitetura de rede, pois se presume que uma ativação segue imediatamente uma convolução
+        A camada CONV é o bloco de construção central de uma Rede Neural Convolucional. Os parâmetros de camada CONV consistem em um conjunto de filtros k aprendendo (ou seja, "kernels"), onde cada filtro tem uma largura e uma altura, e são quase sempre quadrados. Estes filtros são pequenos (em termos de suas dimensões espaciais), mas se estendem por toda a profundidade do volume.Depois de cada camada CONV em uma CNN, aplicamos uma função de ativação não linear, as camadas de ativação não são tecnicamente "camadas" (devido ao fato de que nenhum parâmetro/pesos são aprendidos dentro de uma camada de ativação) e às vezes são omitidos dos diagramas de arquitetura de rede, pois se presume que uma ativação segue imediatamente uma convolução
 
         Existem dois métodos para reduzir o tamanho de um volume de entrada — camadas CONV com um passo > 1 e camadas POOL. É comum inserir camadas POOL entre camadas CONV consecutivas em uma arquitetura CNN:
         INSUMO => CONV => RELU =pool de > => CONV => RELU =pool de > => FC
@@ -84,8 +79,7 @@
     Definição
     ---------
         RNN significa recurrent neural network, trauduzido para português como rede neural recorrente.
-        Uma Rede Neural Recorrente (RNN) é um algoritmo de Aprendizado Profundo que pode captar uma sequência de dados e ser capaz de aprender a reconhecer essa sequência.
-        As conexões entre os nós formam um grafo direcionado ao longo de uma sequência temporal. Isso permite que ele exiba um comportamento dinâmico temporal. Derivado de redes neurais feedforward, os RNNs podem usar seu estado interno (memória) para processar sequências de entradas de comprimento variável.
+        Uma Rede Neural Recorrente (RNN) é um algoritmo de Aprendizado Profundo que pode captar uma sequência de dados e ser capaz de aprender a reconhecer essa sequência.As conexões entre os nós formam um grafo direcionado ao longo de uma sequência temporal. Isso permite que ele exiba um comportamento dinâmico temporal. Derivado de redes neurais feedforward, os RNNs podem usar seu estado interno (memória) para processar sequências de entradas de comprimento variável.
 
     Arquitetura
     -----------

data/content.txt

@@ -1,5 +1 @@
-ann
-cnn
-rnn
-sae
-som
+ann,cnn,rnn,sae,som