question: TypeError: __init__() got an unexpected keyword argument 'row_log_interval'
context: Question:
  I am trying to run the EpicKitchen codes from https://github.com/epic-kitchens/C1-Action-Recognition-TSN-TRN-TSM
  I am getting this Typeerror may be related to older and new versions of lightining module and i was not able to resolve it.
  Error:
  Traceback (most recent call last):
  File "src/test.py", line 145, in 
  main(parser.parse_args())
  File "src/test.py", line 139, in main
  trainer = Trainer(**cfg.trainer, callbacks=[saver])
  File "/home/code-base/.intdoc/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/env_vars_connector.py", line 41, in overwrite_by_env_vars
  return fn(self, **kwargs)
  TypeError: init() got an unexpected keyword argument 'row_log_interval'
  Code:   test.py file
  from collections import defaultdict
  import argparse
  import logging
  import os
  import pickle
  from pathlib import Path
  import colorlog
  import torch
  import numpy as np
  from omegaconf import OmegaConf
  from pytorch_lightning import Callback, Trainer
  from typing import Any, Dict, List, Sequence, Union
  from systems import EpicActionRecogintionDataModule
  from systems import EpicActionRecognitionSystem
  
  parser = argparse.ArgumentParser(
      description="Test model", formatter_class=argparse.ArgumentDefaultsHelpFormatter
  )
  parser.add_argument("checkpoint", type=Path)
  parser.add_argument("results", type=Path)
  parser.add_argument("--split", choices=["val", "test"], default="test")
  parser.add_argument(
      "--n-frames",
      type=int,
      help="Overwrite number of frames to feed model, defaults to the "
      "data.test_frame_count or data.frame_count if the former is not present",
  )
  parser.add_argument(
      "--batch-size",
      type=int,
      help="Overwrite the batch size for loading data, defaults to learning.batch_size",
  )
  parser.add_argument(
      "--datadir",
      default=None,
      help="Overwrite data directory in checkpoint. Useful when testing a checkpoint "
      "trained on a different machine.",
  )
  
  LOG = logging.getLogger("test")
  class ResultsSaver(Callback):
      def __init__(self):
          super().__init__()
          self.results: Dict[str, Dict[str, List[Any]]] = dict()
      def on_test_batch_end(
          self, trainer, pl_module, outputs, batch, batch_idx, dataloader_idx
      ):
          self._store_batch_results("test", outputs)
  
      def _store_batch_results(
          self, dataset_name: str, batch_outputs: Dict[str, Sequence[Any]]
      ):
          if dataset_name not in self.results:
              self.results[dataset_name] = {k: [] for k in batch_outputs.keys()}
  
          for k, vs in batch_outputs.items():
              if isinstance(vs, torch.Tensor):
                  vs = vs.detach().cpu().numpy()
              self.results[dataset_name][k].extend(vs)
  
      def save_results(self, dataset_name: str, filepath: Union[str, Path]):
          filepath = Path(filepath)
          filepath.parent.mkdir(parents=True, exist_ok=True)
          results_dict = self.results[dataset_name]
          new_results_dict = {
              k: np.stack(vs)
              for k, vs in results_dict.items()
          }
  
          with open(filepath, "wb") as f:
              pickle.dump(new_results_dict, f)
  
  
  def main(args):
      logging.basicConfig(level=logging.INFO)
  
      handler = colorlog.StreamHandler()
      handler.setFormatter(
          colorlog.ColoredFormatter("%(log_color)s%(levelname)s:%(name)s:%(message)s")
      )
  
      logger = colorlog.getLogger("example")
      logger.addHandler(handler)
  
      ckpt = torch.load(args.checkpoint, map_location=lambda storage, loc: storage)
      # Publicly released checkpoints use dicts for longevity, so we need to wrap them
      # up in an OmegaConf object as this is what EpicActionRecognitionSystem expects.
      cfg = OmegaConf.create(ckpt["hyper_parameters"])
      OmegaConf.set_struct(cfg, False)  # allow writing arbitrary keys without raising
      # exceptions
      cfg.data._root_gulp_dir = os.getcwd()  # set default root gulp dir to prevent
      # exceptions on instantiating the EpicActionRecognitionSystem
  
      system = EpicActionRecognitionSystem(cfg)
      system.load_state_dict(ckpt["state_dict"])
      if not cfg.get("log_graph", True):
          # MTRN can't be traced due to the model stochasticity so causes a JIT tracer
          # error, we allow you to prevent the tracer from running to log the graph when
          # the summary writer is created
          try:
              delattr(system, "example_input_array")
          except AttributeError:
              pass
  
      if args.n_frames is not None:
          cfg.data.test_frame_count = args.n_frames
      if args.batch_size is not None:
          cfg.learning.batch_size = args.batch_size
      if args.datadir is not None:
          data_dir_key = f"{args.split}_gulp_dir"
          cfg.data[data_dir_key] = args.datadir
  
      # Since we don't support writing results when using DP or DDP
      LOG.info("Disabling DP/DDP")
      cfg.trainer.accelerator = None
  
      n_gpus = 1
      LOG.info(f"Overwriting number of GPUs to {n_gpus}")
      cfg.trainer.gpus = n_gpus
      cfg["test.results_path"] = str(args.results)
  
      data_module = EpicActionRecogintionDataModule(cfg)
      if args.split == "val":
          dataloader = data_module.val_dataloader()
      elif args.split == "test":
          dataloader = data_module.test_dataloader()
      else:
          raise ValueError(
              f"Split {args.split!r} is not a recognised dataset split to " f"test on."
          )
  
      saver = ResultsSaver()
      trainer = Trainer(**cfg.trainer, callbacks=[saver])
      trainer.test(system, test_dataloaders=dataloader)
      saver.save_results("test", args.results)
  if __name__ == "__main__":
      main(parser.parse_args())
  
  
  Versions:
  Python3.6, lightining-1.1.8, pytorch-1.7.1, Running on an linux machine
  I am new to this library, any help would be appreciated
  Thanks in advance
answer: TypeError: init() got an unexpected keyword argument 'row_log_interval'
  
  row_log_interval got deprecated and removed. You must have taken this from an old version of the docs. Use log_every_n_steps instead.