code: def texts_from_csv(
      train_filepath,
      text_column,
      label_columns=[],
      val_filepath=None,
      max_features=MAX_FEATURES,
      maxlen=MAXLEN,
      val_pct=0.1,
      ngram_range=1,
      preprocess_mode="standard",
      encoding=None,  # auto-detected
      lang=None,  # auto-detected
      sep=",",
      is_regression=False,
      random_state=None,
      verbose=1,
  ):
      """
      ```
      Loads text data from CSV or TSV file. Class labels are assumed to be
      one of the following formats:
          1. one-hot-encoded or multi-hot-encoded arrays representing classes:
                Example with label_columns=['positive', 'negative'] and text_column='text':
                  text|positive|negative
                  I like this movie.|1|0
                  I hated this movie.|0|1
              Classification will have a single one in each row: [[1,0,0], [0,1,0]]]
              Multi-label classification will have one more ones in each row: [[1,1,0], [0,1,1]]
          2. labels are in a single column of string or integer values representing classs labels
                 Example with label_columns=['label'] and text_column='text':
                   text|label
                   I like this movie.|positive
                   I hated this movie.|negative
         3. labels are a single column of numerical values for text regression
            NOTE: Must supply is_regression=True for labels to be treated as numerical targets
                   wine_description|wine_price
                   Exquisite wine!|100
                   Wine for budget shoppers|8
  
      Args:
          train_filepath(str): file path to training CSV
          text_column(str): name of column containing the text
          label_column(list): list of columns that are to be treated as labels
          val_filepath(string): file path to test CSV.  If not supplied,
                                 10% of documents in training CSV will be
                                 used for testing/validation.
          max_features(int): max num of words to consider in vocabulary
                             Note: This is only used for preprocess_mode='standard'.
          maxlen(int): each document can be of most <maxlen> words. 0 is used as padding ID.
          ngram_range(int): size of multi-word phrases to consider
                            e.g., 2 will consider both 1-word phrases and 2-word phrases
                                 limited by max_features
          val_pct(float): Proportion of training to use for validation.
                          Has no effect if val_filepath is supplied.
          preprocess_mode (str):  Either 'standard' (normal tokenization) or one of {'bert', 'distilbert'}
                                  tokenization and preprocessing for use with
                                  BERT/DistilBert text classification model.
          encoding (str):        character encoding to use. Auto-detected if None
          lang (str):            language.  Auto-detected if None.
          sep(str):              delimiter for CSV (comma is default)
          is_regression(bool):  If True, integer targets will be treated as numerical targets instead of class IDs
          random_state(int):      If integer is supplied, train/test split is reproducible.
                                  If None, train/test split will be random
          verbose (boolean): verbosity
      ```
      """
      if encoding is None:
          with open(train_filepath, "rb") as f:
              encoding = TU.detect_encoding(f.read())
              U.vprint(
                  "detected encoding: %s (if wrong, set manually)"
                  % (encoding),
                  verbose=verbose,
              )
  
      train_df = pd.read_csv(train_filepath, encoding=encoding, sep=sep)
      val_df = (
          pd.read_csv(val_filepath, encoding=encoding, sep=sep)
          if val_filepath is not None
          else None
      )
      return texts_from_df(
          train_df,
          text_column,
          label_columns=label_columns,
          val_df=val_df,
          max_features=max_features,
          maxlen=maxlen,
          val_pct=val_pct,
          ngram_range=ngram_range,
          preprocess_mode=preprocess_mode,
          lang=lang,
          is_regression=is_regression,
          random_state=random_state,
          verbose=verbose,
      )
  
file_path: ktrain/ktrain/text/data.py
imports: from ..None import utils
  from ..imports import *
  from .None import preprocessor
  from .None import textutils
label_desc: Use image node_id 2 for calling a global function with example usage: texts_from_csv(train_filepath, text_column, label_columns, val_filepath, max_features, maxlen, val_pct, ngram_range, preprocess_mode, encoding, lang, sep, is_regression, random_state, verbose) and returns: texts_from_df