def load(
cls,
meta: Dict[Text, Any],
model_dir: Optional[Text] = None,
model_metadata: Optional[Metadata] = None,
cached_component: Optional["CountVectorsFeaturizer"] = None,
**kwargs: Any,
) -> "CountVectorsFeaturizer":
file_name = meta.get("file")
featurizer_file = os.path.join(model_dir, file_name)
if not os.path.exists(featurizer_file):
return cls(meta)
vocabulary = utils.json_unpickle(featurizer_file)
share_vocabulary = meta["use_shared_vocab"]
if share_vocabulary:
vectorizers = cls._create_shared_vocab_vectorizers(
meta, vocabulary=vocabulary)
else:
vectorizers = cls._create_independent_vocab_vectorizers(
meta, vocabulary=vocabulary)
return cls(meta, vectorizers)
def load(cls,
meta: Dict[Text, Any],
model_dir: Optional[Text] = None,
model_metadata: Optional['Metadata'] = None,
cached_component: Optional['Component'] = None,
**kwargs: Any) -> 'Component':
"""Load this component from file."""
from sklearn.preprocessing import LabelEncoder
from tensorflow.keras.models import load_model
from tensorflow.keras import backend
import tensorflow as tf
model_file = os.path.join(model_dir, meta.get('model'))
encoder_file = os.path.join(model_dir, meta.get('encoder'))
if os.path.exists(model_file):
graph = tf.Graph()
with graph.as_default():
session = tf.Session()
with session.as_default():
model = load_model(model_file)
classes = utils.json_unpickle(encoder_file)
encoder = LabelEncoder()
encoder.classes_ = classes
return cls(meta, model, encoder, graph=graph, session=session)
else:
return cls(meta)
def load(cls,
meta: Dict[Text, Any],
model_dir: Text = None,
model_metadata: Metadata = None,
cached_component: Optional["CountVectorsFeaturizer"] = None,
**kwargs: Any) -> "CountVectorsFeaturizer":
file_name = meta.get("file")
featurizer_file = os.path.join(model_dir, file_name)
if os.path.exists(featurizer_file):
vocabulary = utils.json_unpickle(featurizer_file)
vectorizer = CountVectorizer(
token_pattern=meta["token_pattern"],
strip_accents=meta["strip_accents"],
lowercase=meta["lowercase"],
stop_words=meta["stop_words"],
ngram_range=(meta["min_ngram"], meta["max_ngram"]),
max_df=meta["max_df"],
min_df=meta["min_df"],
max_features=meta["max_features"],
analyzer=meta["analyzer"],
vocabulary=vocabulary,
)
return cls(meta, vectorizer)
else:
return cls(meta)
def load(cls,
meta: Dict[Text, Any],
model_dir=None,
model_metadata=None,
cached_component=None,
**kwargs):
file_name = meta.get("classifier_file")
classifier_file = os.path.join(model_dir, file_name)
return utils.json_unpickle(classifier_file)
def __init__(self):
file_name = "classifier.pkl"
classifier_file = os.path.join("models/nlu-20200108-095729/nlu",
file_name)
classifier = utils.json_unpickle(classifier_file)
matrix = np.matrix(classifier.classifier.coef_)
print(matrix.max())
print(matrix.min())
print(classifier.classifier.coef_)
def load(cls,
meta: Dict[Text, Any],
model_dir: Optional[Text] = None,
model_metadata: Optional[Metadata] = None,
cached_component: Optional["SklearnIntentClassifier"] = None,
**kwargs: Any) -> "SklearnIntentClassifier":
from sklearn.preprocessing import LabelEncoder
classifier_file = os.path.join(model_dir, meta.get("classifier"))
encoder_file = os.path.join(model_dir, meta.get("encoder"))
if os.path.exists(classifier_file):
classifier = utils.json_unpickle(classifier_file)
classes = utils.json_unpickle(encoder_file)
encoder = LabelEncoder()
encoder.classes_ = classes
return cls(meta, classifier, encoder)
else:
return cls(meta)
def load(cls,
meta: Dict[Text, Any],
model_dir: Optional[Text] = None,
model_metadata: Optional[Metadata] = None,
cached_component: Optional["CustomFeaturizer"] = None,
**kwargs: Any) -> "CustomFeaturizer":
mapping_file_name = os.path.join(model_dir, meta.get("grams_mapping"))
if os.path.exists(mapping_file_name):
grams_mapping = utils.json_unpickle(mapping_file_name)
return cls(meta, grams_mapping)
return cls(meta)
def load(
cls,
meta: Dict[Text, Any],
model_dir: Optional[Text] = None,
model_metadata: Optional["Metadata"] = None,
cached_component: Optional["Component"] = None,
**kwargs: Any,
) -> "Component":
"""Load this component from file."""
file_name = meta.get("vectorizer_file")
vectorizer_file = os.path.join(model_dir, file_name)
return utils.json_unpickle(vectorizer_file)
def load(cls,
meta: Dict[Text, Any],
model_dir: Text = None,
model_metadata: Metadata = None,
cached_component: Optional['IncrementalCVF'] = None,
**kwargs: Any) -> 'IncrementalCVF':
if model_dir and meta.get("file"):
file_name = meta.get("file")
featurizer_file = os.path.join(model_dir, file_name)
return utils.json_unpickle(featurizer_file)
else:
logger.warning("Failed to load featurizer. Maybe path {} "
"doesn't exist".format(os.path.abspath(model_dir)))
return IncrementalCVF(meta)
def load(cls,
meta: Dict[Text, Any],
model_dir: Optional[Text] = None,
model_metadata: Optional[Metadata] = None,
cached_component: Optional["LanguageExtractor"] = None,
**kwargs: Any) -> "LanguageExtractor":
from sklearn.svm import SVC
# from sklearn.linear_model import LogisticRegression
classifier_file = os.path.join(model_dir, meta.get("classifier"))
if os.path.exists(classifier_file):
classifier = utils.json_unpickle(classifier_file)
return cls(meta, classifier)
return cls(meta)
def load(
cls,
meta: Dict[Text, Any],
model_dir: Text = None,
model_metadata: Metadata = None,
cached_component: Optional["CountVectorsFeaturizer"] = None,
**kwargs: Any
) -> "CountVectorsFeaturizer":
from sklearn.feature_extraction.text import CountVectorizer
file_name = meta.get("file")
featurizer_file = os.path.join(model_dir, file_name)
if os.path.exists(featurizer_file):
vocabulary = utils.json_unpickle(featurizer_file)
vectorizer = CountVectorizer()
vectorizer.vocabulary_ = vocabulary
return cls(meta, vectorizer)
else:
return cls(meta)
import spacy
import numpy as np
import logging.config
from rasa.nlu.utils import json_unpickle
from sklearn.preprocessing import LabelEncoder
from sklearn import metrics
logging.config.fileConfig('logging.conf')
logger = logging.getLogger(__name__)
# Set the paths
classifier_file = '<path_to_model>/nlu/component_3_SklearnIntentClassifier_classifier.pkl'
encoder_file = '<path_to_model>/nlu/component_3_SklearnIntentClassifier_encoder.pkl'
logger.info('Load Rasa classifier model')
classifier = json_unpickle(classifier_file)
classes = json_unpickle(encoder_file)
encoder = LabelEncoder()
encoder.classes_ = classes
def get_features(nlp, texts):
"""
:param nlp:
:param texts:
:return:
"""
features = []
for doc in nlp.pipe(texts, batch_size=32):
features.append(doc.vector)
