docs: def main(feature_folder, create_learning_curve=False):
      """main function of create_ffiles.py"""
  
      # Read the feature description file
      with open(os.path.join(feature_folder, "info.yml"), 'r') as ymlfile:
          feature_description = yaml.load(ymlfile)
  
      # Get preprocessed .pickle file from model description file
      path_to_data = os.path.join(utils.get_project_root(),
                                  feature_description['data-source'])
      if os.path.isdir(path_to_data):
          path_to_data = os.path.join(path_to_data, "data.pickle")
      target_paths = {'traindata': os.path.join(feature_folder,
                                                "traindata.hdf5"),
                      'validdata': os.path.join(feature_folder,
                                                "validdata.hdf5"),
                      'testdata': os.path.join(feature_folder,
                                               "testdata.hdf5")}
  
      feature_list = features.get_features(feature_description['features'])
      mult_queue = data_multiplication.get_data_multiplication_queue(
          feature_description['data-multiplication'])
  
      # Set everything up for the creation of the 3 hdf5 (test, validation,
      # training).
  
      os.chdir(feature_folder)
      logging.info("Start creation of hdf5-files...")
      logging.info("Get sets from '%s' ...", path_to_data)
      (training_set, validation_set, test_set, formula_id2index,
       preprocessing_queue, index2latex) = get_sets(path_to_data)
  
      training_set = training_set_multiplication(training_set, mult_queue)
      _create_index_formula_lookup(formula_id2index, feature_folder, index2latex)
  
      # Output data for documentation
      print("Classes (nr of symbols): %i" % len(formula_id2index))
      preprocessing.print_preprocessing_list(preprocessing_queue)
      features.print_featurelist(feature_list)
  
      logging.info("Start creating hdf5 files")
  
      # Get the dimension of the feature vector
      input_features = sum(map(lambda n: n.get_dimension(), feature_list))
  
      # Traindata has to come first because of feature normalization
      for dataset_name, dataset, is_traindata in \
          [("traindata", training_set, True),
           ("testdata", test_set, False),
           ("validdata", validation_set, False)]:
          t0 = time.time()
          logging.info("Start preparing '%s' ...", dataset_name)
          prepared, translation = prepare_dataset(dataset,
                                                  formula_id2index,
                                                  feature_list,
                                                  is_traindata)
          logging.info("%s length: %i", dataset_name, len(prepared))
          logging.info("start 'make_hdf5'x ...")
          make_hdf5(dataset_name,
                    input_features,
                    prepared,
                    os.path.join(feature_folder, target_paths[dataset_name]),
                    create_learning_curve)
  
          _create_translation_file(feature_folder,
                                   dataset_name,
                                   translation,
                                   formula_id2index)
  
          t1 = time.time() - t0
          logging.info("%s was written. Needed %0.2f seconds", dataset_name, t1)
          gc.collect()
      utils.create_run_logfile(feature_folder)