def train(self, data, **kwargs):
# type: (TrainingData) -> Interpreter
"""Trains the underlying pipeline using the provided training data."""
self.training_data = data
context = kwargs # type: Dict[Text, Any]
for component in self.pipeline:
updates = component.provide_context()
if updates:
context.update(updates)
# Before the training starts: check that all arguments are provided
if not self.skip_validation:
components.validate_arguments(self.pipeline, context)
# data gets modified internally during the training - hence the copy
working_data = copy.deepcopy(data)
for i, component in enumerate(self.pipeline):
logger.info("Starting to train component {}"
"".format(component.name))
component.prepare_partial_processing(self.pipeline[:i], context)
updates = component.train(working_data, self.config,
**context)
logger.info("Finished training component.")
if updates:
context.update(updates)
return Interpreter(self.pipeline, context)
def train(self, data):
# type: (TrainingData) -> Interpreter
"""Trains the underlying pipeline by using the provided training data."""
self.training_data = copy.deepcopy(data)
context = {} # type: Dict[Text, Any]
for component in self.pipeline:
updates = component.provide_context()
if updates:
context.update(updates)
# Before training the component classes, lets check if all arguments are provided
if not self.skip_validation:
components.validate_arguments(self.pipeline, context)
for component in self.pipeline:
logger.info("Starting to train component {}".format(
component.name))
updates = component.train(data, self.config, **context)
logger.info("Finished training component.")
if updates:
context.update(updates)
return Interpreter(self.pipeline, context)
def train(self, data: TrainingData, **kwargs: Any) -> 'Interpreter':
"""Trains the underlying pipeline using the provided training data."""
self.training_data = data
context = kwargs
for component in self.pipeline:
updates = component.provide_context()
if updates:
context.update(updates)
# Before the training starts: check that all arguments are provided
if not self.skip_validation:
components.validate_arguments(self.pipeline, context)
# data gets modified internally during the training - hence the copy
working_data = copy.deepcopy(data)
for i, component in enumerate(self.pipeline):
logger.info("Starting to train component {}"
"".format(component.name))
component.prepare_partial_processing(self.pipeline[:i], context)
updates = component.train(working_data, self.config, **context)
logger.info("Finished training component.")
if updates:
context.update(updates)
return Interpreter(self.pipeline, context)
def train(self, data):
# type: (TrainingData) -> Interpreter
"""Trains the underlying pipeline using the provided training data."""
self.training_data = data
context = {} # type: Dict[Text, Any]
for component in self.pipeline:
updates = component.provide_context()
if updates:
context.update(updates)
# Before the training starts: check that all arguments are provided
if not self.skip_validation:
components.validate_arguments(self.pipeline, context)
# data gets modified internally during the training - hence the copy
working_data = copy.deepcopy(data)
for i, component in enumerate(self.pipeline):
logger.info("Starting to train component {}".format(component.name))
#print('[>>>>>>>DEBUG] Type of component: %s' % type(component))
#print('[>>>>>>>DEBUG] Type of entity_examples: %s' % type(working_data.entity_examples))
component.prepare_partial_processing(self.pipeline[:i], context)
#print('[>>>>>>>DEBUG] Before Train: %s' % working_data.entity_examples[0].get('tokens'))
updates = component.train(working_data, self.config, **context)
#print('[>>>>>>>DEBUG] After Train: %s' % working_data.entity_examples[0].get('tokens'))
logger.info("Finished training component.")
if updates:
context.update(updates)
return Interpreter(self.pipeline, context)
def train(self, data):
# type: (TrainingData) -> Interpreter
"""Trains the underlying pipeline by using the provided training data."""
# Before training the component classes, lets check if all arguments are provided
if not self.skip_validation:
components.validate_arguments(self.pipeline, self.config)
self.training_data = data
context = {} # type: Dict[Text, Any]
for component in self.pipeline:
updates = component.pipeline_init()
if updates:
context.update(updates)
init_context = context.copy()
context["training_data"] = data
for component in self.pipeline:
args = components.fill_args(component.train_args(), context,
self.config.as_dict())
logger.info("Starting to train component {}".format(
component.name))
updates = component.train(*args)
logger.info("Finished training component.")
if updates:
context.update(updates)
return Interpreter(self.pipeline,
context=init_context,
config=self.config.as_dict())
def train(self, data):
# type: (TrainingData) -> Interpreter
"""Trains the underlying pipeline by using the provided training data."""
self.training_data = data
context = {} # type: Dict[Text, Any]
for component in self.pipeline:
updates = component.provide_context()
if updates:
context.update(updates)
# Before training the component classes, lets check if all arguments are provided
if not self.skip_validation:
components.validate_arguments(self.pipeline, context)
working_data = copy.deepcopy(
data
) # data gets modified internally during the training - hence the copy
for i, component in enumerate(self.pipeline):
logger.info("Starting to train component {}".format(
component.name))
component.prepare_partial_processing(self.pipeline[:i], context)
updates = component.train(working_data, self.config, **context)
logger.info("Finished training component.")
if updates:
context.update(updates)
return Interpreter(self.pipeline, context)
def train(self, data):
# type: (TrainingData) -> Interpreter
"""Trains the underlying pipeline by using the provided training data."""
# Before training the component classes, lets check if all arguments are provided
if not self.skip_validation:
components.validate_arguments(self.pipeline, self.config)
self.training_data = data
context = {} # type: Dict[Text, Any]
for component in self.pipeline:
updates = component.pipeline_init()
if updates:
context.update(updates)
init_context = context.copy()
context["training_data"] = data
for component in self.pipeline:
args = components.fill_args(component.train_args(), context, self.config.as_dict())
logger.info("Starting to train component {}".format(component.name))
updates = component.train(*args)
logger.info("Finished training component.")
if updates:
context.update(updates)
return Interpreter(self.pipeline, context=init_context, config=self.config.as_dict())
def train(self, data):
# type: (TrainingData) -> Interpreter
"""Trains the underlying pipeline by using the provided training data."""
self.training_data = copy.deepcopy(data)
context = {} # type: Dict[Text, Any]
for component in self.pipeline:
updates = component.provide_context()
if updates:
context.update(updates)
# Before training the component classes, lets check if all arguments are provided
if not self.skip_validation:
components.validate_arguments(self.pipeline, context)
for i, component in enumerate(self.pipeline):
logger.info("Starting to train component {}".format(component.name))
component.prepare_partial_processing(self.pipeline[:i], context)
updates = component.train(data, self.config, **context)
logger.info("Finished training component.")
if updates:
context.update(updates)
return Interpreter(self.pipeline, context)
