Just recently Comet<\/a> reached another milestone with its integration with Spark NLP. Now you can monitor your NLP experiments directly inside of Comet. Thanks to this integration, you can monitor your NLP pipeline directly in Comet, either during the training process or when it finishes.<\/p>\n Spark NLP<\/a> is a library for Natural Language Processing released by John Snow Labs. It is 100% open source and supports different programming languages, including Python, Java and Scala. Spark NLP is widely used in production, since it is natively integrated with Apache Spark<\/a>, a multi-language engine for large-scale analytics.<\/p>\n Spark NLP provides more than 50 features, including Tokenization, Named Entity Recognition, Sentiment Analysis, and much more.<\/p>\n To integrate Spark NLP with Comet, a In this article, I give an overview of the The Spark NLP library has been extended with a new subpackage, called This subpackage contains a class, named In order to track a Spark NLP experiment, firstly, I create a The Note the difference between You can always access to the raw experiment class defined in Comet through For the complete list of methods, you can read the documentation<\/a>.<\/p>\n In order to make Spark NLP run with Comet, these steps should be followed:<\/p>\n Firstly, I log in to Comet<\/a> and then I create a new Comet project. I add a new experiment and I copy the generated API key<\/strong>, as well as the project name<\/strong> and workspace<\/strong>.<\/p>\n Now, I can create a new CometLogger:<\/p>\n Did you know that Comet is free for students and start-ups? Get started today and learn how to make better models faster.<\/a><\/p><\/blockquote>\n<\/div>\n<\/div>\n<\/div>\n\n\n\n Now I can create a Spark NLP Pipeline as I usually do. Firstly, I must transform raw data to a Then, I can build my pipeline, which can include many steps, such as tokenization, sentence encoding and so on. In order to track the experiment in Comet, the pipeline should include an Among the other parameters, for the The following snippet of code shows how to set the path for the logs for a Now I\u2019m ready to connect the I should specify the previous method only if I want to monitor the model during the training phase. If I want to log the metrics when the training phase is complete, I should use the Everything is ready to start my experiment. Thus I can build and train the pipeline. The Spark NLP pipeline involves all the steps previously defined, and can be created as follows:<\/p>\n The three dots must be substituted by the other steps involved in the pipeline, such as tokenization, sentence splitting, and so on.<\/p>\n The pipeline can be trained with the training data:<\/p>\n Since I have configured the CometLogger<\/code> has been added to the Spark NLP library, making it possible to track experiments in a very simple way.<\/p>\nCometLogger<\/code> provided by Spark NLP as well as the steps needed to make a project run. For a complete example, you can refer to the article, entitled New Integration: Comet + Spark NLP<\/a> by Dhruv Nair, <\/a>as well as to this <\/span>Colab notebook<\/a>.<\/span><\/p>\nThe CometLogger<\/h1>\n
comet <\/code>and available under the logging package:<\/p>\nsparknlp.logging.comet<\/span><\/pre>\nCometLogger<\/code>, that provides the interface to the Comet platform.<\/p>\nCometLogger<\/code> by specifying the Comet configuration parameters, which include the workspace, the project name, and API key:<\/p>\nlogger = CometLogger<\/strong>(workspace<\/strong>='my-work-space', project_name<\/strong>='my-project-name', api_key<\/strong>='my-api-key')<\/span><\/pre>\nCometLogger<\/code> class provides different methods that permit to log metrics, parameters, and models, as well as monitor the steps of a training process. The main methods provided by the CometLogger class are below and the description of the method has been taken directly from the documentation:<\/p>\n\n
log_pipeline_parameters()<\/code>: Iterates over the different stages in a pyspark PipelineModel object and logs the parameters to Comet.<\/li>\nlog_visualization()<\/code>: Uploads a NER visualization from Spark NLP Display to Comet.<\/li>\nlog_metrics()<\/code>: Submits logs of an evaluation metrics.<\/li>\nlog_parameters()<\/code>: Logs a dictionary (or dictionary-like object) of multiple parameters<\/li>\nlog_completed_run()<\/code>: Submit logs of training metrics after a run has completed.<\/li>\nlog_asset()<\/code>: Uploads an asset to Comet.<\/li>\nmonitor()<\/code>: Monitors the training of the model and submits logs to Comet, given by an interval.<\/li>\n<\/ul>\nlog_completed_run()<\/code>and monitor()<\/code>: the first submits metrics when the run is complete, while the second monitors the metrics during the run.<\/p>\nlogger.experiment<\/code> field.<\/p>\nHow to Build a Project<\/h1>\n
\n
CometLogger<\/code><\/li>\nCometLogger<\/code> to the Spark NLP Annotator Approach<\/li>\nInitialize the CometLogger<\/h2>\n
![\"\"](\"https:\/\/miro.medium.com\/v2\/resize:fit:700\/1*i0ETAWz567vRH6AyH8cpjQ.jpeg\")
<\/figure>from<\/strong> sparknlp.logging.comet import CometLogger<\/strong><\/span>logger = CometLogger<\/strong>(workspace<\/strong>='my-work-space', project_name<\/strong>='my-project-name', api_key<\/strong>='my-api-key')<\/span><\/pre>\n<\/div>\n<\/div>\n<\/div>\n\n\n\nCreate the Spark NLP Pipeline<\/h2>\n
DocumentAssembler<\/code> where I specify the input and output columns, as well an optional cleanup mode. For example, I can use the shrink<\/code> mode, which removes new lines and tabs as well as merges multiple spaces and blank lines to a single space.<\/p>\nfrom sparknlp.base import DocumentAssembler<\/span>document = (\n DocumentAssembler<\/strong>()\n .setInputCol(\"text\")\n .setOutputCol(\"document\")\n .setCleanupMode(\"shrink\")\n)<\/span><\/pre>\nAnnotatorApproach<\/code> object, which can be, for example, a SentimentDLApproach<\/code> or a MultiClassifierDLApproach<\/code>.<\/p>\nAnnotatorApproach<\/code> object, I must set the path where to save logs through the setOutputLogsPath(PATH)<\/code> method. The output log will be read by the CometLogger<\/code> during the training process.<\/p>\nMultiClassifierDLApproach<\/code>:<\/p>\nfrom sparknlp.annotator import MultiClassifierDLApproach()<\/span>PATH<\/strong>=\/path\/to\/my\/directory<\/span>multiClassifier = (\n MultiClassifierDLApproach()\n # add other configuration parameters\n .setOutputLogsPath(PATH)\n<\/strong>)<\/span><\/pre>\nAttach the CometLogger to the Spark NLP Annotator Approach<\/h2>\n
CometLogger<\/code> to the AnnotatorApproach<\/code>, which is a MultiClassifierDLApproach<\/code> in my case. It is sufficient to specify the path to the log and the AnnotatorApproach<\/code> as follows:<\/p>\nlogger.monitor<\/strong>(PATH, multiClassifier)<\/span><\/pre>\nlog_completed_run()<\/code> method, as specified in the next sections.<\/p>\n<\/figure>
Train the Pipeline<\/h2>\n
pipeline = Pipeline(stages=[document, ... , multiClassifier])<\/span><\/pre>\nmodel = pipeline.fit<\/strong>(trainDataset)<\/span><\/pre>\nShow Results in Comet<\/h2>\n
CometLogger<\/code> to work with the monitor()<\/code> method, now I can open the Comet dashboard and look at the experiment results. The following figure shows an example of possible results:<\/p>\n
![\"\"](\"https:\/\/miro.medium.com\/v2\/resize:fit:700\/1*7uhooK1gQ2CKrQL1iKEgzw.png\")
<\/figure>