https://koaning.github.io/human-learn/#interactive-drawings

[ ] [ ] Skip to content
logo
Human-Learn Index
[                    ] 
Type to start searching

 
GitHub

  * Home
  * Guides
  * Api
  * Examples

logo Human-Learn
 
GitHub

  * [*] Home Home
      + [ ] Index Index Table of contents
          o Project Goal
          o Install
          o Guides
              # Tutorial
              # Getting Started
          o Features
              # Interactive Drawings
              # Classification Models
                  @ FunctionClassifier
                  @ InteractiveClassifier
              # Regression Models
                  @ FunctionRegressor
              # Outlier Detection Models
                  @ FunctionOutlierDetector
                  @ InteractiveOutlierDetector
              # Preprocessing Models
                  @ PipeTransformer
                  @ InteractivePreprocessor
              # Datasets
                  @ Titanic
                  @ Fish
  * [ ] Guides Guides
      + Function as a Model
      + Human Preprocessing
      + Drawing as a Model
      + Outliers and Comfort
      + Drawing Features
  * [ ] Api Api
      + [ ] Models Models
          o Classification
          o Regression
          o Outlier
          o Preprocessing
      + [ ] Interactive Interactive
          o Charts
      + [ ] Utility Utility
          o Common
          o Datasets
  * [ ] Examples Examples
      + Examples
      + FAQ

Table of contents

  * Project Goal
  * Install
  * Guides
      + Tutorial
      + Getting Started
  * Features
      + Interactive Drawings
      + Classification Models
          o FunctionClassifier
          o InteractiveClassifier
      + Regression Models
          o FunctionRegressor
      + Outlier Detection Models
          o FunctionOutlierDetector
          o InteractiveOutlierDetector
      + Preprocessing Models
          o PipeTransformer
          o InteractivePreprocessor
      + Datasets
          o Titanic
          o Fish



[logo]

Human LearnP

    Machine Learning models should play by the rules, literally.

Project GoalP

Back in the old days, it was common to write rule-based systems.
Systems that do;

[rules]

Nowadays, it's much more fashionable to use machine learning instead.
Something like;

[ml]

We started wondering if we might have lost something in this
transition. Sure, machine learning covers a lot of ground but it is
also capable of making bad decision. We've also reached a stage of
hype that folks forget that many classification problems can be
handled by natural intelligence too.

This package contains scikit-learn compatible tools that should make
it easier to construct and benchmark rule based systems that are
designed by humans. You can also use it in combination with ML
models.

InstallP

You can install this tool via pip.

python -m pip install human-learn

GuidesP

TutorialP

    There is a full course on this tool available on calmcode.io.
    This is the first video.

Getting StartedP

To help you get started we've written some helpful getting started
guides.

 1. Functions as a Model
 2. Human Preprocessing
 3. Drawing as a Model
 4. Outliers and Comfort
 5. Drawing Features

You can also check out the API documentation here.

FeaturesP

This library hosts a couple of models that you can play with.

Interactive DrawingsP

This tool allows you to draw over your datasets. These drawings can
later be converted to models or to preprocessing tools.

[draw-gif]

Classification ModelsP

FunctionClassifierP

This allows you to define a function that can make classification
predictions. It's constructed in such a way that you can use the
arguments of the function as a parameter that you can benchmark in a
grid-search.

InteractiveClassifierP

This allows you to draw decision boundaries in interactive charts to
create a model. You can create charts interactively in the notebook
and export it as a scikit-learn compatible model.

Regression ModelsP

FunctionRegressorP

This allows you to define a function that can make regression
predictions. It's constructed in such a way that you can use the
arguments of the function as a parameter that you can benchmark in a
grid-search.

Outlier Detection ModelsP

FunctionOutlierDetectorP

This allows you to define a function that can declare outliers. It's
constructed in such a way that you can use the arguments of the
function as a parameter that you can benchmark in a grid-search.

InteractiveOutlierDetectorP

This allows you to draw decision boundaries in interactive charts to
create a model. If a point falls outside of these boundaries we might
be able to declare it an outlier. There's a threshold parameter for
how strict you might want to be.

Preprocessing ModelsP

PipeTransformerP

This allows you to define a function that can make handle
preprocessing. It's constructed in such a way that you can use the
arguments of the function as a parameter that you can benchmark in a
grid-search. This is especially powerful in combination with the
pandas .pipe method. If you're unfamiliar with this amazing feature,
you may appreciate this tutorial.

InteractivePreprocessorP

This allows you to draw features that you'd like to add to your
dataset or your machine learning pipeline. You can use it via tfm.fit
(df).transform(df) and df.pipe(tfm).

DatasetsP

TitanicP

This library hosts the popular titanic survivor dataset for demo
purposes. The goal of this dataset is to predict who might have
survived the titanic disaster.

FishP

The fish market dataset is also hosted in this library. The goal of
this dataset is to predict the weight of fish. However, it can also
be turned into a classification problem by predicting the species.

 
Next Function as a Model
Copyright (c) 2020 Maintained by Vincent.
powered by MkDocs and Material for MkDocs