Recursive feature elimination

Recursive feature elimination | BigML.com

FREE

Recursive Feature Elimination

Details:

Created	Thu, 8 Oct 2026 15:02:07 +0000
Published	Thu, 8 Oct 2026 17:25:58 +0000

Description:

Script to select the n best features for modeling a given dataset, using a recursive algorithm:

Initialize the set S of selected features to the full initial dataset
Initialize c as the current number of features in S

While c is greater than n:

Create random forest with features of S
Obtain importances from random forest
Remove from S the least important feature
If test-dataset is defined, evaluate the random forest
Update c with current number of features

Find more info in readme

Tags:

BigMLer BigMLer_ThuOct0826_170206

URL:

https://bigml.com/user/whizzml/gallery/script/6ac7b06ffa54d0f159b44a7c

Script FREE

Source code

;; choosable-objective-ids
;;
;; List of ids of the fields in the dataset that can be chosen as objective
;; field.
;;
;; Inputs:
;;  fields: (map) Fields structure
;; Output: (list) list of field ids
(define (choosable-objective-ids fields)
  (let (field-val (lambda (fid k) (fields [fid k] false))
        objective-types ["categorical", "numeric"]
        pref? (lambda (k) (field-val k "preferred"))
        pred? (lambda (k) (member? (field-val k "optype") objective-types)))
    (filter (lambda (x) (and (pref? x) (pred? x))) (keys fields))))


;; safe-delete
;;
;; deletes resource ignoring errors
;; Inputs:
;;   id: (resource-id) resource to be deleted
;;
;; Output: (boolean) true if successful, false if not
;;
(define (safe-delete id)
  (try (delete id)
       (catch e
         (log-info  "Error deleting resource " id " ignored"))))

;; default-inputs
;;
;; Get the default set of input fields for this dataset (all preferred
;; fields minus the objective field).
;;
;; Inputs:
;;  dataset-id: (dataset-id) Dataset id
;;  obj-id: (string) id of the objective field
;;
;; Output: (list) Inputs field ids for this dataset
(define (default-inputs dataset-id obj-id)
  (let (fields ((fetch dataset-id) "fields")
        fids (keys fields))
    (filter (lambda (k) (and (fields [k "preferred"] true) (not (= obj-id k))))
            fids)))

;; random-forest
;; Create a random forest from the dataset
;;
;; Inputs:
;;   ds-id: (dataset-id) Dataset id
;;   obj: (string) Objective field id
;;   seed: (string) Seed used in the ensemble creation
;;   input-fields: (list) Specifies the fields to be considered to create
;;                        the ensemble.
;; Output: (ensemble-id) Random Forest id
(define (random-forest ds-id obj seed, input-fields)
  (create-and-wait-ensemble {"dataset" ds-id
                             "objective_field" obj
                             "randomize" true
                             "random_candidate_ratio" 0.33
                             "sample_rate" 0.8
                             "seed" seed
                             "input_fields" input-fields
                             "ensemble_sample" {"rate" 1
                                                "replacement" true
                                                "seed" seed}}))

;; recursive-feature-elimination
;;
;; Applies recursive feature elimination algorithm and returns a map with
;; the selected fields names, selected fields ids, and information about
;; each iteration
;;
;; Inputs:
;;   dataset-id: (dataset-id) Dataset id (for training)
;;   nfeatures: (number) Number of features that we want to obtain
;;   objective-id: (string) Objective field id
;;   test-ds-id: (dataset-id) id of the dataset used to
;;                     evaluate the model
;;   evaluation-metric: (string) Metric  used in the evaluation
;; Output: (map) Map with selected field names, selected field ids, and 
;;         iterations evaluation info (only if test-ds-id is present)
(define (recursive-feature-elimination dataset-id
                                       nfeatures
                                       objective-id
                                       test-ds-id
                                       evaluation-metric)
  (let (do-evaluation (not (empty? test-ds-id))
        obj-id (get-objective dataset-id objective-id)
        fields (resource-fields dataset-id)
        otype (fields [obj-id "optype"] false)
        input-ids (default-inputs dataset-id obj-id)
        evaluation-metric (choose-eval-metric evaluation-metric otype))
    (loop (selected input-ids
           evaluations []) 
        ;; Loop until we obtain the desired number of features
        (if (<= (count selected) nfeatures)
            (response selected 
                      (feature-names fields selected) 
                      evaluations 
                      do-evaluation)
            (let (_ (log-info "------- New iteration with "
			      (count selected)
			      " fields -------")
                  seed "BigML-RFE"
                  ;; Create random forest and obtain its importances
                  rf-id (random-forest dataset-id obj-id seed selected)
                  imps ((fetch rf-id) "importance")
		  ;; Check least important fields
		  removed-fields (check-no-imp imps selected)
		  removed-fields-names (feature-names fields removed-fields)

                  _ (log-info  "Removed-fields " removed-fields-names)
                  ;; Remove field from selected list
                  selected (keys (dissoc imps (removed-fields 0)))
                  ev (when do-evaluation 
                         (fetch (wait (create-evaluation test-ds-id rf-id))))
                  ev-result (when ev (ev ["result" "model" evaluation-metric]))
                  ;; Iterations evaluation info
                  iterations (when ev {"features" (count selected)
                                       "evaluation"  ev-result
                                       "last-removed" removed-fields-names})
                  evaluations (when ev (append evaluations iterations)))
              (recur selected
                     evaluations))))))

;; choose-eval-metric
;;
;; Sets the metric that will be use in evaluation
;;
;; Inputs:
;;   evaluation-metric: (string): Evaluation metric chosen by the user
;;                                (could be empty)
;;   otype: (string) Objective field type
;;
;; Outputs: (string) Chosen evaluation-metric 
(define (choose-eval-metric evaluation-metric otype)
  (cond (not (empty? evaluation-metric)) evaluation-metric
        (= "categorical" otype) "average_phi"
        "r_squared"))


;; check-no-imp
;;
;; Checks fields with no importance  
;; 
;; Inputs:
;;   imps: (map) List of field ids with their importances
;;   selected: (list) Selected fields ids
;; Output: (list) List of fields with no importance
;;  
(define (check-no-imp imps selected)
  ;; Obtain fields with importance 0
  ;; (they  doesnt appear in "importance")
  (let (no-imp-fields (filter (lambda (n)
				(not (member? n (keys imps))))
			      selected)
	;; Obtaining minimum field importance
        removed-field (min-key (lambda (x) (imps x)) (keys imps))
        removed-fields (cons removed-field no-imp-fields))
    removed-fields))

;; response
;;
;; Creates a human-readable response and cleans the created resources
;;
;; Inputs:
;;   selected: (list) Selected fields ids
;;   selected-names: (list) Selected fields names
;;   evaluations: (list) Result of the evaluations at each iteration
;;   do-evaluation: (boolean) Whether we performed evaluations
;;
;; Output: (map) Map with selected field names, selected field ids, and 
;;         iterations evaluation info (only if test-ds-id is present)
(define (response selected selected-names evaluations do-evaluation)
  ;; Remove created resources
  (map safe-delete (created-resources))
  (let( evaluations (if  do-evaluation
                         evaluations
                         ["test-ds-id needed to create evaluations"]))
    {"selected-fields" selected
     "selected-fields-names" selected-names
     "evaluations" evaluations}))


;; feature-names
;;
;; Returns feature names given ids
;;
;; Inputs:
;;   fieds: (map) Fields map (Output from resource-fields)
;;   ids: (list) List of field ids
;;
;; Output: (list) List with all the field names
;;
(define (feature-names fields ids)
  (map (lambda (id) (fields [id "name"])) ids))


;; get-objective-name
;;
;; Returns the name of the field used as objective field
;;
;; Inputs:
;;  dataset: (map) Dataset resource info
;;  objective-id: (string) id of the objective field
;;
;; Outputs: (string) Name of the objective field
;;
(define (get-objective-name dataset objective-id)
  (dataset ["fields" objective-id "name"] false))

;; get-objective
;;
;; Retrieves and checks whether the objective field of the given
;; dataset exists, raising an error otherwise.
;;
;; Inputs:
;;  ds-id: (dataset-id) Dataset id
;;  obj-id: (string) id of the objective field
;;
;; Outputs: (string) Same objective field id
;;
(define (get-objective ds-id obj-id)
  (let (obj-id (if (empty? obj-id)
                   (dataset-get-objective-id ds-id)
                   obj-id)
        fields (resource-fields ds-id)
        obj-id ((find-field fields obj-id) "id")
        otype (fields [obj-id "optype"] false))
    (when (not otype)
      (raise  "The dataset's doesn't exist"))
    obj-id))


;; output-features
;;
;; Result from recursive-feature-elimination procedure
;; Output: (map) Map with selected field names, selected field ids, and 
;;         iterations evaluation info (only if test-ds-id is present)
(define output-features
  (recursive-feature-elimination dataset-id 
                                 n 
                                 objective-id
                                 test-ds-id
                                 evaluation-metric))
;; output-dataset
;;
;; Creates new dataset with only the selected fields from the execution of
;; the recursive feature elimination algorithm
;; Output: (dataset) Dataset with the selected fields and the objective id
(define output-dataset
  (let (dataset (fetch dataset-id)
        obj-id (get-objective dataset-id objective-id)
        obj-name  (get-objective-name dataset obj-id))
    (create-and-wait-dataset {"origin_dataset" dataset-id
                              "input_fields"
                              (append (output-features "selected-fields") obj-name)
                              "name" (str (dataset "name")
                                          "[RFE-BestFeatures]")})))

Description

Inputs

Outputs

License: Creative Commons Zero V1.0
Script FREE

Recursive feature elimination | BigML.com

Sending Request...

COMPANY

PRODUCT

BUSINESS

TRAINING

GALLERY

License

Embed this Script in your web site

COMPANY

PRODUCT

BUSINESS

TRAINING

GALLERY