End of training

README.md

@@ -0,0 +1,15 @@
+
+---
+base_model: stabilityai/stable-diffusion-xl-base-1.0
+instance_prompt: a photo of sks dog
+tags:
+- text-to-image
+- diffusers
+- autotrain
+inference: true
+---
+    
+# DreamBooth trained by AutoTrain
+
+Test enoder was not trained.
+

autotrain-advanced/.dockerignore

@@ -0,0 +1,9 @@
+build/
+dist/
+logs/
+output/
+output2/
+test/
+test.py
+.DS_Store
+.vscode/

autotrain-advanced/.github/workflows/build_documentation.yml

@@ -0,0 +1,19 @@
+name: Build documentation
+
+on:
+  push:
+    branches:
+      - main
+      - doc-builder*
+      - v*-release
+
+jobs:
+   build:
+    uses: huggingface/doc-builder/.github/workflows/build_main_documentation.yml@main
+    with:
+      commit_sha: ${{ github.sha }}
+      package: autotrain-advanced
+      package_name: autotrain
+    secrets:
+      token: ${{ secrets.HUGGINGFACE_PUSH }}
+      hf_token: ${{ secrets.HF_DOC_BUILD_PUSH }}

autotrain-advanced/.github/workflows/build_pr_documentation.yml

@@ -0,0 +1,17 @@
+name: Build PR Documentation
+
+on:
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    uses: huggingface/doc-builder/.github/workflows/build_pr_documentation.yml@main
+    with:
+      commit_sha: ${{ github.event.pull_request.head.sha }}
+      pr_number: ${{ github.event.number }}
+      package: autotrain-advanced
+      package_name: autotrain

autotrain-advanced/.github/workflows/code_quality.yml

@@ -0,0 +1,30 @@
+name: Code quality
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+  release:
+    types:
+      - created
+
+jobs:
+  check_code_quality:
+    name: Check code quality
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.9
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.9
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install flake8 black isort
+    - name: Make quality
+      run: |
+        make quality

autotrain-advanced/.github/workflows/delete_doc_comment.yml

@@ -0,0 +1,13 @@
+name: Delete doc comment
+
+on:
+  workflow_run:
+    workflows: ["Delete doc comment trigger"]
+    types:
+      - completed
+
+jobs:
+  delete:
+    uses: huggingface/doc-builder/.github/workflows/delete_doc_comment.yml@main
+    secrets:
+      comment_bot_token: ${{ secrets.COMMENT_BOT_TOKEN }}

autotrain-advanced/.github/workflows/delete_doc_comment_trigger.yml

@@ -0,0 +1,12 @@
+name: Delete doc comment trigger
+
+on:
+  pull_request:
+    types: [ closed ]
+
+
+jobs:
+  delete:
+    uses: huggingface/doc-builder/.github/workflows/delete_doc_comment_trigger.yml@main
+    with:
+      pr_number: ${{ github.event.number }}

autotrain-advanced/.github/workflows/tests.yml

@@ -0,0 +1,30 @@
+name: Tests
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+  release:
+    types:
+      - created
+
+jobs:
+  tests:
+    name: Run unit tests
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.9
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.9
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install .[dev]
+    - name: Make test
+      run: |
+        make test

autotrain-advanced/.github/workflows/upload_pr_documentation.yml

@@ -0,0 +1,16 @@
+name: Upload PR Documentation
+
+on:
+  workflow_run:
+    workflows: ["Build PR Documentation"]
+    types:
+      - completed
+
+jobs:
+  build:
+    uses: huggingface/doc-builder/.github/workflows/upload_pr_documentation.yml@main
+    with:
+      package_name: autotrain
+    secrets:
+      hf_token: ${{ secrets.HF_DOC_BUILD_PUSH }}
+      comment_bot_token: ${{ secrets.COMMENT_BOT_TOKEN }}

autotrain-advanced/.gitignore

@@ -0,0 +1,138 @@
+# Local stuff
+.DS_Store
+.vscode/
+test/
+test.py
+output/
+output2/
+logs/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

autotrain-advanced/Dockerfile

@@ -0,0 +1,65 @@
+FROM nvidia/cuda:11.8.0-cudnn8-devel-ubuntu20.04
+
+ENV DEBIAN_FRONTEND=noninteractive \
+    TZ=UTC
+
+ENV PATH="${HOME}/miniconda3/bin:${PATH}"
+ARG PATH="${HOME}/miniconda3/bin:${PATH}"
+
+RUN mkdir -p /tmp/model
+RUN chown -R 1000:1000 /tmp/model
+RUN mkdir -p /tmp/data
+RUN chown -R 1000:1000 /tmp/data
+
+RUN apt-get update &&  \
+    apt-get upgrade -y &&  \
+    apt-get install -y \
+    build-essential \
+    cmake \
+    curl \
+    ca-certificates \
+    gcc \
+    git \
+    locales \
+    net-tools \
+    wget \
+    libpq-dev \
+    libsndfile1-dev \
+    git \
+    git-lfs \
+    libgl1 \
+    && rm -rf /var/lib/apt/lists/*
+
+
+RUN curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | bash && \
+    git lfs install
+
+WORKDIR /app
+RUN mkdir -p /app/.cache
+ENV HF_HOME="/app/.cache"
+RUN chown -R 1000:1000 /app
+USER 1000
+ENV HOME=/app
+
+ENV PYTHONPATH=$HOME/app \
+    PYTHONUNBUFFERED=1 \
+    GRADIO_ALLOW_FLAGGING=never \
+    GRADIO_NUM_PORTS=1 \
+    GRADIO_SERVER_NAME=0.0.0.0 \
+    SYSTEM=spaces
+
+
+RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh \
+    && sh Miniconda3-latest-Linux-x86_64.sh -b -p /app/miniconda \
+    && rm -f Miniconda3-latest-Linux-x86_64.sh
+ENV PATH /app/miniconda/bin:$PATH
+
+RUN conda create -p /app/env -y python=3.9
+
+SHELL ["conda", "run","--no-capture-output", "-p","/app/env", "/bin/bash", "-c"]
+
+RUN conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia
+RUN pip install git+https://github.com/huggingface/peft.git
+COPY --chown=1000:1000 . /app/
+
+RUN pip install -e .

autotrain-advanced/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

autotrain-advanced/Makefile

@@ -0,0 +1,28 @@
+.PHONY: quality style test
+
+# Check that source code meets quality standards
+
+quality:
+	black --check --line-length 119 --target-version py38 .
+	isort --check-only .
+	flake8 --max-line-length 119
+
+# Format source code automatically
+
+style:
+	black --line-length 119 --target-version py38 .
+	isort .
+
+test:
+	pytest -sv ./src/
+
+docker:
+	docker build -t autotrain-advanced:latest .
+	docker tag autotrain-advanced:latest huggingface/autotrain-advanced:latest
+	docker push huggingface/autotrain-advanced:latest
+
+pip:
+	rm -rf build/
+	rm -rf dist/
+	python setup.py sdist bdist_wheel
+	twine upload dist/* --verbose

autotrain-advanced/README.md

@@ -0,0 +1,13 @@
+# 🤗 AutoTrain Advanced
+
+AutoTrain Advanced: faster and easier training and deployments of state-of-the-art machine learning models
+
+## Installation
+
+You can Install AutoTrain-Advanced python package via PIP. Please note you will need python >= 3.8 for AutoTrain Advanced to work properly.
+
+    pip install autotrain-advanced
+    
+Please make sure that you have git lfs installed. Check out the instructions here: https://github.com/git-lfs/git-lfs/wiki/Installation
+
+## Coming Soon!

autotrain-advanced/docs/source/_toctree.yml

@@ -0,0 +1,28 @@
+- sections: 
+  - local: index
+    title: 🤗 AutoTrain
+  - local: getting_started
+    title: Installation
+  - local: cost
+    title: How much does it cost?
+  - local: support
+    title: Get help and support
+  title: Get started
+- sections:
+  - local: model_choice
+    title: Model Selection
+  - local: param_choice
+    title: Parameter Selection
+  title: Selecting Models and Parameters
+- sections: 
+  - local: text_classification
+    title: Text Classification
+  - local: llm_finetuning
+    title: LLM Finetuning
+  title: Text Tasks
+- sections:
+  - local: image_classification
+    title: Image Classification
+  - local: dreambooth
+    title: DreamBooth
+  title: Image Tasks

autotrain-advanced/docs/source/cost.mdx

@@ -0,0 +1,17 @@
+# How much does it cost?
+
+AutoTrain provides you with best models which are deployable with just a few clicks.
+Unlike other services, we don't own your models. Once the training is done, you can download them and use them anywhere you want.
+
+Before you start training, you can see the estimated cost of training.
+
+Free tier is available for everyone. For a limited number of samples, you can train your models for free!
+If your dataset is larger, you will be presented with the estimated cost of training.
+Training will begin only after you confirm the payment.
+
+Please note that in order to use non-free tier AutoTrain, you need to have a valid payment method on file.
+You can add your payment method in the [billing](https://huggingface.co/settings/billing) section.
+
+Estimated cost will be displayed in the UI as follows:
+
+![cost](https://raw.githubusercontent.com/huggingface/autotrain-advanced/main/static/cost.png)

autotrain-advanced/docs/source/dreambooth.mdx

@@ -0,0 +1,18 @@
+# DreamBooth
+
+DreamBooth is a method to personalize text-to-image models like Stable Diffusion given just a few (3-5) images of a subject. It allows the model to generate contextualized images of the subject in different scenes, poses, and views.
+
+![DreamBooth Teaser](https://raw.githubusercontent.com/huggingface/autotrain-advanced/main/static/dreambooth1.jpeg)
+
+## Data Preparation
+
+The data format for DreamBooth training is simple. All you need is images of a concept (e.g. a person) and a concept token.
+
+![DreamBooth Training](https://raw.githubusercontent.com/huggingface/autotrain-advanced/main/static/dreambooth2.png)
+
+To train a dreambooth model, please select an appropriate model from the hub. You can also let AutoTrain decide the best model for you!
+When choosing a model from the hub, please make sure you select the correct image size compatible with the model.
+
+Same as other tasks, you also have an option to select the parameters manually or automatically using AutoTrain.
+
+For each concept that you want to train, you must have a concept token and concept images. Concept token is nothing but a word that is not available in the dictionary.

autotrain-advanced/docs/source/getting_started.mdx

@@ -0,0 +1,29 @@
+# Installation
+
+There is no installation required! AutoTrain Advanced runs on Hugging Face Spaces. All you need to do is create a new space with the AutoTrain Advanced template: https://huggingface.co/new-space?template=autotrain-projects/autotrain-advanced. Please make sure you keep the space private.
+
+![autotrain-space-template](https://raw.githubusercontent.com/huggingface/autotrain-advanced/main/static/space_template_1.png)
+
+Once you have selected Docker > AutoTrain template. You can click on "Create Space" and you will be redirected to your new space.
+
+![autotrain-space-template](https://raw.githubusercontent.com/huggingface/autotrain-advanced/main/static/space_template_2.png)
+
+Once the space is build, you will see this screen:
+
+![autotrain-space-template](https://raw.githubusercontent.com/huggingface/autotrain-advanced/main/static/space_template_3.png)
+
+You can find your token at https://huggingface.co/settings/token.
+
+Note: you have to add HF_TOKEN as an environment variable in your space settings. To do so, click on the "Settings" button in the top right corner of your space, then click on "New Secret" in the "Repository Secrets" section and add a new variable with the name HF_TOKEN and your token as the value as shown below:
+
+![autotrain-space-template](https://raw.githubusercontent.com/huggingface/autotrain-advanced/main/static/space_template_4.png)
+
+# Updating AutoTrain Advanced to Latest Version
+
+We are constantly adding new features and tasks to AutoTrain Advanced. Its always a good idea to update your space to the latest version before starting a new project. An up-to-date version of AutoTrain Advanced will have the latest tasks, features and bug fixes! Updating is as easy as clicking on the "Factory reboot" button in the setting page of your space.
+
+![autotrain-space-template](https://raw.githubusercontent.com/huggingface/autotrain-advanced/main/static/space_template_5.png)
+
+Please note that "restarting" a space will not update it to the latest version. You need to "Factory reboot" the space to update it to the latest version.
+
+And now we are all set and we can start with our first project!

autotrain-advanced/docs/source/image_classification.mdx

@@ -0,0 +1,40 @@
+# Image Classification
+
+Image classification is a supervised learning problem: define a set of target classes (objects to identify in images), and train a model to recognize them using labeled example photos.
+Using AutoTrain, its super-easy to train a state-of-the-art image classification model. Just upload a set of images, and AutoTrain will automatically train a model to classify them.
+
+## Data Preparation
+
+The data for image classification must be in zip format, with each class in a separate subfolder. For example, if you want to classify cats and dogs, your zip file should look like this:
+
+```
+cats_and_dogs.zip
+├── cats
+│   ├── cat.1.jpg
+│   ├── cat.2.jpg
+│   ├── cat.3.jpg
+│   └── ...
+└── dogs
+    ├── dog.1.jpg
+    ├── dog.2.jpg
+    ├── dog.3.jpg
+    └── ...
+```
+
+Some points to keep in mind:
+
+- The zip file should contain multiple folders (the classes), each folder should contain images of a single class.
+- The name of the folder should be the name of the class.
+- The images must be jpeg, jpg or png.
+- There should be at least 5 images per class.
+- There should not be any other files in the zip file.
+- There should not be any other folders inside the zip folder.
+
+When train.zip is decompressed, it creates two folders: cats and dogs. these are the two categories for classification. The images for both categories are in their respective folders. You can have as many categories as you want.
+
+## Training
+
+Once you have your data ready, you can upload it to AutoTrain and select model and parameters.
+If the estimate looks good, click on `Create Project` button to start training.
+
+![Image Classification](https://raw.githubusercontent.com/huggingface/autotrain-advanced/main/static/image_classification_1.png)

autotrain-advanced/docs/source/index.mdx

@@ -0,0 +1,34 @@
+# AutoTrain
+
+🤗 AutoTrain is a no-code tool for training state-of-the-art models for Natural Language Processing (NLP) tasks, for Computer Vision (CV) tasks, and for Speech tasks and even for Tabular tasks. It is built on top of the awesome tools developed by the Hugging Face team, and it is designed to be easy to use.
+
+## Who should use AutoTrain?
+
+AutoTrain is for anyone who wants to train a state-of-the-art model for a NLP, CV, Speech or Tabular task, but doesn't want to spend time on the technical details of training a model. AutoTrain is also for anyone who wants to train a model for a custom dataset, but doesn't want to spend time on the technical details of training a model. Our goal is to make it easy for anyone to train a state-of-the-art model for any task and our focus is not just data scientists or machine learning engineers, but also non-technical users.
+
+## How to use AutoTrain?
+
+We offer several ways to use AutoTrain:
+
+- No code users with large number of data samples can use `AutoTrain Advanced` by creating a new space with AutoTrain Docker image: https://huggingface.co/new-space?template=autotrain-projects/autotrain-advanced. Please make sure you keep the space private.
+
+- No code users with small number of data samples can use AutoTrain using the UI located at: https://ui.autotrain.huggingface.co/projects. Please note that this UI won't be updated with new tasks and features as frequently as AutoTrain Advanced.
+
+- Developers can access and build on top of AutoTrain using python api or run AutoTrain Advanced UI locally. The python api is available in the `autotrain-advanced` package. You can install it using pip:
+
+```bash
+pip install autotrain-advanced
+```
+
+- Developers can also use the AutoTrain API directly. The API is available at: https://api.autotrain.huggingface.co/docs
+
+
+## What is AutoTrain Advanced?
+
+AutoTrain Advanced processes your data either in a Hugging Face Space or locally (if installed locally using pip). This saves one time since the data processing is not done by the AutoTrain backend, resulting in your job not being queued. AutoTrain Advanced also allows you to use your own hardware (better CPU and RAM) to process the data, thus, making the data processing faster.
+
+Using AutoTrain Advanced, advanced users can also control the hyperparameters used for training per job. This allows you to train multiple models with different hyperparameters and compare the results.
+
+Everything else is the same as AutoTrain. You can use AutoTrain Advanced to train models for NLP, CV, Speech and Tabular tasks.
+
+We recommend using [AutoTrain Advanced](https://huggingface.co/new-space?template=autotrain-projects/autotrain-advanced) since it is faster, more flexible and will have more supported tasks and features in the future.

autotrain-advanced/docs/source/llm_finetuning.mdx

@@ -0,0 +1,43 @@
+# LLM Finetuning
+
+With AutoTrain, you can easily finetune large language models (LLMs) on your own data!
+
+AutoTrain supports the following types of LLM finetuning:
+
+- Causal Language Modeling (CLM)
+- Masked Language Modeling (MLM) [Coming Soon]
+
+For LLM finetuning, only Hugging Face Hub model choice is available. 
+User needs to select a model from Hugging Face Hub, that they want to finetune and select the parameters on their own (Manual Parameter Selection),
+or use AutoTrain's Auto Parameter Selection to automatically select the best parameters for the task.
+
+## Data Preparation
+
+LLM finetuning accepts data in CSV format.
+There are two modes for LLM finetuning: `generic` and `chat`.
+An example dataset with both formats in the same dataset can be found here: https://huggingface.co/datasets/tatsu-lab/alpaca
+
+### Generic
+
+In generic mode, only one column is required: `text`.
+The user can take care of how the data is formatted for the task.
+A sample instance for this format is presented below:
+
+```
+Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request. 
+
+### Instruction: Evaluate this sentence for spelling and grammar mistakes 
+
+### Input: He finnished his meal and left the resturant 
+
+### Response: He finished his meal and left the restaurant.
+```
+
+![Generic LLM Finetuning](https://raw.githubusercontent.com/huggingface/autotrain-advanced/main/static/llm_1.png)
+
+Please note that above is the format for instruction finetuning. But in the `generic` mode, you can also finetune on any other format as you want. The data can be changed according to the requirements.
+
+
+## Training
+
+Once you have your data ready and estimate verified, you can start training your model by clicking the "Create Project" button.

autotrain-advanced/docs/source/model_choice.mdx

@@ -0,0 +1,24 @@
+# Model Choice
+
+AutoTrain can automagically select the best models for your task! However, you are also
+allowed to choose the models you want to use. You can choose the most appropriate models
+from the Hugging Face Hub.
+
+![autotrain-model-choice](https://raw.githubusercontent.com/huggingface/autotrain-advanced/main/static/model_choice_1.png)
+
+## AutoTrain Model Choice
+
+To let AutoTrain choose the best models for your task, you can use the "AutoTrain" 
+in the "Model Choice" section. Once you choose AutoTrain mode, you no longer need to worry about model and parameter selection.
+AutoTrain will automatically select the best models (and parameters) for your task.
+
+## Manual Model Choice
+
+To choose the models manually, you can use the "HuggingFace Hub" in the "Model Choice" section.
+For example, if you want to use if you are training a text classification task and want to choose Deberta V3 Base for your task 
+from https://huggingface.co/microsoft/deberta-v3-base,
+You can choose "HuggingFace Hub" and then write the model name: `microsoft/deberta-v3-base` in the model name field.
+
+![hub-model-choice](https://raw.githubusercontent.com/huggingface/autotrain-advanced/main/static/hub_model_choice.png)
+
+Please note that if you are selecting a hub model, you should make sure that it is compatible with your task, otherwise the training will fail.

autotrain-advanced/docs/source/param_choice.mdx

@@ -0,0 +1,25 @@
+# Parameter Choice
+
+Just like model choice, you can choose the parameters for your job in two ways: AutoTrain and Manual.
+
+## AutoTrain Mode
+
+In the AutoTrain mode, the parameters for your task-model pair will be chosen automagically.
+If you choose "AutoTrain" as model choice, you get the AutoTrain mode as the only option.
+If you choose "HuggingFace Hub" as model choice, you get the the option to choose between AutoTrain and Manual mode for parameter choice.
+
+An example of AutoTrain mode for a text classification task is shown below:
+
+![AutoTrain Parameter Choice](https://raw.githubusercontent.com/huggingface/autotrain-advanced/main/static/param_choice_1.png)
+
+For most of the tasks in AutoTrain parameter selection mode, you will get "Number of Models" as the only parameter to choose. Some tasks like test-classification might ask you about the language of the dataset.
+The more the number of models, the better the final results might be but it might be more expensive too!
+
+## Manual Mode
+
+Manual model can be used only when you choose "HuggingFace Hub" as model choice. In this mode, you can choose the parameters for your task-model pair manually.
+An example of Manual mode for a text classification task is shown below:
+
+![Manual Parameter Choice](https://raw.githubusercontent.com/huggingface/autotrain-advanced/main/static/param_choice_2.png)
+
+In the manual mode, you have to add the jobs on your own. So, carefully select your parameters, click on "Add Job" and 💥.

autotrain-advanced/docs/source/support.mdx

@@ -0,0 +1,12 @@
+# Help and Support
+
+To get help and support for autotrain, there are 3 ways:
+
+- [Create an issue](https://github.com/huggingface/autotrain-advanced/issues/new) in AutoTrain Advanced GitHub repository.
+
+- [Ask in the Hugging Face Forum](https://discuss.huggingface.co/c/autotrain/16).
+
+- [Email us](mailto:autotrain@hf.co) directly.
+
+
+Please don't forget to mention your username and project name if you have a specific question about your project.

autotrain-advanced/docs/source/text_classification.mdx

@@ -0,0 +1,60 @@
+# Text Classification
+
+Training a text classification model with AutoTrain is super-easy! Get your data ready in
+proper format and then with just a few clicks, your state-of-the-art model will be ready to
+be used in production.
+
+## Data Format
+
+Let's train a model for classifying the sentiment of a movie review. The data should be
+in the following CSV format:
+
+```csv
+review,sentiment
+"this movie is great",positive
+"this movie is bad",negative
+.
+.
+.
+```
+
+As you can see, we have two columns in the CSV file. One column is the text and the other
+is the label. The label can be any string. In this example, we have two labels: `positive`
+and `negative`. You can have as many labels as you want.
+
+If your CSV is huge, you can divide it into multiple CSV files and upload them separately.
+Please make sure that the column names are the same in all CSV files.
+
+One way to divide the CSV file using pandas is as follows:
+
+```python
+import pandas as pd
+
+# Set the chunk size
+chunk_size = 1000
+i = 1
+
+# Open the CSV file and read it in chunks
+for chunk in pd.read_csv('example.csv', chunksize=chunk_size):
+    # Save each chunk to a new file
+    chunk.to_csv(f'chunk_{i}.csv', index=False)
+    i += 1
+```
+
+Once the data has been uploaded, you have to select the proper column mapping
+
+## Column Mapping
+
+![Column Mapping](https://raw.githubusercontent.com/huggingface/autotrain-advanced/main/static/text_classification_1.png)
+
+In our example, the text column is called `review` and the label column is called `sentiment`.
+Thus, we have to select `review` for the text column and `sentiment` for the label column.
+Please note that, if column mapping is not done correctly, the training will fail.
+
+
+## Training
+
+Once you have uploaded the data, selected the column mapping, and set the hyperparameters (AutoTrain or Manual mode), you can start the training.
+To start the training, please confirm the estimated cost and click on the `Create Project` button.
+
+

autotrain-advanced/examples/text_classification_binary.py

@@ -0,0 +1,77 @@
+import os
+from uuid import uuid4
+
+from datasets import load_dataset
+
+from autotrain.dataset import AutoTrainDataset
+from autotrain.project import Project
+
+
+RANDOM_ID = str(uuid4())
+DATASET = "imdb"
+PROJECT_NAME = f"imdb_{RANDOM_ID}"
+TASK = "text_binary_classification"
+MODEL = "bert-base-uncased"
+
+USERNAME = os.environ["AUTOTRAIN_USERNAME"]
+TOKEN = os.environ["HF_TOKEN"]
+
+
+if __name__ == "__main__":
+    dataset = load_dataset(DATASET)
+    train = dataset["train"]
+    validation = dataset["test"]
+
+    # convert to pandas dataframe
+    train_df = train.to_pandas()
+    validation_df = validation.to_pandas()
+
+    # prepare dataset for AutoTrain
+    dset = AutoTrainDataset(
+        train_data=[train_df],
+        valid_data=[validation_df],
+        task=TASK,
+        token=TOKEN,
+        project_name=PROJECT_NAME,
+        username=USERNAME,
+        column_mapping={"text": "text", "label": "label"},
+        percent_valid=None,
+    )
+    dset.prepare()
+
+    #
+    # How to get params for a task:
+    #
+    # from autotrain.params import Params
+    # params = Params(task=TASK, training_type="hub_model").get()
+    # print(params) to get full list of params for the task
+
+    # define params in proper format
+    job1 = {
+        "task": TASK,
+        "learning_rate": 1e-5,
+        "optimizer": "adamw_torch",
+        "scheduler": "linear",
+        "epochs": 5,
+    }
+
+    job2 = {
+        "task": TASK,
+        "learning_rate": 3e-5,
+        "optimizer": "adamw_torch",
+        "scheduler": "cosine",
+        "epochs": 5,
+    }
+
+    job3 = {
+        "task": TASK,
+        "learning_rate": 5e-5,
+        "optimizer": "sgd",
+        "scheduler": "cosine",
+        "epochs": 5,
+    }
+
+    jobs = [job1, job2, job3]
+    project = Project(dataset=dset, hub_model=MODEL, job_params=jobs)
+    project_id = project.create()
+    project.approve(project_id)

autotrain-advanced/examples/text_classification_multiclass.py

@@ -0,0 +1,77 @@
+import os
+from uuid import uuid4
+
+from datasets import load_dataset
+
+from autotrain.dataset import AutoTrainDataset
+from autotrain.project import Project
+
+
+RANDOM_ID = str(uuid4())
+DATASET = "amazon_reviews_multi"
+PROJECT_NAME = f"amazon_reviews_multi_{RANDOM_ID}"
+TASK = "text_multi_class_classification"
+MODEL = "bert-base-uncased"
+
+USERNAME = os.environ["AUTOTRAIN_USERNAME"]
+TOKEN = os.environ["HF_TOKEN"]
+
+
+if __name__ == "__main__":
+    dataset = load_dataset(DATASET, "en")
+    train = dataset["train"]
+    validation = dataset["test"]
+
+    # convert to pandas dataframe
+    train_df = train.to_pandas()
+    validation_df = validation.to_pandas()
+
+    # prepare dataset for AutoTrain
+    dset = AutoTrainDataset(
+        train_data=[train_df],
+        valid_data=[validation_df],
+        task=TASK,
+        token=TOKEN,
+        project_name=PROJECT_NAME,
+        username=USERNAME,
+        column_mapping={"text": "review_body", "label": "stars"},
+        percent_valid=None,
+    )
+    dset.prepare()
+
+    #
+    # How to get params for a task:
+    #
+    # from autotrain.params import Params
+    # params = Params(task=TASK, training_type="hub_model").get()
+    # print(params) to get full list of params for the task
+
+    # define params in proper format
+    job1 = {
+        "task": TASK,
+        "learning_rate": 1e-5,
+        "optimizer": "adamw_torch",
+        "scheduler": "linear",
+        "epochs": 5,
+    }
+
+    job2 = {
+        "task": TASK,
+        "learning_rate": 3e-5,
+        "optimizer": "adamw_torch",
+        "scheduler": "cosine",
+        "epochs": 5,
+    }
+
+    job3 = {
+        "task": TASK,
+        "learning_rate": 5e-5,
+        "optimizer": "sgd",
+        "scheduler": "cosine",
+        "epochs": 5,
+    }
+
+    jobs = [job1, job2, job3]
+    project = Project(dataset=dset, hub_model=MODEL, job_params=jobs)
+    project_id = project.create()
+    project.approve(project_id)

autotrain-advanced/requirements.txt

@@ -0,0 +1,31 @@
+albumentations==1.3.1
+codecarbon==2.2.3
+datasets[vision]~=2.14.0
+evaluate==0.3.0
+ipadic==1.0.0
+jiwer==3.0.2
+joblib==1.3.1
+loguru==0.7.0
+pandas==2.0.3
+Pillow==10.0.0
+protobuf==4.23.4
+pydantic==1.10.11
+sacremoses==0.0.53
+scikit-learn==1.3.0
+sentencepiece==0.1.99
+tqdm==4.65.0
+werkzeug==2.3.6
+huggingface_hub>=0.16.4
+requests==2.31.0
+gradio==3.39.0
+einops==0.6.1
+invisible-watermark==0.2.0
+# latest versions
+tensorboard
+peft
+trl
+tiktoken
+transformers
+accelerate
+diffusers
+bitsandbytes

autotrain-advanced/setup.cfg

@@ -0,0 +1,24 @@
+[metadata]
+license_files = LICENSE
+version = attr: autotrain.__version__
+
+[isort]
+ensure_newline_before_comments = True
+force_grid_wrap = 0
+include_trailing_comma = True
+line_length = 119
+lines_after_imports = 2
+multi_line_output = 3
+use_parentheses = True
+
+[flake8]
+ignore = E203, E501, W503
+max-line-length = 119
+per-file-ignores =
+    # imported but unused
+    __init__.py: F401
+exclude =
+    .git,
+    .venv,
+    __pycache__,
+    dist

autotrain-advanced/setup.py

@@ -0,0 +1,71 @@
+# Lint as: python3
+"""
+HuggingFace / AutoTrain Advanced
+"""
+import os
+
+from setuptools import find_packages, setup
+
+
+DOCLINES = __doc__.split("\n")
+
+this_directory = os.path.abspath(os.path.dirname(__file__))
+with open(os.path.join(this_directory, "README.md"), encoding="utf-8") as f:
+    LONG_DESCRIPTION = f.read()
+
+# get INSTALL_REQUIRES from requirements.txt
+with open(os.path.join(this_directory, "requirements.txt"), encoding="utf-8") as f:
+    INSTALL_REQUIRES = f.read().splitlines()
+
+QUALITY_REQUIRE = [
+    "black",
+    "isort",
+    "flake8==3.7.9",
+]
+
+TESTS_REQUIRE = ["pytest"]
+
+
+EXTRAS_REQUIRE = {
+    "dev": INSTALL_REQUIRES + QUALITY_REQUIRE + TESTS_REQUIRE,
+    "quality": INSTALL_REQUIRES + QUALITY_REQUIRE,
+    "docs": INSTALL_REQUIRES
+    + [
+        "recommonmark",
+        "sphinx==3.1.2",
+        "sphinx-markdown-tables",
+        "sphinx-rtd-theme==0.4.3",
+        "sphinx-copybutton",
+    ],
+}
+
+setup(
+    name="autotrain-advanced",
+    description=DOCLINES[0],
+    long_description=LONG_DESCRIPTION,
+    long_description_content_type="text/markdown",
+    author="HuggingFace Inc.",
+    author_email="autotrain@huggingface.co",
+    url="https://github.com/huggingface/autotrain-advanced",
+    download_url="https://github.com/huggingface/autotrain-advanced/tags",
+    license="Apache 2.0",
+    package_dir={"": "src"},
+    packages=find_packages("src"),
+    extras_require=EXTRAS_REQUIRE,
+    install_requires=INSTALL_REQUIRES,
+    entry_points={"console_scripts": ["autotrain=autotrain.cli.autotrain:main"]},
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Education",
+        "Intended Audience :: Science/Research",
+        "License :: OSI Approved :: Apache Software License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    ],
+    keywords="automl autonlp autotrain huggingface",
+)

autotrain-advanced/src/autotrain/__init__.py

@@ -0,0 +1,24 @@
+# coding=utf-8
+# Copyright 2020-2021 The HuggingFace AutoTrain Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Lint as: python3
+# pylint: enable=line-too-long
+import os
+
+
+# ignore bnb warnings
+os.environ["BITSANDBYTES_NOWELCOME"] = "1"
+# os.environ["HF_HUB_DISABLE_PROGRESS_BARS"] = "1"
+__version__ = "0.6.16.dev0"

autotrain-advanced/src/autotrain/app.py

@@ -0,0 +1,965 @@
+import json
+import os
+import random
+import string
+import zipfile
+
+import gradio as gr
+import pandas as pd
+from huggingface_hub import list_models
+from loguru import logger
+
+from autotrain.dataset import AutoTrainDataset, AutoTrainDreamboothDataset, AutoTrainImageClassificationDataset
+from autotrain.languages import SUPPORTED_LANGUAGES
+from autotrain.params import Params
+from autotrain.project import Project
+from autotrain.utils import get_project_cost, get_user_token, user_authentication
+
+
+APP_TASKS = {
+    "Natural Language Processing": ["Text Classification", "LLM Finetuning"],
+    # "Tabular": TABULAR_TASKS,
+    "Computer Vision": ["Image Classification", "Dreambooth"],
+}
+
+APP_TASKS_MAPPING = {
+    "Text Classification": "text_multi_class_classification",
+    "LLM Finetuning": "lm_training",
+    "Image Classification": "image_multi_class_classification",
+    "Dreambooth": "dreambooth",
+}
+
+APP_TASK_TYPE_MAPPING = {
+    "text_classification": "Natural Language Processing",
+    "lm_training": "Natural Language Processing",
+    "image_classification": "Computer Vision",
+    "dreambooth": "Computer Vision",
+}
+
+ALLOWED_FILE_TYPES = [
+    ".csv",
+    ".CSV",
+    ".jsonl",
+    ".JSONL",
+    ".zip",
+    ".ZIP",
+    ".png",
+    ".PNG",
+    ".jpg",
+    ".JPG",
+    ".jpeg",
+    ".JPEG",
+]
+
+
+def _login_user(user_token):
+    user_info = user_authentication(token=user_token)
+    username = user_info["name"]
+
+    user_can_pay = user_info["canPay"]
+    orgs = user_info["orgs"]
+
+    valid_orgs = [org for org in orgs if org["canPay"] is True]
+    valid_orgs = [org for org in valid_orgs if org["roleInOrg"] in ("admin", "write")]
+    valid_orgs = [org["name"] for org in valid_orgs]
+
+    valid_can_pay = [username] + valid_orgs if user_can_pay else valid_orgs
+    who_is_training = [username] + [org["name"] for org in orgs]
+    return user_token, valid_can_pay, who_is_training
+
+
+def _update_task_type(project_type):
+    return gr.Dropdown.update(
+        value=APP_TASKS[project_type][0],
+        choices=APP_TASKS[project_type],
+        visible=True,
+    )
+
+
+def _update_model_choice(task, autotrain_backend):
+    # TODO: add tabular and remember, for tabular, we only support AutoTrain
+    if autotrain_backend.lower() != "huggingface internal":
+        model_choice = ["HuggingFace Hub"]
+        return gr.Dropdown.update(
+            value=model_choice[0],
+            choices=model_choice,
+            visible=True,
+        )
+
+    if task == "LLM Finetuning":
+        model_choice = ["HuggingFace Hub"]
+    else:
+        model_choice = ["AutoTrain", "HuggingFace Hub"]
+
+    return gr.Dropdown.update(
+        value=model_choice[0],
+        choices=model_choice,
+        visible=True,
+    )
+
+
+def _update_file_type(task):
+    task = APP_TASKS_MAPPING[task]
+    if task in ("text_multi_class_classification", "lm_training"):
+        return gr.Radio.update(
+            value="CSV",
+            choices=["CSV", "JSONL"],
+            visible=True,
+        )
+    elif task == "image_multi_class_classification":
+        return gr.Radio.update(
+            value="ZIP",
+            choices=["Image Subfolders", "ZIP"],
+            visible=True,
+        )
+    elif task == "dreambooth":
+        return gr.Radio.update(
+            value="ZIP",
+            choices=["Image Folder", "ZIP"],
+            visible=True,
+        )
+    else:
+        raise NotImplementedError
+
+
+def _update_param_choice(model_choice, autotrain_backend):
+    logger.info(f"model_choice: {model_choice}")
+    choices = ["AutoTrain", "Manual"] if model_choice == "HuggingFace Hub" else ["AutoTrain"]
+    choices = ["Manual"] if autotrain_backend != "HuggingFace Internal" else choices
+    return gr.Dropdown.update(
+        value=choices[0],
+        choices=choices,
+        visible=True,
+    )
+
+
+def _project_type_update(project_type, task_type, autotrain_backend):
+    logger.info(f"project_type: {project_type}, task_type: {task_type}")
+    task_choices_update = _update_task_type(project_type)
+    model_choices_update = _update_model_choice(task_choices_update["value"], autotrain_backend)
+    param_choices_update = _update_param_choice(model_choices_update["value"], autotrain_backend)
+    return [
+        task_choices_update,
+        model_choices_update,
+        param_choices_update,
+        _update_hub_model_choices(task_choices_update["value"], model_choices_update["value"]),
+    ]
+
+
+def _task_type_update(task_type, autotrain_backend):
+    logger.info(f"task_type: {task_type}")
+    model_choices_update = _update_model_choice(task_type, autotrain_backend)
+    param_choices_update = _update_param_choice(model_choices_update["value"], autotrain_backend)
+    return [
+        model_choices_update,
+        param_choices_update,
+        _update_hub_model_choices(task_type, model_choices_update["value"]),
+    ]
+
+
+def _update_col_map(training_data, task):
+    task = APP_TASKS_MAPPING[task]
+    if task == "text_multi_class_classification":
+        data_cols = pd.read_csv(training_data[0].name, nrows=2).columns.tolist()
+        return [
+            gr.Dropdown.update(visible=True, choices=data_cols, label="Map `text` column", value=data_cols[0]),
+            gr.Dropdown.update(visible=True, choices=data_cols, label="Map `target` column", value=data_cols[1]),
+            gr.Text.update(visible=False),
+        ]
+    elif task == "lm_training":
+        data_cols = pd.read_csv(training_data[0].name, nrows=2).columns.tolist()
+        return [
+            gr.Dropdown.update(visible=True, choices=data_cols, label="Map `text` column", value=data_cols[0]),
+            gr.Dropdown.update(visible=False),
+            gr.Text.update(visible=False),
+        ]
+    elif task == "dreambooth":
+        return [
+            gr.Dropdown.update(visible=False),
+            gr.Dropdown.update(visible=False),
+            gr.Text.update(visible=True, label="Concept Token", interactive=True),
+        ]
+    else:
+        return [
+            gr.Dropdown.update(visible=False),
+            gr.Dropdown.update(visible=False),
+            gr.Text.update(visible=False),
+        ]
+
+
+def _estimate_costs(
+    training_data, validation_data, task, user_token, autotrain_username, training_params_txt, autotrain_backend
+):
+    if autotrain_backend.lower() != "huggingface internal":
+        return [
+            gr.Markdown.update(
+                value="Cost estimation is not available for this backend",
+                visible=True,
+            ),
+            gr.Number.update(visible=False),
+        ]
+    try:
+        logger.info("Estimating costs....")
+        if training_data is None:
+            return [
+                gr.Markdown.update(
+                    value="Could not estimate cost. Please add training data",
+                    visible=True,
+                ),
+                gr.Number.update(visible=False),
+            ]
+        if validation_data is None:
+            validation_data = []
+
+        training_params = json.loads(training_params_txt)
+        if len(training_params) == 0:
+            return [
+                gr.Markdown.update(
+                    value="Could not estimate cost. Please add atleast one job",
+                    visible=True,
+                ),
+                gr.Number.update(visible=False),
+            ]
+        elif len(training_params) == 1:
+            if "num_models" in training_params[0]:
+                num_models = training_params[0]["num_models"]
+            else:
+                num_models = 1
+        else:
+            num_models = len(training_params)
+        task = APP_TASKS_MAPPING[task]
+        num_samples = 0
+        logger.info("Estimating number of samples")
+        if task in ("text_multi_class_classification", "lm_training"):
+            for _f in training_data:
+                num_samples += pd.read_csv(_f.name).shape[0]
+            for _f in validation_data:
+                num_samples += pd.read_csv(_f.name).shape[0]
+        elif task == "image_multi_class_classification":
+            logger.info(f"training_data: {training_data}")
+            if len(training_data) > 1:
+                return [
+                    gr.Markdown.update(
+                        value="Only one training file is supported for image classification",
+                        visible=True,
+                    ),
+                    gr.Number.update(visible=False),
+                ]
+            if len(validation_data) > 1:
+                return [
+                    gr.Markdown.update(
+                        value="Only one validation file is supported for image classification",
+                        visible=True,
+                    ),
+                    gr.Number.update(visible=False),
+                ]
+            for _f in training_data:
+                zip_ref = zipfile.ZipFile(_f.name, "r")
+                for _ in zip_ref.namelist():
+                    num_samples += 1
+            for _f in validation_data:
+                zip_ref = zipfile.ZipFile(_f.name, "r")
+                for _ in zip_ref.namelist():
+                    num_samples += 1
+        elif task == "dreambooth":
+            num_samples = len(training_data)
+        else:
+            raise NotImplementedError
+
+        logger.info(f"Estimating costs for: num_models: {num_models}, task: {task}, num_samples: {num_samples}")
+        estimated_cost = get_project_cost(
+            username=autotrain_username,
+            token=user_token,
+            task=task,
+            num_samples=num_samples,
+            num_models=num_models,
+        )
+        logger.info(f"Estimated_cost: {estimated_cost}")
+        return [
+            gr.Markdown.update(
+                value=f"Estimated cost: ${estimated_cost:.2f}. Note: clicking on 'Create Project' will start training and incur charges!",
+                visible=True,
+            ),
+            gr.Number.update(visible=False),
+        ]
+    except Exception as e:
+        logger.error(e)
+        logger.error("Could not estimate cost, check inputs")
+        return [
+            gr.Markdown.update(
+                value="Could not estimate cost, check inputs",
+                visible=True,
+            ),
+            gr.Number.update(visible=False),
+        ]
+
+
+def get_job_params(param_choice, training_params, task):
+    if param_choice == "autotrain":
+        if len(training_params) > 1:
+            raise ValueError("❌ Only one job parameter is allowed for AutoTrain.")
+        training_params[0].update({"task": task})
+    elif param_choice.lower() == "manual":
+        for i in range(len(training_params)):
+            training_params[i].update({"task": task})
+            if "hub_model" in training_params[i]:
+                # remove hub_model from training_params
+                training_params[i].pop("hub_model")
+    return training_params
+
+
+def _update_project_name():
+    random_project_name = "-".join(
+        ["".join(random.choices(string.ascii_lowercase + string.digits, k=4)) for _ in range(3)]
+    )
+    # check if training tracker exists
+    if os.path.exists(os.path.join("/tmp", "training")):
+        return [
+            gr.Text.update(value=random_project_name, visible=True, interactive=True),
+            gr.Button.update(interactive=False),
+        ]
+    return [
+        gr.Text.update(value=random_project_name, visible=True, interactive=True),
+        gr.Button.update(interactive=True),
+    ]
+
+
+def _update_hub_model_choices(task, model_choice):
+    task = APP_TASKS_MAPPING[task]
+    logger.info(f"Updating hub model choices for task: {task}, model_choice: {model_choice}")
+    if model_choice.lower() == "autotrain":
+        return gr.Dropdown.update(
+            visible=False,
+            interactive=False,
+        )
+    if task == "text_multi_class_classification":
+        hub_models1 = list_models(filter="fill-mask", sort="downloads", direction=-1, limit=100)
+        hub_models2 = list_models(filter="text-classification", sort="downloads", direction=-1, limit=100)
+        hub_models = list(hub_models1) + list(hub_models2)
+    elif task == "lm_training":
+        hub_models = list(list_models(filter="text-generation", sort="downloads", direction=-1, limit=100))
+    elif task == "image_multi_class_classification":
+        hub_models = list(list_models(filter="image-classification", sort="downloads", direction=-1, limit=100))
+    elif task == "dreambooth":
+        hub_models = list(list_models(filter="text-to-image", sort="downloads", direction=-1, limit=100))
+    else:
+        raise NotImplementedError
+    # sort by number of downloads in descending order
+    hub_models = [{"id": m.modelId, "downloads": m.downloads} for m in hub_models if m.private is False]
+    hub_models = sorted(hub_models, key=lambda x: x["downloads"], reverse=True)
+
+    if task == "dreambooth":
+        choices = ["stabilityai/stable-diffusion-xl-base-1.0"] + [m["id"] for m in hub_models]
+        value = choices[0]
+        return gr.Dropdown.update(
+            choices=choices,
+            value=value,
+            visible=True,
+            interactive=True,
+        )
+
+    return gr.Dropdown.update(
+        choices=[m["id"] for m in hub_models],
+        value=hub_models[0]["id"],
+        visible=True,
+        interactive=True,
+    )
+
+
+def _update_backend(backend):
+    if backend != "Hugging Face Internal":
+        return [
+            gr.Dropdown.update(
+                visible=True,
+                interactive=True,
+                choices=["HuggingFace Hub"],
+                value="HuggingFace Hub",
+            ),
+            gr.Dropdown.update(
+                visible=True,
+                interactive=True,
+                choices=["Manual"],
+                value="Manual",
+            ),
+        ]
+    return [
+        gr.Dropdown.update(
+            visible=True,
+            interactive=True,
+        ),
+        gr.Dropdown.update(
+            visible=True,
+            interactive=True,
+        ),
+    ]
+
+
+def _create_project(
+    autotrain_username,
+    valid_can_pay,
+    project_name,
+    user_token,
+    task,
+    training_data,
+    validation_data,
+    col_map_text,
+    col_map_label,
+    concept_token,
+    training_params_txt,
+    hub_model,
+    estimated_cost,
+    autotrain_backend,
+):
+    task = APP_TASKS_MAPPING[task]
+    valid_can_pay = valid_can_pay.split(",")
+    can_pay = autotrain_username in valid_can_pay
+    logger.info(f"🚨🚨🚨Creating project: {project_name}")
+    logger.info(f"🚨Task: {task}")
+    logger.info(f"🚨Training data: {training_data}")
+    logger.info(f"🚨Validation data: {validation_data}")
+    logger.info(f"🚨Training params: {training_params_txt}")
+    logger.info(f"🚨Hub model: {hub_model}")
+    logger.info(f"🚨Estimated cost: {estimated_cost}")
+    logger.info(f"🚨:Can pay: {can_pay}")
+
+    if can_pay is False and estimated_cost > 0:
+        raise gr.Error("❌ You do not have enough credits to create this project. Please add a valid payment method.")
+
+    training_params = json.loads(training_params_txt)
+    if len(training_params) == 0:
+        raise gr.Error("Please add atleast one job")
+    elif len(training_params) == 1:
+        if "num_models" in training_params[0]:
+            param_choice = "autotrain"
+        else:
+            param_choice = "manual"
+    else:
+        param_choice = "manual"
+
+    if task == "image_multi_class_classification":
+        training_data = training_data[0].name
+        if validation_data is not None:
+            validation_data = validation_data[0].name
+        dset = AutoTrainImageClassificationDataset(
+            train_data=training_data,
+            token=user_token,
+            project_name=project_name,
+            username=autotrain_username,
+            valid_data=validation_data,
+            percent_valid=None,  # TODO: add to UI
+        )
+    elif task == "text_multi_class_classification":
+        training_data = [f.name for f in training_data]
+        if validation_data is None:
+            validation_data = []
+        else:
+            validation_data = [f.name for f in validation_data]
+        dset = AutoTrainDataset(
+            train_data=training_data,
+            task=task,
+            token=user_token,
+            project_name=project_name,
+            username=autotrain_username,
+            column_mapping={"text": col_map_text, "label": col_map_label},
+            valid_data=validation_data,
+            percent_valid=None,  # TODO: add to UI
+        )
+    elif task == "lm_training":
+        training_data = [f.name for f in training_data]
+        if validation_data is None:
+            validation_data = []
+        else:
+            validation_data = [f.name for f in validation_data]
+        dset = AutoTrainDataset(
+            train_data=training_data,
+            task=task,
+            token=user_token,
+            project_name=project_name,
+            username=autotrain_username,
+            column_mapping={"text": col_map_text},
+            valid_data=validation_data,
+            percent_valid=None,  # TODO: add to UI
+        )
+    elif task == "dreambooth":
+        dset = AutoTrainDreamboothDataset(
+            concept_images=training_data,
+            concept_name=concept_token,
+            token=user_token,
+            project_name=project_name,
+            username=autotrain_username,
+        )
+    else:
+        raise NotImplementedError
+
+    dset.prepare()
+    project = Project(
+        dataset=dset,
+        param_choice=param_choice,
+        hub_model=hub_model,
+        job_params=get_job_params(param_choice, training_params, task),
+    )
+    if autotrain_backend.lower() == "huggingface internal":
+        project_id = project.create()
+        project.approve(project_id)
+        return gr.Markdown.update(
+            value=f"Project created successfully. Monitor progess on the [dashboard](https://ui.autotrain.huggingface.co/{project_id}/trainings).",
+            visible=True,
+        )
+    else:
+        project.create(local=True)
+
+
+def get_variable_name(var, namespace):
+    for name in namespace:
+        if namespace[name] is var:
+            return name
+    return None
+
+
+def disable_create_project_button():
+    return gr.Button.update(interactive=False)
+
+
+def main():
+    with gr.Blocks(theme="freddyaboulton/dracula_revamped") as demo:
+        gr.Markdown("## 🤗 AutoTrain Advanced")
+        user_token = os.environ.get("HF_TOKEN", "")
+
+        if len(user_token) == 0:
+            user_token = get_user_token()
+
+        if user_token is None:
+            gr.Markdown(
+                """Please login with a write [token](https://huggingface.co/settings/tokens).
+                Pass your HF token in an environment variable called `HF_TOKEN` and then restart this app.
+                """
+            )
+            return demo
+
+        user_token, valid_can_pay, who_is_training = _login_user(user_token)
+
+        if user_token is None or len(user_token) == 0:
+            gr.Error("Please login with a write token.")
+
+        user_token = gr.Textbox(
+            value=user_token, type="password", lines=1, max_lines=1, visible=False, interactive=False
+        )
+        valid_can_pay = gr.Textbox(value=",".join(valid_can_pay), visible=False, interactive=False)
+        with gr.Row():
+            with gr.Column():
+                with gr.Row():
+                    autotrain_username = gr.Dropdown(
+                        label="AutoTrain Username",
+                        choices=who_is_training,
+                        value=who_is_training[0] if who_is_training else "",
+                    )
+                    autotrain_backend = gr.Dropdown(
+                        label="AutoTrain Backend",
+                        choices=["HuggingFace Internal", "HuggingFace Spaces"],
+                        value="HuggingFace Internal",
+                        interactive=True,
+                    )
+                with gr.Row():
+                    project_name = gr.Textbox(label="Project name", value="", lines=1, max_lines=1, interactive=True)
+                    project_type = gr.Dropdown(
+                        label="Project Type", choices=list(APP_TASKS.keys()), value=list(APP_TASKS.keys())[0]
+                    )
+                    task_type = gr.Dropdown(
+                        label="Task",
+                        choices=APP_TASKS[list(APP_TASKS.keys())[0]],
+                        value=APP_TASKS[list(APP_TASKS.keys())[0]][0],
+                        interactive=True,
+                    )
+                    model_choice = gr.Dropdown(
+                        label="Model Choice",
+                        choices=["AutoTrain", "HuggingFace Hub"],
+                        value="AutoTrain",
+                        visible=True,
+                        interactive=True,
+                    )
+                hub_model = gr.Dropdown(
+                    label="Hub Model",
+                    value="",
+                    visible=False,
+                    interactive=True,
+                    elem_id="hub_model",
+                )
+        gr.Markdown("<hr>")
+        with gr.Row():
+            with gr.Column():
+                with gr.Tabs(elem_id="tabs"):
+                    with gr.TabItem("Data"):
+                        with gr.Column():
+                            # file_type_training = gr.Radio(
+                            #     label="File Type",
+                            #     choices=["CSV", "JSONL"],
+                            #     value="CSV",
+                            #     visible=True,
+                            #     interactive=True,
+                            # )
+                            training_data = gr.File(
+                                label="Training Data",
+                                file_types=ALLOWED_FILE_TYPES,
+                                file_count="multiple",
+                                visible=True,
+                                interactive=True,
+                                elem_id="training_data_box",
+                            )
+                            with gr.Accordion("Validation Data (Optional)", open=False):
+                                validation_data = gr.File(
+                                    label="Validation Data (Optional)",
+                                    file_types=ALLOWED_FILE_TYPES,
+                                    file_count="multiple",
+                                    visible=True,
+                                    interactive=True,
+                                    elem_id="validation_data_box",
+                                )
+                            with gr.Row():
+                                col_map_text = gr.Dropdown(
+                                    label="Text Column", choices=[], visible=False, interactive=True
+                                )
+                                col_map_target = gr.Dropdown(
+                                    label="Target Column", choices=[], visible=False, interactive=True
+                                )
+                                concept_token = gr.Text(
+                                    value="", visible=False, interactive=True, lines=1, max_lines=1
+                                )
+                    with gr.TabItem("Params"):
+                        with gr.Row():
+                            source_language = gr.Dropdown(
+                                label="Source Language",
+                                choices=SUPPORTED_LANGUAGES[:-1],
+                                value="en",
+                                visible=True,
+                                interactive=True,
+                                elem_id="source_language",
+                            )
+                            num_models = gr.Slider(
+                                label="Number of Models",
+                                minimum=1,
+                                maximum=25,
+                                value=5,
+                                step=1,
+                                visible=True,
+                                interactive=True,
+                                elem_id="num_models",
+                            )
+                            target_language = gr.Dropdown(
+                                label="Target Language",
+                                choices=["fr"],
+                                value="fr",
+                                visible=False,
+                                interactive=True,
+                                elem_id="target_language",
+                            )
+                            image_size = gr.Number(
+                                label="Image Size",
+                                value=512,
+                                visible=False,
+                                interactive=True,
+                                elem_id="image_size",
+                            )
+
+                        with gr.Row():
+                            learning_rate = gr.Number(
+                                label="Learning Rate",
+                                value=5e-5,
+                                visible=False,
+                                interactive=True,
+                                elem_id="learning_rate",
+                            )
+                            batch_size = gr.Number(
+                                label="Train Batch Size",
+                                value=32,
+                                visible=False,
+                                interactive=True,
+                                elem_id="train_batch_size",
+                            )
+                            num_epochs = gr.Number(
+                                label="Number of Epochs",
+                                value=3,
+                                visible=False,
+                                interactive=True,
+                                elem_id="num_train_epochs",
+                            )
+                        with gr.Row():
+                            gradient_accumulation_steps = gr.Number(
+                                label="Gradient Accumulation Steps",
+                                value=1,
+                                visible=False,
+                                interactive=True,
+                                elem_id="gradient_accumulation_steps",
+                            )
+                            percentage_warmup_steps = gr.Number(
+                                label="Percentage of Warmup Steps",
+                                value=0.1,
+                                visible=False,
+                                interactive=True,
+                                elem_id="percentage_warmup",
+                            )
+                            weight_decay = gr.Number(
+                                label="Weight Decay",
+                                value=0.01,
+                                visible=False,
+                                interactive=True,
+                                elem_id="weight_decay",
+                            )
+                        with gr.Row():
+                            lora_r = gr.Number(
+                                label="LoraR",
+                                value=16,
+                                visible=False,
+                                interactive=True,
+                                elem_id="lora_r",
+                            )
+                            lora_alpha = gr.Number(
+                                label="LoraAlpha",
+                                value=32,
+                                visible=False,
+                                interactive=True,
+                                elem_id="lora_alpha",
+                            )
+                            lora_dropout = gr.Number(
+                                label="Lora Dropout",
+                                value=0.1,
+                                visible=False,
+                                interactive=True,
+                                elem_id="lora_dropout",
+                            )
+                        with gr.Row():
+                            db_num_steps = gr.Number(
+                                label="Num Steps",
+                                value=500,
+                                visible=False,
+                                interactive=True,
+                                elem_id="num_steps",
+                            )
+                        with gr.Row():
+                            optimizer = gr.Dropdown(
+                                label="Optimizer",
+                                choices=["adamw_torch", "adamw_hf", "sgd", "adafactor", "adagrad"],
+                                value="adamw_torch",
+                                visible=False,
+                                interactive=True,
+                                elem_id="optimizer",
+                            )
+                            scheduler = gr.Dropdown(
+                                label="Scheduler",
+                                choices=["linear", "cosine"],
+                                value="linear",
+                                visible=False,
+                                interactive=True,
+                                elem_id="scheduler",
+                            )
+
+                        add_job_button = gr.Button(
+                            value="Add Job",
+                            visible=True,
+                            interactive=True,
+                            elem_id="add_job",
+                        )
+                        # clear_jobs_button = gr.Button(
+                        #     value="Clear Jobs",
+                        #     visible=True,
+                        #     interactive=True,
+                        #     elem_id="clear_jobs",
+                        # )
+                gr.Markdown("<hr>")
+                estimated_costs_md = gr.Markdown(value="Estimated Costs: N/A", visible=True, interactive=False)
+                estimated_costs_num = gr.Number(value=0, visible=False, interactive=False)
+                create_project_button = gr.Button(
+                    value="Create Project",
+                    visible=True,
+                    interactive=True,
+                    elem_id="create_project",
+                )
+            with gr.Column():
+                param_choice = gr.Dropdown(
+                    label="Param Choice",
+                    choices=["AutoTrain"],
+                    value="AutoTrain",
+                    visible=True,
+                    interactive=True,
+                )
+                training_params_txt = gr.Text(value="[]", visible=False, interactive=False)
+                training_params_md = gr.DataFrame(visible=False, interactive=False)
+
+        final_output = gr.Markdown(value="", visible=True, interactive=False)
+        hyperparameters = [
+            hub_model,
+            num_models,
+            source_language,
+            target_language,
+            learning_rate,
+            batch_size,
+            num_epochs,
+            gradient_accumulation_steps,
+            lora_r,
+            lora_alpha,
+            lora_dropout,
+            optimizer,
+            scheduler,
+            percentage_warmup_steps,
+            weight_decay,
+            db_num_steps,
+            image_size,
+        ]
+
+        def _update_params(params_data):
+            _task = params_data[task_type]
+            _task = APP_TASKS_MAPPING[_task]
+            params = Params(
+                task=_task,
+                param_choice="autotrain" if params_data[param_choice] == "AutoTrain" else "manual",
+                model_choice="autotrain" if params_data[model_choice] == "AutoTrain" else "hub_model",
+            )
+            params = params.get()
+            visible_params = []
+            for param in hyperparameters:
+                if param.elem_id in params.keys():
+                    visible_params.append(param.elem_id)
+            op = [h.update(visible=h.elem_id in visible_params) for h in hyperparameters]
+            op.append(add_job_button.update(visible=True))
+            op.append(training_params_md.update(visible=False))
+            op.append(training_params_txt.update(value="[]"))
+            return op
+
+        autotrain_backend.change(
+            _project_type_update,
+            inputs=[project_type, task_type, autotrain_backend],
+            outputs=[task_type, model_choice, param_choice, hub_model],
+        )
+
+        project_type.change(
+            _project_type_update,
+            inputs=[project_type, task_type, autotrain_backend],
+            outputs=[task_type, model_choice, param_choice, hub_model],
+        )
+        task_type.change(
+            _task_type_update,
+            inputs=[task_type, autotrain_backend],
+            outputs=[model_choice, param_choice, hub_model],
+        )
+        model_choice.change(
+            _update_param_choice,
+            inputs=[model_choice, autotrain_backend],
+            outputs=param_choice,
+        ).then(
+            _update_hub_model_choices,
+            inputs=[task_type, model_choice],
+            outputs=hub_model,
+        )
+
+        param_choice.change(
+            _update_params,
+            inputs=set([task_type, param_choice, model_choice] + hyperparameters + [add_job_button]),
+            outputs=hyperparameters + [add_job_button, training_params_md, training_params_txt],
+        )
+        task_type.change(
+            _update_params,
+            inputs=set([task_type, param_choice, model_choice] + hyperparameters + [add_job_button]),
+            outputs=hyperparameters + [add_job_button, training_params_md, training_params_txt],
+        )
+        model_choice.change(
+            _update_params,
+            inputs=set([task_type, param_choice, model_choice] + hyperparameters + [add_job_button]),
+            outputs=hyperparameters + [add_job_button, training_params_md, training_params_txt],
+        )
+
+        def _add_job(params_data):
+            _task = params_data[task_type]
+            _task = APP_TASKS_MAPPING[_task]
+            _param_choice = "autotrain" if params_data[param_choice] == "AutoTrain" else "manual"
+            _model_choice = "autotrain" if params_data[model_choice] == "AutoTrain" else "hub_model"
+            if _model_choice == "hub_model" and params_data[hub_model] is None:
+                logger.error("Hub model is None")
+                return
+            _training_params = {}
+            params = Params(task=_task, param_choice=_param_choice, model_choice=_model_choice)
+            params = params.get()
+            for _param in hyperparameters:
+                if _param.elem_id in params.keys():
+                    _training_params[_param.elem_id] = params_data[_param]
+            _training_params_md = json.loads(params_data[training_params_txt])
+            if _param_choice == "autotrain":
+                if len(_training_params_md) > 0:
+                    _training_params_md[0] = _training_params
+                    _training_params_md = _training_params_md[:1]
+                else:
+                    _training_params_md.append(_training_params)
+            else:
+                _training_params_md.append(_training_params)
+            params_df = pd.DataFrame(_training_params_md)
+            # remove hub_model column
+            if "hub_model" in params_df.columns:
+                params_df = params_df.drop(columns=["hub_model"])
+            return [
+                gr.DataFrame.update(value=params_df, visible=True),
+                gr.Textbox.update(value=json.dumps(_training_params_md), visible=False),
+            ]
+
+        add_job_button.click(
+            _add_job,
+            inputs=set(
+                [task_type, param_choice, model_choice] + hyperparameters + [training_params_md, training_params_txt]
+            ),
+            outputs=[training_params_md, training_params_txt],
+        )
+        col_map_components = [
+            col_map_text,
+            col_map_target,
+            concept_token,
+        ]
+        training_data.change(
+            _update_col_map,
+            inputs=[training_data, task_type],
+            outputs=col_map_components,
+        )
+        task_type.change(
+            _update_col_map,
+            inputs=[training_data, task_type],
+            outputs=col_map_components,
+        )
+        estimate_costs_inputs = [
+            training_data,
+            validation_data,
+            task_type,
+            user_token,
+            autotrain_username,
+            training_params_txt,
+            autotrain_backend,
+        ]
+        estimate_costs_outputs = [estimated_costs_md, estimated_costs_num]
+        training_data.change(_estimate_costs, inputs=estimate_costs_inputs, outputs=estimate_costs_outputs)
+        validation_data.change(_estimate_costs, inputs=estimate_costs_inputs, outputs=estimate_costs_outputs)
+        training_params_txt.change(_estimate_costs, inputs=estimate_costs_inputs, outputs=estimate_costs_outputs)
+        task_type.change(_estimate_costs, inputs=estimate_costs_inputs, outputs=estimate_costs_outputs)
+        add_job_button.click(_estimate_costs, inputs=estimate_costs_inputs, outputs=estimate_costs_outputs)
+
+        create_project_button.click(disable_create_project_button, None, create_project_button).then(
+            _create_project,
+            inputs=[
+                autotrain_username,
+                valid_can_pay,
+                project_name,
+                user_token,
+                task_type,
+                training_data,
+                validation_data,
+                col_map_text,
+                col_map_target,
+                concept_token,
+                training_params_txt,
+                hub_model,
+                estimated_costs_num,
+                autotrain_backend,
+            ],
+            outputs=final_output,
+        )
+
+        demo.load(
+            _update_project_name,
+            outputs=[project_name, create_project_button],
+        )
+
+    return demo

autotrain-advanced/src/autotrain/cli/__init__.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+from argparse import ArgumentParser
+
+
+class BaseAutoTrainCommand(ABC):
+    @staticmethod
+    @abstractmethod
+    def register_subcommand(parser: ArgumentParser):
+        raise NotImplementedError()
+
+    @abstractmethod
+    def run(self):
+        raise NotImplementedError()

autotrain-advanced/src/autotrain/cli/autotrain.py

@@ -0,0 +1,40 @@
+import argparse
+
+from .. import __version__
+from .run_app import RunAutoTrainAppCommand
+from .run_dreambooth import RunAutoTrainDreamboothCommand
+from .run_llm import RunAutoTrainLLMCommand
+from .run_setup import RunSetupCommand
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        "AutoTrain advanced CLI",
+        usage="autotrain <command> [<args>]",
+        epilog="For more information about a command, run: `autotrain <command> --help`",
+    )
+    parser.add_argument("--version", "-v", help="Display AutoTrain version", action="store_true")
+    commands_parser = parser.add_subparsers(help="commands")
+
+    # Register commands
+    RunAutoTrainAppCommand.register_subcommand(commands_parser)
+    RunAutoTrainLLMCommand.register_subcommand(commands_parser)
+    RunSetupCommand.register_subcommand(commands_parser)
+    RunAutoTrainDreamboothCommand.register_subcommand(commands_parser)
+
+    args = parser.parse_args()
+
+    if args.version:
+        print(__version__)
+        exit(0)
+
+    if not hasattr(args, "func"):
+        parser.print_help()
+        exit(1)
+
+    command = args.func(args)
+    command.run()
+
+
+if __name__ == "__main__":
+    main()

autotrain-advanced/src/autotrain/cli/run_app.py

@@ -0,0 +1,55 @@
+from argparse import ArgumentParser
+
+from . import BaseAutoTrainCommand
+
+
+def run_app_command_factory(args):
+    return RunAutoTrainAppCommand(
+        args.port,
+        args.host,
+        args.task,
+    )
+
+
+class RunAutoTrainAppCommand(BaseAutoTrainCommand):
+    @staticmethod
+    def register_subcommand(parser: ArgumentParser):
+        run_app_parser = parser.add_parser(
+            "app",
+            description="✨ Run AutoTrain app",
+        )
+        run_app_parser.add_argument(
+            "--port",
+            type=int,
+            default=7860,
+            help="Port to run the app on",
+            required=False,
+        )
+        run_app_parser.add_argument(
+            "--host",
+            type=str,
+            default="127.0.0.1",
+            help="Host to run the app on",
+            required=False,
+        )
+        run_app_parser.add_argument(
+            "--task",
+            type=str,
+            required=False,
+            help="Task to run",
+        )
+        run_app_parser.set_defaults(func=run_app_command_factory)
+
+    def __init__(self, port, host, task):
+        self.port = port
+        self.host = host
+        self.task = task
+
+    def run(self):
+        if self.task == "dreambooth":
+            from ..dreambooth_app import main
+        else:
+            from ..app import main
+
+        demo = main()
+        demo.queue(concurrency_count=10).launch()

autotrain-advanced/src/autotrain/cli/run_dreambooth.py

@@ -0,0 +1,469 @@
+import glob
+import os
+from argparse import ArgumentParser
+
+from loguru import logger
+
+from autotrain.cli import BaseAutoTrainCommand
+
+
+try:
+    from autotrain.trainers.dreambooth import train as train_dreambooth
+    from autotrain.trainers.dreambooth.params import DreamBoothTrainingParams
+    from autotrain.trainers.dreambooth.utils import VALID_IMAGE_EXTENSIONS, XL_MODELS
+except ImportError:
+    logger.warning(
+        "❌ Some DreamBooth components are missing! Please run `autotrain setup` to install it. Ignore this warning if you are not using DreamBooth or running `autotrain setup` already."
+    )
+
+
+def count_images(directory):
+    files_grabbed = []
+    for files in VALID_IMAGE_EXTENSIONS:
+        files_grabbed.extend(glob.glob(os.path.join(directory, "*" + files)))
+    return len(files_grabbed)
+
+
+def run_dreambooth_command_factory(args):
+    return RunAutoTrainDreamboothCommand(args)
+
+
+class RunAutoTrainDreamboothCommand(BaseAutoTrainCommand):
+    @staticmethod
+    def register_subcommand(parser: ArgumentParser):
+        arg_list = [
+            {
+                "arg": "--model",
+                "help": "Model to use for training",
+                "required": True,
+                "type": str,
+            },
+            {
+                "arg": "--revision",
+                "help": "Model revision to use for training",
+                "required": False,
+                "type": str,
+            },
+            {
+                "arg": "--tokenizer",
+                "help": "Tokenizer to use for training",
+                "required": False,
+                "type": str,
+            },
+            {
+                "arg": "--image-path",
+                "help": "Path to the images",
+                "required": True,
+                "type": str,
+            },
+            {
+                "arg": "--class-image-path",
+                "help": "Path to the class images",
+                "required": False,
+                "type": str,
+            },
+            {
+                "arg": "--prompt",
+                "help": "Instance prompt",
+                "required": True,
+                "type": str,
+            },
+            {
+                "arg": "--class-prompt",
+                "help": "Class prompt",
+                "required": False,
+                "type": str,
+            },
+            {
+                "arg": "--num-class-images",
+                "help": "Number of class images",
+                "required": False,
+                "default": 100,
+                "type": int,
+            },
+            {
+                "arg": "--class-labels-conditioning",
+                "help": "Class labels conditioning",
+                "required": False,
+                "type": str,
+            },
+            {
+                "arg": "--prior-preservation",
+                "help": "With prior preservation",
+                "required": False,
+                "action": "store_true",
+            },
+            {
+                "arg": "--prior-loss-weight",
+                "help": "Prior loss weight",
+                "required": False,
+                "default": 1.0,
+                "type": float,
+            },
+            {
+                "arg": "--output",
+                "help": "Output directory",
+                "required": True,
+                "type": str,
+            },
+            {
+                "arg": "--seed",
+                "help": "Seed",
+                "required": False,
+                "default": 42,
+                "type": int,
+            },
+            {
+                "arg": "--resolution",
+                "help": "Resolution",
+                "required": True,
+                "type": int,
+            },
+            {
+                "arg": "--center-crop",
+                "help": "Center crop",
+                "required": False,
+                "action": "store_true",
+            },
+            {
+                "arg": "--train-text-encoder",
+                "help": "Train text encoder",
+                "required": False,
+                "action": "store_true",
+            },
+            {
+                "arg": "--batch-size",
+                "help": "Train batch size",
+                "required": False,
+                "default": 4,
+                "type": int,
+            },
+            {
+                "arg": "--sample-batch-size",
+                "help": "Sample batch size",
+                "required": False,
+                "default": 4,
+                "type": int,
+            },
+            {
+                "arg": "--epochs",
+                "help": "Number of training epochs",
+                "required": False,
+                "default": 1,
+                "type": int,
+            },
+            {
+                "arg": "--num-steps",
+                "help": "Max train steps",
+                "required": False,
+                "type": int,
+            },
+            {
+                "arg": "--checkpointing-steps",
+                "help": "Checkpointing steps",
+                "required": False,
+                "default": 100000,
+                "type": int,
+            },
+            {
+                "arg": "--resume-from-checkpoint",
+                "help": "Resume from checkpoint",
+                "required": False,
+                "type": str,
+            },
+            {
+                "arg": "--gradient-accumulation",
+                "help": "Gradient accumulation steps",
+                "required": False,
+                "default": 1,
+                "type": int,
+            },
+            {
+                "arg": "--gradient-checkpointing",
+                "help": "Gradient checkpointing",
+                "required": False,
+                "action": "store_true",
+            },
+            {
+                "arg": "--lr",
+                "help": "Learning rate",
+                "required": False,
+                "default": 5e-4,
+                "type": float,
+            },
+            {
+                "arg": "--scale-lr",
+                "help": "Scale learning rate",
+                "required": False,
+                "action": "store_true",
+            },
+            {
+                "arg": "--scheduler",
+                "help": "Learning rate scheduler",
+                "required": False,
+                "default": "constant",
+            },
+            {
+                "arg": "--warmup-steps",
+                "help": "Learning rate warmup steps",
+                "required": False,
+                "default": 0,
+                "type": int,
+            },
+            {
+                "arg": "--num-cycles",
+                "help": "Learning rate num cycles",
+                "required": False,
+                "default": 1,
+                "type": int,
+            },
+            {
+                "arg": "--lr-power",
+                "help": "Learning rate power",
+                "required": False,
+                "default": 1.0,
+                "type": float,
+            },
+            {
+                "arg": "--dataloader-num-workers",
+                "help": "Dataloader num workers",
+                "required": False,
+                "default": 0,
+                "type": int,
+            },
+            {
+                "arg": "--use-8bit-adam",
+                "help": "Use 8bit adam",
+                "required": False,
+                "action": "store_true",
+            },
+            {
+                "arg": "--adam-beta1",
+                "help": "Adam beta 1",
+                "required": False,
+                "default": 0.9,
+                "type": float,
+            },
+            {
+                "arg": "--adam-beta2",
+                "help": "Adam beta 2",
+                "required": False,
+                "default": 0.999,
+                "type": float,
+            },
+            {
+                "arg": "--adam-weight-decay",
+                "help": "Adam weight decay",
+                "required": False,
+                "default": 1e-2,
+                "type": float,
+            },
+            {
+                "arg": "--adam-epsilon",
+                "help": "Adam epsilon",
+                "required": False,
+                "default": 1e-8,
+                "type": float,
+            },
+            {
+                "arg": "--max-grad-norm",
+                "help": "Max grad norm",
+                "required": False,
+                "default": 1.0,
+                "type": float,
+            },
+            {
+                "arg": "--allow-tf32",
+                "help": "Allow TF32",
+                "required": False,
+                "action": "store_true",
+            },
+            {
+                "arg": "--prior-generation-precision",
+                "help": "Prior generation precision",
+                "required": False,
+                "type": str,
+            },
+            {
+                "arg": "--local-rank",
+                "help": "Local rank",
+                "required": False,
+                "default": -1,
+                "type": int,
+            },
+            {
+                "arg": "--xformers",
+                "help": "Enable xformers memory efficient attention",
+                "required": False,
+                "action": "store_true",
+            },
+            {
+                "arg": "--pre-compute-text-embeddings",
+                "help": "Pre compute text embeddings",
+                "required": False,
+                "action": "store_true",
+            },
+            {
+                "arg": "--tokenizer-max-length",
+                "help": "Tokenizer max length",
+                "required": False,
+                "type": int,
+            },
+            {
+                "arg": "--text-encoder-use-attention-mask",
+                "help": "Text encoder use attention mask",
+                "required": False,
+                "action": "store_true",
+            },
+            {
+                "arg": "--rank",
+                "help": "Rank",
+                "required": False,
+                "default": 4,
+                "type": int,
+            },
+            {
+                "arg": "--xl",
+                "help": "XL",
+                "required": False,
+                "action": "store_true",
+            },
+            {
+                "arg": "--fp16",
+                "help": "FP16",
+                "required": False,
+                "action": "store_true",
+            },
+            {
+                "arg": "--bf16",
+                "help": "BF16",
+                "required": False,
+                "action": "store_true",
+            },
+            {
+                "arg": "--hub-token",
+                "help": "Hub token",
+                "required": False,
+                "type": str,
+            },
+            {
+                "arg": "--hub-model-id",
+                "help": "Hub model id",
+                "required": False,
+                "type": str,
+            },
+            {
+                "arg": "--push-to-hub",
+                "help": "Push to hub",
+                "required": False,
+                "action": "store_true",
+            },
+            {
+                "arg": "--validation-prompt",
+                "help": "Validation prompt",
+                "required": False,
+                "type": str,
+            },
+            {
+                "arg": "--num-validation-images",
+                "help": "Number of validation images",
+                "required": False,
+                "default": 4,
+                "type": int,
+            },
+            {
+                "arg": "--validation-epochs",
+                "help": "Validation epochs",
+                "required": False,
+                "default": 50,
+                "type": int,
+            },
+            {
+                "arg": "--checkpoints-total-limit",
+                "help": "Checkpoints total limit",
+                "required": False,
+                "type": int,
+            },
+            {
+                "arg": "--validation-images",
+                "help": "Validation images",
+                "required": False,
+                "type": str,
+            },
+            {
+                "arg": "--logging",
+                "help": "Logging using tensorboard",
+                "required": False,
+                "action": "store_true",
+            },
+        ]
+
+        run_dreambooth_parser = parser.add_parser("dreambooth", description="✨ Run AutoTrain DreamBooth Training")
+        for arg in arg_list:
+            if "action" in arg:
+                run_dreambooth_parser.add_argument(
+                    arg["arg"],
+                    help=arg["help"],
+                    required=arg.get("required", False),
+                    action=arg.get("action"),
+                    default=arg.get("default"),
+                )
+            else:
+                run_dreambooth_parser.add_argument(
+                    arg["arg"],
+                    help=arg["help"],
+                    required=arg.get("required", False),
+                    type=arg.get("type"),
+                    default=arg.get("default"),
+                )
+        run_dreambooth_parser.set_defaults(func=run_dreambooth_command_factory)
+
+    def __init__(self, args):
+        self.args = args
+        logger.info(self.args)
+
+        store_true_arg_names = [
+            "center_crop",
+            "train_text_encoder",
+            "gradient_checkpointing",
+            "scale_lr",
+            "use_8bit_adam",
+            "allow_tf32",
+            "xformers",
+            "pre_compute_text_embeddings",
+            "text_encoder_use_attention_mask",
+            "xl",
+            "fp16",
+            "bf16",
+            "push_to_hub",
+            "logging",
+            "prior_preservation",
+        ]
+
+        for arg_name in store_true_arg_names:
+            if getattr(self.args, arg_name) is None:
+                setattr(self.args, arg_name, False)
+
+        if self.args.fp16 and self.args.bf16:
+            raise ValueError("❌ Please choose either FP16 or BF16")
+
+        # check if self.args.image_path is a directory with images
+        if not os.path.isdir(self.args.image_path):
+            raise ValueError("❌ Please specify a valid image directory")
+
+        # count the number of images in the directory. valid images are .jpg, .jpeg, .png
+        num_images = count_images(self.args.image_path)
+        if num_images == 0:
+            raise ValueError("❌ Please specify a valid image directory")
+
+        if self.args.push_to_hub:
+            if self.args.hub_model_id is None:
+                raise ValueError("❌ Please specify a hub model id")
+
+        if self.args.model in XL_MODELS:
+            self.args.xl = True
+
+    def run(self):
+        logger.info("Running DreamBooth Training")
+        params = DreamBoothTrainingParams(**vars(self.args))
+        train_dreambooth(params)

autotrain-advanced/src/autotrain/cli/run_llm.py

@@ -0,0 +1,489 @@
+from argparse import ArgumentParser
+
+from loguru import logger
+
+from autotrain.infer.text_generation import TextGenerationInference
+
+from ..trainers.clm import train as train_llm
+from ..trainers.utils import LLMTrainingParams
+from . import BaseAutoTrainCommand
+
+
+def run_llm_command_factory(args):
+    return RunAutoTrainLLMCommand(
+        args.train,
+        args.deploy,
+        args.inference,
+        args.data_path,
+        args.train_split,
+        args.valid_split,
+        args.text_column,
+        args.model,
+        args.learning_rate,
+        args.num_train_epochs,
+        args.train_batch_size,
+        args.eval_batch_size,
+        args.warmup_ratio,
+        args.gradient_accumulation_steps,
+        args.optimizer,
+        args.scheduler,
+        args.weight_decay,
+        args.max_grad_norm,
+        args.seed,
+        args.add_eos_token,
+        args.block_size,
+        args.use_peft,
+        args.lora_r,
+        args.lora_alpha,
+        args.lora_dropout,
+        args.training_type,
+        args.train_on_inputs,
+        args.logging_steps,
+        args.project_name,
+        args.evaluation_strategy,
+        args.save_total_limit,
+        args.save_strategy,
+        args.auto_find_batch_size,
+        args.fp16,
+        args.push_to_hub,
+        args.use_int8,
+        args.model_max_length,
+        args.repo_id,
+        args.use_int4,
+        args.trainer,
+        args.target_modules,
+    )
+
+
+class RunAutoTrainLLMCommand(BaseAutoTrainCommand):
+    @staticmethod
+    def register_subcommand(parser: ArgumentParser):
+        run_llm_parser = parser.add_parser(
+            "llm",
+            description="✨ Run AutoTrain LLM training/inference/deployment",
+        )
+        run_llm_parser.add_argument(
+            "--train",
+            help="Train the model",
+            required=False,
+            action="store_true",
+        )
+        run_llm_parser.add_argument(
+            "--deploy",
+            help="Deploy the model",
+            required=False,
+            action="store_true",
+        )
+        run_llm_parser.add_argument(
+            "--inference",
+            help="Run inference",
+            required=False,
+            action="store_true",
+        )
+        run_llm_parser.add_argument(
+            "--data_path",
+            help="Train dataset to use",
+            required=False,
+            type=str,
+        )
+        run_llm_parser.add_argument(
+            "--train_split",
+            help="Test dataset split to use",
+            required=False,
+            type=str,
+            default="train",
+        )
+        run_llm_parser.add_argument(
+            "--valid_split",
+            help="Validation dataset split to use",
+            required=False,
+            type=str,
+            default=None,
+        )
+        run_llm_parser.add_argument(
+            "--text_column",
+            help="Text column to use",
+            required=False,
+            type=str,
+            default="text",
+        )
+        run_llm_parser.add_argument(
+            "--model",
+            help="Model to use",
+            required=False,
+            type=str,
+        )
+        run_llm_parser.add_argument(
+            "--learning_rate",
+            help="Learning rate to use",
+            required=False,
+            type=float,
+            default=3e-5,
+        )
+        run_llm_parser.add_argument(
+            "--num_train_epochs",
+            help="Number of training epochs to use",
+            required=False,
+            type=int,
+            default=1,
+        )
+        run_llm_parser.add_argument(
+            "--train_batch_size",
+            help="Training batch size to use",
+            required=False,
+            type=int,
+            default=2,
+        )
+        run_llm_parser.add_argument(
+            "--eval_batch_size",
+            help="Evaluation batch size to use",
+            required=False,
+            type=int,
+            default=4,
+        )
+        run_llm_parser.add_argument(
+            "--warmup_ratio",
+            help="Warmup proportion to use",
+            required=False,
+            type=float,
+            default=0.1,
+        )
+        run_llm_parser.add_argument(
+            "--gradient_accumulation_steps",
+            help="Gradient accumulation steps to use",
+            required=False,
+            type=int,
+            default=1,
+        )
+        run_llm_parser.add_argument(
+            "--optimizer",
+            help="Optimizer to use",
+            required=False,
+            type=str,
+            default="adamw_torch",
+        )
+        run_llm_parser.add_argument(
+            "--scheduler",
+            help="Scheduler to use",
+            required=False,
+            type=str,
+            default="linear",
+        )
+        run_llm_parser.add_argument(
+            "--weight_decay",
+            help="Weight decay to use",
+            required=False,
+            type=float,
+            default=0.0,
+        )
+        run_llm_parser.add_argument(
+            "--max_grad_norm",
+            help="Max gradient norm to use",
+            required=False,
+            type=float,
+            default=1.0,
+        )
+        run_llm_parser.add_argument(
+            "--seed",
+            help="Seed to use",
+            required=False,
+            type=int,
+            default=42,
+        )
+        run_llm_parser.add_argument(
+            "--add_eos_token",
+            help="Add EOS token to use",
+            required=False,
+            action="store_true",
+        )
+        run_llm_parser.add_argument(
+            "--block_size",
+            help="Block size to use",
+            required=False,
+            type=int,
+            default=-1,
+        )
+        run_llm_parser.add_argument(
+            "--use_peft",
+            help="Use PEFT to use",
+            required=False,
+            action="store_true",
+        )
+        run_llm_parser.add_argument(
+            "--lora_r",
+            help="Lora r to use",
+            required=False,
+            type=int,
+            default=16,
+        )
+        run_llm_parser.add_argument(
+            "--lora_alpha",
+            help="Lora alpha to use",
+            required=False,
+            type=int,
+            default=32,
+        )
+        run_llm_parser.add_argument(
+            "--lora_dropout",
+            help="Lora dropout to use",
+            required=False,
+            type=float,
+            default=0.05,
+        )
+        run_llm_parser.add_argument(
+            "--training_type",
+            help="Training type to use",
+            required=False,
+            type=str,
+            default="generic",
+        )
+        run_llm_parser.add_argument(
+            "--train_on_inputs",
+            help="Train on inputs to use",
+            required=False,
+            action="store_true",
+        )
+        run_llm_parser.add_argument(
+            "--logging_steps",
+            help="Logging steps to use",
+            required=False,
+            type=int,
+            default=-1,
+        )
+        run_llm_parser.add_argument(
+            "--project_name",
+            help="Output directory",
+            required=False,
+            type=str,
+        )
+        run_llm_parser.add_argument(
+            "--evaluation_strategy",
+            help="Evaluation strategy to use",
+            required=False,
+            type=str,
+            default="epoch",
+        )
+        run_llm_parser.add_argument(
+            "--save_total_limit",
+            help="Save total limit to use",
+            required=False,
+            type=int,
+            default=1,
+        )
+        run_llm_parser.add_argument(
+            "--save_strategy",
+            help="Save strategy to use",
+            required=False,
+            type=str,
+            default="epoch",
+        )
+        run_llm_parser.add_argument(
+            "--auto_find_batch_size",
+            help="Auto find batch size True/False",
+            required=False,
+            action="store_true",
+        )
+        run_llm_parser.add_argument(
+            "--fp16",
+            help="FP16 True/False",
+            required=False,
+            action="store_true",
+        )
+        run_llm_parser.add_argument(
+            "--push_to_hub",
+            help="Push to hub True/False",
+            required=False,
+            action="store_true",
+        )
+        run_llm_parser.add_argument(
+            "--use_int8",
+            help="Use int8 True/False",
+            required=False,
+            action="store_true",
+        )
+        run_llm_parser.add_argument(
+            "--model_max_length",
+            help="Model max length to use",
+            required=False,
+            type=int,
+            default=1024,
+        )
+        run_llm_parser.add_argument(
+            "--repo_id",
+            help="Repo id for hugging face hub",
+            required=False,
+            type=str,
+        )
+        run_llm_parser.add_argument(
+            "--use_int4",
+            help="Use int4 True/False",
+            required=False,
+            action="store_true",
+        )
+        run_llm_parser.add_argument(
+            "--trainer",
+            help="Trainer type to use",
+            required=False,
+            type=str,
+            default="default",
+        )
+        run_llm_parser.add_argument(
+            "--target_modules",
+            help="Target modules to use",
+            required=False,
+            type=str,
+            default=None,
+        )
+
+        run_llm_parser.set_defaults(func=run_llm_command_factory)
+
+    def __init__(
+        self,
+        train,
+        deploy,
+        inference,
+        data_path,
+        train_split,
+        valid_split,
+        text_column,
+        model,
+        learning_rate,
+        num_train_epochs,
+        train_batch_size,
+        eval_batch_size,
+        warmup_ratio,
+        gradient_accumulation_steps,
+        optimizer,
+        scheduler,
+        weight_decay,
+        max_grad_norm,
+        seed,
+        add_eos_token,
+        block_size,
+        use_peft,
+        lora_r,
+        lora_alpha,
+        lora_dropout,
+        training_type,
+        train_on_inputs,
+        logging_steps,
+        project_name,
+        evaluation_strategy,
+        save_total_limit,
+        save_strategy,
+        auto_find_batch_size,
+        fp16,
+        push_to_hub,
+        use_int8,
+        model_max_length,
+        repo_id,
+        use_int4,
+        trainer,
+        target_modules,
+    ):
+        self.train = train
+        self.deploy = deploy
+        self.inference = inference
+        self.data_path = data_path
+        self.train_split = train_split
+        self.valid_split = valid_split
+        self.text_column = text_column
+        self.model = model
+        self.learning_rate = learning_rate
+        self.num_train_epochs = num_train_epochs
+        self.train_batch_size = train_batch_size
+        self.eval_batch_size = eval_batch_size
+        self.warmup_ratio = warmup_ratio
+        self.gradient_accumulation_steps = gradient_accumulation_steps
+        self.optimizer = optimizer
+        self.scheduler = scheduler
+        self.weight_decay = weight_decay
+        self.max_grad_norm = max_grad_norm
+        self.seed = seed
+        self.add_eos_token = add_eos_token
+        self.block_size = block_size
+        self.use_peft = use_peft
+        self.lora_r = lora_r
+        self.lora_alpha = lora_alpha
+        self.lora_dropout = lora_dropout
+        self.training_type = training_type
+        self.train_on_inputs = train_on_inputs
+        self.logging_steps = logging_steps
+        self.project_name = project_name
+        self.evaluation_strategy = evaluation_strategy
+        self.save_total_limit = save_total_limit
+        self.save_strategy = save_strategy
+        self.auto_find_batch_size = auto_find_batch_size
+        self.fp16 = fp16
+        self.push_to_hub = push_to_hub
+        self.use_int8 = use_int8
+        self.model_max_length = model_max_length
+        self.repo_id = repo_id
+        self.use_int4 = use_int4
+        self.trainer = trainer
+        self.target_modules = target_modules
+
+        if self.train:
+            if self.project_name is None:
+                raise ValueError("Project name must be specified")
+            if self.data_path is None:
+                raise ValueError("Data path must be specified")
+            if self.model is None:
+                raise ValueError("Model must be specified")
+            if self.push_to_hub:
+                if self.repo_id is None:
+                    raise ValueError("Repo id must be specified for push to hub")
+
+        if self.inference:
+            tgi = TextGenerationInference(self.project_name, use_int4=self.use_int4, use_int8=self.use_int8)
+            while True:
+                prompt = input("User: ")
+                if prompt == "exit()":
+                    break
+                print(f"Bot: {tgi.chat(prompt)}")
+
+    def run(self):
+        logger.info("Running LLM")
+        logger.info(f"Train: {self.train}")
+        if self.train:
+            params = LLMTrainingParams(
+                model_name=self.model,
+                data_path=self.data_path,
+                train_split=self.train_split,
+                valid_split=self.valid_split,
+                text_column=self.text_column,
+                learning_rate=self.learning_rate,
+                num_train_epochs=self.num_train_epochs,
+                train_batch_size=self.train_batch_size,
+                eval_batch_size=self.eval_batch_size,
+                warmup_ratio=self.warmup_ratio,
+                gradient_accumulation_steps=self.gradient_accumulation_steps,
+                optimizer=self.optimizer,
+                scheduler=self.scheduler,
+                weight_decay=self.weight_decay,
+                max_grad_norm=self.max_grad_norm,
+                seed=self.seed,
+                add_eos_token=self.add_eos_token,
+                block_size=self.block_size,
+                use_peft=self.use_peft,
+                lora_r=self.lora_r,
+                lora_alpha=self.lora_alpha,
+                lora_dropout=self.lora_dropout,
+                training_type=self.training_type,
+                train_on_inputs=self.train_on_inputs,
+                logging_steps=self.logging_steps,
+                project_name=self.project_name,
+                evaluation_strategy=self.evaluation_strategy,
+                save_total_limit=self.save_total_limit,
+                save_strategy=self.save_strategy,
+                auto_find_batch_size=self.auto_find_batch_size,
+                fp16=self.fp16,
+                push_to_hub=self.push_to_hub,
+                use_int8=self.use_int8,
+                model_max_length=self.model_max_length,
+                repo_id=self.repo_id,
+                use_int4=self.use_int4,
+                trainer=self.trainer,
+                target_modules=self.target_modules,
+            )
+            train_llm(params)

autotrain-advanced/src/autotrain/cli/run_setup.py

@@ -0,0 +1,61 @@
+import subprocess
+from argparse import ArgumentParser
+
+from loguru import logger
+
+from . import BaseAutoTrainCommand
+
+
+def run_app_command_factory(args):
+    return RunSetupCommand(args.update_torch)
+
+
+class RunSetupCommand(BaseAutoTrainCommand):
+    @staticmethod
+    def register_subcommand(parser: ArgumentParser):
+        run_setup_parser = parser.add_parser(
+            "setup",
+            description="✨ Run AutoTrain setup",
+        )
+        run_setup_parser.add_argument(
+            "--update-torch",
+            action="store_true",
+            help="Update PyTorch to latest version",
+        )
+        run_setup_parser.set_defaults(func=run_app_command_factory)
+
+    def __init__(self, update_torch: bool):
+        self.update_torch = update_torch
+
+    def run(self):
+        # install latest transformers
+        cmd = "pip uninstall -y transformers && pip install git+https://github.com/huggingface/transformers.git"
+        pipe = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        logger.info("Installing latest transformers@main")
+        _, _ = pipe.communicate()
+        logger.info("Successfully installed latest transformers")
+
+        cmd = "pip uninstall -y peft && pip install git+https://github.com/huggingface/peft.git"
+        pipe = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        logger.info("Installing latest peft@main")
+        _, _ = pipe.communicate()
+        logger.info("Successfully installed latest peft")
+
+        cmd = "pip uninstall -y diffusers && pip install git+https://github.com/huggingface/diffusers.git"
+        pipe = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        logger.info("Installing latest diffusers@main")
+        _, _ = pipe.communicate()
+        logger.info("Successfully installed latest diffusers")
+
+        cmd = "pip uninstall -y trl && pip install git+https://github.com/lvwerra/trl.git"
+        pipe = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        logger.info("Installing latest trl@main")
+        _, _ = pipe.communicate()
+        logger.info("Successfully installed latest trl")
+
+        if self.update_torch:
+            cmd = "pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118"
+            pipe = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            logger.info("Installing latest PyTorch")
+            _, _ = pipe.communicate()
+            logger.info("Successfully installed latest PyTorch")

autotrain-advanced/src/autotrain/config.py

@@ -0,0 +1,12 @@
+import os
+import sys
+
+from loguru import logger
+
+
+AUTOTRAIN_BACKEND_API = os.getenv("AUTOTRAIN_BACKEND_API", "https://api.autotrain.huggingface.co")
+
+HF_API = os.getenv("HF_API", "https://huggingface.co")
+
+
+logger.configure(handlers=[dict(sink=sys.stderr, format="> <level>{level:<7} {message}</level>")])

autotrain-advanced/src/autotrain/dataset.py

@@ -0,0 +1,344 @@
+import os
+import uuid
+import zipfile
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+from loguru import logger
+
+from autotrain.preprocessor.dreambooth import DreamboothPreprocessor
+from autotrain.preprocessor.tabular import (
+    TabularBinaryClassificationPreprocessor,
+    TabularMultiClassClassificationPreprocessor,
+    TabularSingleColumnRegressionPreprocessor,
+)
+from autotrain.preprocessor.text import (
+    LLMPreprocessor,
+    TextBinaryClassificationPreprocessor,
+    TextMultiClassClassificationPreprocessor,
+    TextSingleColumnRegressionPreprocessor,
+)
+from autotrain.preprocessor.vision import ImageClassificationPreprocessor
+
+
+def remove_non_image_files(folder):
+    # Define allowed image file extensions
+    allowed_extensions = {".jpg", ".jpeg", ".png", ".JPG", ".JPEG", ".PNG"}
+
+    # Iterate through all files in the folder
+    for root, dirs, files in os.walk(folder):
+        for file in files:
+            # Get the file extension
+            file_extension = os.path.splitext(file)[1]
+
+            # If the file extension is not in the allowed list, remove the file
+            if file_extension.lower() not in allowed_extensions:
+                file_path = os.path.join(root, file)
+                os.remove(file_path)
+                print(f"Removed file: {file_path}")
+
+        # Recursively call the function on each subfolder
+        for subfolder in dirs:
+            remove_non_image_files(os.path.join(root, subfolder))
+
+
+@dataclass
+class AutoTrainDreamboothDataset:
+    concept_images: List[Any]
+    concept_name: str
+    token: str
+    project_name: str
+    username: str
+
+    def __str__(self) -> str:
+        info = f"Dataset: {self.project_name} ({self.task})\n"
+        return info
+
+    def __post_init__(self):
+        self.task = "dreambooth"
+        logger.info(self.__str__())
+
+    @property
+    def num_samples(self):
+        return len(self.concept_images)
+
+    def prepare(self):
+        preprocessor = DreamboothPreprocessor(
+            concept_images=self.concept_images,
+            concept_name=self.concept_name,
+            token=self.token,
+            project_name=self.project_name,
+            username=self.username,
+        )
+        preprocessor.prepare()
+
+
+@dataclass
+class AutoTrainImageClassificationDataset:
+    train_data: str
+    token: str
+    project_name: str
+    username: str
+    valid_data: Optional[str] = None
+    percent_valid: Optional[float] = None
+
+    def __str__(self) -> str:
+        info = f"Dataset: {self.project_name} ({self.task})\n"
+        info += f"Train data: {self.train_data}\n"
+        info += f"Valid data: {self.valid_data}\n"
+        return info
+
+    def __post_init__(self):
+        self.task = "image_multi_class_classification"
+        if not self.valid_data and self.percent_valid is None:
+            self.percent_valid = 0.2
+        elif self.valid_data and self.percent_valid is not None:
+            raise ValueError("You can only specify one of valid_data or percent_valid")
+        elif self.valid_data:
+            self.percent_valid = 0.0
+        logger.info(self.__str__())
+
+        self.num_files = self._count_files()
+
+    @property
+    def num_samples(self):
+        return self.num_files
+
+    def _count_files(self):
+        num_files = 0
+        zip_ref = zipfile.ZipFile(self.train_data, "r")
+        for _ in zip_ref.namelist():
+            num_files += 1
+        if self.valid_data:
+            zip_ref = zipfile.ZipFile(self.valid_data, "r")
+            for _ in zip_ref.namelist():
+                num_files += 1
+        return num_files
+
+    def prepare(self):
+        cache_dir = os.environ.get("HF_HOME")
+        if not cache_dir:
+            cache_dir = os.path.join(os.path.expanduser("~"), ".cache", "huggingface")
+
+        random_uuid = uuid.uuid4()
+        train_dir = os.path.join(cache_dir, "autotrain", str(random_uuid))
+        os.makedirs(train_dir, exist_ok=True)
+        zip_ref = zipfile.ZipFile(self.train_data, "r")
+        zip_ref.extractall(train_dir)
+        # remove the __MACOSX directory
+        macosx_dir = os.path.join(train_dir, "__MACOSX")
+        if os.path.exists(macosx_dir):
+            os.system(f"rm -rf {macosx_dir}")
+        remove_non_image_files(train_dir)
+
+        valid_dir = None
+        if self.valid_data:
+            random_uuid = uuid.uuid4()
+            valid_dir = os.path.join(cache_dir, "autotrain", str(random_uuid))
+            os.makedirs(valid_dir, exist_ok=True)
+            zip_ref = zipfile.ZipFile(self.valid_data, "r")
+            zip_ref.extractall(valid_dir)
+            # remove the __MACOSX directory
+            macosx_dir = os.path.join(valid_dir, "__MACOSX")
+            if os.path.exists(macosx_dir):
+                os.system(f"rm -rf {macosx_dir}")
+            remove_non_image_files(valid_dir)
+
+        preprocessor = ImageClassificationPreprocessor(
+            train_data=train_dir,
+            valid_data=valid_dir,
+            token=self.token,
+            project_name=self.project_name,
+            username=self.username,
+        )
+        preprocessor.prepare()
+
+
+@dataclass
+class AutoTrainDataset:
+    train_data: List[str]
+    task: str
+    token: str
+    project_name: str
+    username: str
+    column_mapping: Optional[Dict[str, str]] = None
+    valid_data: Optional[List[str]] = None
+    percent_valid: Optional[float] = None
+
+    def __str__(self) -> str:
+        info = f"Dataset: {self.project_name} ({self.task})\n"
+        info += f"Train data: {self.train_data}\n"
+        info += f"Valid data: {self.valid_data}\n"
+        info += f"Column mapping: {self.column_mapping}\n"
+        return info
+
+    def __post_init__(self):
+        if not self.valid_data and self.percent_valid is None:
+            self.percent_valid = 0.2
+        elif self.valid_data and self.percent_valid is not None:
+            raise ValueError("You can only specify one of valid_data or percent_valid")
+        elif self.valid_data:
+            self.percent_valid = 0.0
+
+        self.train_df, self.valid_df = self._preprocess_data()
+        logger.info(self.__str__())
+
+    def _preprocess_data(self):
+        train_df = []
+        for file in self.train_data:
+            if isinstance(file, pd.DataFrame):
+                train_df.append(file)
+            else:
+                train_df.append(pd.read_csv(file))
+        if len(train_df) > 1:
+            train_df = pd.concat(train_df)
+        else:
+            train_df = train_df[0]
+
+        valid_df = None
+        if len(self.valid_data) > 0:
+            valid_df = []
+            for file in self.valid_data:
+                if isinstance(file, pd.DataFrame):
+                    valid_df.append(file)
+                else:
+                    valid_df.append(pd.read_csv(file))
+            if len(valid_df) > 1:
+                valid_df = pd.concat(valid_df)
+            else:
+                valid_df = valid_df[0]
+        return train_df, valid_df
+
+    @property
+    def num_samples(self):
+        return len(self.train_df) + len(self.valid_df) if self.valid_df is not None else len(self.train_df)
+
+    def prepare(self):
+        if self.task == "text_binary_classification":
+            text_column = self.column_mapping["text"]
+            label_column = self.column_mapping["label"]
+            preprocessor = TextBinaryClassificationPreprocessor(
+                train_data=self.train_df,
+                text_column=text_column,
+                label_column=label_column,
+                username=self.username,
+                project_name=self.project_name,
+                valid_data=self.valid_df,
+                test_size=self.percent_valid,
+                token=self.token,
+                seed=42,
+            )
+            preprocessor.prepare()
+
+        elif self.task == "text_multi_class_classification":
+            text_column = self.column_mapping["text"]
+            label_column = self.column_mapping["label"]
+            preprocessor = TextMultiClassClassificationPreprocessor(
+                train_data=self.train_df,
+                text_column=text_column,
+                label_column=label_column,
+                username=self.username,
+                project_name=self.project_name,
+                valid_data=self.valid_df,
+                test_size=self.percent_valid,
+                token=self.token,
+                seed=42,
+            )
+            preprocessor.prepare()
+
+        elif self.task == "text_single_column_regression":
+            text_column = self.column_mapping["text"]
+            label_column = self.column_mapping["label"]
+            preprocessor = TextSingleColumnRegressionPreprocessor(
+                train_data=self.train_df,
+                text_column=text_column,
+                label_column=label_column,
+                username=self.username,
+                project_name=self.project_name,
+                valid_data=self.valid_df,
+                test_size=self.percent_valid,
+                token=self.token,
+                seed=42,
+            )
+            preprocessor.prepare()
+
+        elif self.task == "lm_training":
+            text_column = self.column_mapping.get("text", None)
+            if text_column is None:
+                prompt_column = self.column_mapping["prompt"]
+                response_column = self.column_mapping["response"]
+            else:
+                prompt_column = None
+                response_column = None
+            context_column = self.column_mapping.get("context", None)
+            prompt_start_column = self.column_mapping.get("prompt_start", None)
+            preprocessor = LLMPreprocessor(
+                train_data=self.train_df,
+                text_column=text_column,
+                prompt_column=prompt_column,
+                response_column=response_column,
+                context_column=context_column,
+                prompt_start_column=prompt_start_column,
+                username=self.username,
+                project_name=self.project_name,
+                valid_data=self.valid_df,
+                test_size=self.percent_valid,
+                token=self.token,
+                seed=42,
+            )
+            preprocessor.prepare()
+
+        elif self.task == "tabular_binary_classification":
+            id_column = self.column_mapping["id"]
+            label_column = self.column_mapping["label"]
+            if len(id_column.strip()) == 0:
+                id_column = None
+            preprocessor = TabularBinaryClassificationPreprocessor(
+                train_data=self.train_df,
+                id_column=id_column,
+                label_column=label_column,
+                username=self.username,
+                project_name=self.project_name,
+                valid_data=self.valid_df,
+                test_size=self.percent_valid,
+                token=self.token,
+                seed=42,
+            )
+            preprocessor.prepare()
+        elif self.task == "tabular_multi_class_classification":
+            id_column = self.column_mapping["id"]
+            label_column = self.column_mapping["label"]
+            if len(id_column.strip()) == 0:
+                id_column = None
+            preprocessor = TabularMultiClassClassificationPreprocessor(
+                train_data=self.train_df,
+                id_column=id_column,
+                label_column=label_column,
+                username=self.username,
+                project_name=self.project_name,
+                valid_data=self.valid_df,
+                test_size=self.percent_valid,
+                token=self.token,
+                seed=42,
+            )
+            preprocessor.prepare()
+        elif self.task == "tabular_single_column_regression":
+            id_column = self.column_mapping["id"]
+            label_column = self.column_mapping["label"]
+            if len(id_column.strip()) == 0:
+                id_column = None
+            preprocessor = TabularSingleColumnRegressionPreprocessor(
+                train_data=self.train_df,
+                id_column=id_column,
+                label_column=label_column,
+                username=self.username,
+                project_name=self.project_name,
+                valid_data=self.valid_df,
+                test_size=self.percent_valid,
+                token=self.token,
+                seed=42,
+            )
+            preprocessor.prepare()
+        else:
+            raise ValueError(f"Task {self.task} not supported")

autotrain-advanced/src/autotrain/dreambooth_app.py

@@ -0,0 +1,485 @@
+import os
+import pty
+import random
+import shutil
+import string
+import subprocess
+
+import gradio as gr
+from huggingface_hub import HfApi, whoami
+
+
+# ❯ autotrain dreambooth --help
+# usage: autotrain <command> [<args>] dreambooth [-h] --model MODEL [--revision REVISION] [--tokenizer TOKENIZER] --image-path IMAGE_PATH
+#                                                [--class-image-path CLASS_IMAGE_PATH] --prompt PROMPT [--class-prompt CLASS_PROMPT]
+#                                                [--num-class-images NUM_CLASS_IMAGES] [--class-labels-conditioning CLASS_LABELS_CONDITIONING]
+#                                                [--prior-preservation] [--prior-loss-weight PRIOR_LOSS_WEIGHT] --output OUTPUT [--seed SEED]
+#                                                --resolution RESOLUTION [--center-crop] [--train-text-encoder] [--batch-size BATCH_SIZE]
+#                                                [--sample-batch-size SAMPLE_BATCH_SIZE] [--epochs EPOCHS] [--num-steps NUM_STEPS]
+#                                                [--checkpointing-steps CHECKPOINTING_STEPS] [--resume-from-checkpoint RESUME_FROM_CHECKPOINT]
+#                                                [--gradient-accumulation GRADIENT_ACCUMULATION] [--gradient-checkpointing] [--lr LR] [--scale-lr]
+#                                                [--scheduler SCHEDULER] [--warmup-steps WARMUP_STEPS] [--num-cycles NUM_CYCLES] [--lr-power LR_POWER]
+#                                                [--dataloader-num-workers DATALOADER_NUM_WORKERS] [--use-8bit-adam] [--adam-beta1 ADAM_BETA1]
+#                                                [--adam-beta2 ADAM_BETA2] [--adam-weight-decay ADAM_WEIGHT_DECAY] [--adam-epsilon ADAM_EPSILON]
+#                                                [--max-grad-norm MAX_GRAD_NORM] [--allow-tf32]
+#                                                [--prior-generation-precision PRIOR_GENERATION_PRECISION] [--local-rank LOCAL_RANK] [--xformers]
+#                                                [--pre-compute-text-embeddings] [--tokenizer-max-length TOKENIZER_MAX_LENGTH]
+#                                                [--text-encoder-use-attention-mask] [--rank RANK] [--xl] [--fp16] [--bf16] [--hub-token HUB_TOKEN]
+#                                                [--hub-model-id HUB_MODEL_ID] [--push-to-hub] [--validation-prompt VALIDATION_PROMPT]
+#                                                [--num-validation-images NUM_VALIDATION_IMAGES] [--validation-epochs VALIDATION_EPOCHS]
+#                                                [--checkpoints-total-limit CHECKPOINTS_TOTAL_LIMIT] [--validation-images VALIDATION_IMAGES]
+#                                                [--logging]
+
+REPO_ID = os.environ.get("REPO_ID")
+ALLOWED_FILE_TYPES = ["png", "jpg", "jpeg"]
+MODELS = [
+    "stabilityai/stable-diffusion-xl-base-1.0",
+    "runwayml/stable-diffusion-v1-5",
+    "stabilityai/stable-diffusion-2-1",
+    "stabilityai/stable-diffusion-2-1-base",
+]
+WELCOME_TEXT = """
+Welcome to the AutoTrain DreamBooth! This app allows you to train a DreamBooth model using AutoTrain.
+The app runs on HuggingFace Spaces. Your data is not stored anywhere.
+The trained model (LoRA) will be pushed to your HuggingFace Hub account.
+
+You need to use your HuggingFace Hub write [token](https://huggingface.co/settings/tokens) to push the model to your account.
+
+NOTE: This space requires GPU to train. Please make sure you have GPU enabled in space settings.
+Please make sure to shutdown / pause the space to avoid any additional charges.
+"""
+
+STEPS = """
+1. [Duplicate](https://huggingface.co/spaces/autotrain-projects/dreambooth?duplicate=true) this space
+2. Upgrade the space to GPU
+3. Enter your HuggingFace Hub write token
+4. Upload images and adjust prompt (remember the prompt!)
+5. Click on Train and wait for the training to finish
+6. Go to your HuggingFace Hub account to find the trained model
+
+NOTE: For any issues or feature requests, please open an issue [here](https://github.com/huggingface/autotrain-advanced/issues)
+"""
+
+
+def _update_project_name():
+    random_project_name = "-".join(
+        ["".join(random.choices(string.ascii_lowercase + string.digits, k=4)) for _ in range(3)]
+    )
+    # check if training tracker exists
+    if os.path.exists(os.path.join("/tmp", "training")):
+        return [
+            gr.Text.update(value=random_project_name, visible=True, interactive=True),
+            gr.Button.update(interactive=False),
+        ]
+    return [
+        gr.Text.update(value=random_project_name, visible=True, interactive=True),
+        gr.Button.update(interactive=True),
+    ]
+
+
+def run_command(cmd):
+    cmd = [str(c) for c in cmd]
+    print(f"Running command: {' '.join(cmd)}")
+    master, slave = pty.openpty()
+    p = subprocess.Popen(cmd, stdout=slave, stderr=slave)
+    os.close(slave)
+
+    while p.poll() is None:
+        try:
+            output = os.read(master, 1024).decode()
+        except OSError:
+            # Handle exception here, e.g. the pty was closed
+            break
+        else:
+            print(output, end="")
+
+
+def _run_training(
+    hub_token,
+    project_name,
+    model,
+    images,
+    prompt,
+    learning_rate,
+    num_steps,
+    batch_size,
+    gradient_accumulation_steps,
+    prior_preservation,
+    scale_lr,
+    use_8bit_adam,
+    train_text_encoder,
+    gradient_checkpointing,
+    center_crop,
+    prior_loss_weight,
+    num_cycles,
+    lr_power,
+    adam_beta1,
+    adam_beta2,
+    adam_weight_decay,
+    adam_epsilon,
+    max_grad_norm,
+    warmup_steps,
+    scheduler,
+    resolution,
+    fp16,
+):
+    if REPO_ID == "autotrain-projects/dreambooth":
+        return gr.Markdown.update(
+            value="❌ Please [duplicate](https://huggingface.co/spaces/autotrain-projects/dreambooth?duplicate=true) this space before training."
+        )
+
+    api = HfApi(token=hub_token)
+
+    if os.path.exists(os.path.join("/tmp", "training")):
+        return gr.Markdown.update(value="❌ Another training job is already running in this space.")
+
+    with open(os.path.join("/tmp", "training"), "w") as f:
+        f.write("training")
+
+    hub_model_id = whoami(token=hub_token)["name"] + "/" + str(project_name).strip()
+
+    image_path = "/tmp/data"
+    os.makedirs(image_path, exist_ok=True)
+    output_dir = "/tmp/model"
+    os.makedirs(output_dir, exist_ok=True)
+
+    for image in images:
+        shutil.copy(image.name, image_path)
+    cmd = [
+        "autotrain",
+        "dreambooth",
+        "--model",
+        model,
+        "--output",
+        output_dir,
+        "--image-path",
+        image_path,
+        "--prompt",
+        prompt,
+        "--resolution",
+        "1024",
+        "--batch-size",
+        batch_size,
+        "--num-steps",
+        num_steps,
+        "--gradient-accumulation",
+        gradient_accumulation_steps,
+        "--lr",
+        learning_rate,
+        "--scheduler",
+        scheduler,
+        "--warmup-steps",
+        warmup_steps,
+        "--num-cycles",
+        num_cycles,
+        "--lr-power",
+        lr_power,
+        "--adam-beta1",
+        adam_beta1,
+        "--adam-beta2",
+        adam_beta2,
+        "--adam-weight-decay",
+        adam_weight_decay,
+        "--adam-epsilon",
+        adam_epsilon,
+        "--max-grad-norm",
+        max_grad_norm,
+        "--prior-loss-weight",
+        prior_loss_weight,
+        "--push-to-hub",
+        "--hub-token",
+        hub_token,
+        "--hub-model-id",
+        hub_model_id,
+    ]
+
+    if prior_preservation:
+        cmd.append("--prior-preservation")
+    if scale_lr:
+        cmd.append("--scale-lr")
+    if use_8bit_adam:
+        cmd.append("--use-8bit-adam")
+    if train_text_encoder:
+        cmd.append("--train-text-encoder")
+    if gradient_checkpointing:
+        cmd.append("--gradient-checkpointing")
+    if center_crop:
+        cmd.append("--center-crop")
+    if fp16:
+        cmd.append("--fp16")
+
+    try:
+        run_command(cmd)
+        # delete the training tracker file in /tmp/
+        os.remove(os.path.join("/tmp", "training"))
+        # switch off space
+        if REPO_ID is not None:
+            api.pause_space(repo_id=REPO_ID)
+        return gr.Markdown.update(value=f"✅ Training finished! Model pushed to {hub_model_id}")
+    except Exception as e:
+        print(e)
+        print("Error running command")
+        # delete the training tracker file in /tmp/
+        os.remove(os.path.join("/tmp", "training"))
+        return gr.Markdown.update(value="❌ Error running command. Please try again.")
+
+
+def main():
+    with gr.Blocks(theme="freddyaboulton/dracula_revamped") as demo:
+        gr.Markdown("## 🤗 AutoTrain DreamBooth")
+        gr.Markdown(WELCOME_TEXT)
+        with gr.Accordion("Steps", open=False):
+            gr.Markdown(STEPS)
+        hub_token = gr.Textbox(
+            label="Hub Token",
+            value="",
+            lines=1,
+            max_lines=1,
+            interactive=True,
+            type="password",
+        )
+
+        with gr.Row():
+            with gr.Column():
+                project_name = gr.Textbox(
+                    label="Project name",
+                    value="",
+                    lines=1,
+                    max_lines=1,
+                    interactive=True,
+                )
+                model = gr.Dropdown(
+                    label="Model",
+                    choices=MODELS,
+                    value=MODELS[0],
+                    visible=True,
+                    interactive=True,
+                    elem_id="model",
+                    allow_custom_values=True,
+                )
+                images = gr.File(
+                    label="Images",
+                    file_types=ALLOWED_FILE_TYPES,
+                    file_count="multiple",
+                    visible=True,
+                    interactive=True,
+                )
+
+            with gr.Column():
+                prompt = gr.Textbox(
+                    label="Prompt",
+                    placeholder="photo of sks dog",
+                    lines=1,
+                )
+                with gr.Row():
+                    learning_rate = gr.Number(
+                        label="Learning Rate",
+                        value=1e-4,
+                        visible=True,
+                        interactive=True,
+                        elem_id="learning_rate",
+                    )
+                    num_steps = gr.Number(
+                        label="Number of Steps",
+                        value=500,
+                        visible=True,
+                        interactive=True,
+                        elem_id="num_steps",
+                        precision=0,
+                    )
+                    batch_size = gr.Number(
+                        label="Batch Size",
+                        value=1,
+                        visible=True,
+                        interactive=True,
+                        elem_id="batch_size",
+                        precision=0,
+                    )
+                with gr.Row():
+                    gradient_accumulation_steps = gr.Number(
+                        label="Gradient Accumulation Steps",
+                        value=4,
+                        visible=True,
+                        interactive=True,
+                        elem_id="gradient_accumulation_steps",
+                        precision=0,
+                    )
+                    resolution = gr.Number(
+                        label="Resolution",
+                        value=1024,
+                        visible=True,
+                        interactive=True,
+                        elem_id="resolution",
+                        precision=0,
+                    )
+                    scheduler = gr.Dropdown(
+                        label="Scheduler",
+                        choices=["cosine", "linear", "constant"],
+                        value="constant",
+                        visible=True,
+                        interactive=True,
+                        elem_id="scheduler",
+                    )
+            with gr.Column():
+                with gr.Group():
+                    fp16 = gr.Checkbox(
+                        label="FP16",
+                        value=True,
+                        visible=True,
+                        interactive=True,
+                        elem_id="fp16",
+                    )
+                    prior_preservation = gr.Checkbox(
+                        label="Prior Preservation",
+                        value=False,
+                        visible=True,
+                        interactive=True,
+                        elem_id="prior_preservation",
+                    )
+                    scale_lr = gr.Checkbox(
+                        label="Scale LR",
+                        value=False,
+                        visible=True,
+                        interactive=True,
+                        elem_id="scale_lr",
+                    )
+                    use_8bit_adam = gr.Checkbox(
+                        label="Use 8bit Adam",
+                        value=True,
+                        visible=True,
+                        interactive=True,
+                        elem_id="use_8bit_adam",
+                    )
+                    train_text_encoder = gr.Checkbox(
+                        label="Train Text Encoder",
+                        value=False,
+                        visible=True,
+                        interactive=True,
+                        elem_id="train_text_encoder",
+                    )
+                    gradient_checkpointing = gr.Checkbox(
+                        label="Gradient Checkpointing",
+                        value=False,
+                        visible=True,
+                        interactive=True,
+                        elem_id="gradient_checkpointing",
+                    )
+                    center_crop = gr.Checkbox(
+                        label="Center Crop",
+                        value=False,
+                        visible=True,
+                        interactive=True,
+                        elem_id="center_crop",
+                    )
+        with gr.Accordion("Advanced Parameters", open=False):
+            with gr.Row():
+                prior_loss_weight = gr.Number(
+                    label="Prior Loss Weight",
+                    value=1.0,
+                    visible=True,
+                    interactive=True,
+                    elem_id="prior_loss_weight",
+                )
+                num_cycles = gr.Number(
+                    label="Num Cycles",
+                    value=1,
+                    visible=True,
+                    interactive=True,
+                    elem_id="num_cycles",
+                    precision=0,
+                )
+                lr_power = gr.Number(
+                    label="LR Power",
+                    value=1,
+                    visible=True,
+                    interactive=True,
+                    elem_id="lr_power",
+                )
+
+                adam_beta1 = gr.Number(
+                    label="Adam Beta1",
+                    value=0.9,
+                    visible=True,
+                    interactive=True,
+                    elem_id="adam_beta1",
+                )
+                adam_beta2 = gr.Number(
+                    label="Adam Beta2",
+                    value=0.999,
+                    visible=True,
+                    interactive=True,
+                    elem_id="adam_beta2",
+                )
+                adam_weight_decay = gr.Number(
+                    label="Adam Weight Decay",
+                    value=1e-2,
+                    visible=True,
+                    interactive=True,
+                    elem_id="adam_weight_decay",
+                )
+                adam_epsilon = gr.Number(
+                    label="Adam Epsilon",
+                    value=1e-8,
+                    visible=True,
+                    interactive=True,
+                    elem_id="adam_epsilon",
+                )
+                max_grad_norm = gr.Number(
+                    label="Max Grad Norm",
+                    value=1,
+                    visible=True,
+                    interactive=True,
+                    elem_id="max_grad_norm",
+                )
+                warmup_steps = gr.Number(
+                    label="Warmup Steps",
+                    value=0,
+                    visible=True,
+                    interactive=True,
+                    elem_id="warmup_steps",
+                    precision=0,
+                )
+
+        train_button = gr.Button(value="Train", elem_id="train")
+        output_md = gr.Markdown("## Output")
+        inputs = [
+            hub_token,
+            project_name,
+            model,
+            images,
+            prompt,
+            learning_rate,
+            num_steps,
+            batch_size,
+            gradient_accumulation_steps,
+            prior_preservation,
+            scale_lr,
+            use_8bit_adam,
+            train_text_encoder,
+            gradient_checkpointing,
+            center_crop,
+            prior_loss_weight,
+            num_cycles,
+            lr_power,
+            adam_beta1,
+            adam_beta2,
+            adam_weight_decay,
+            adam_epsilon,
+            max_grad_norm,
+            warmup_steps,
+            scheduler,
+            resolution,
+            fp16,
+        ]
+
+        train_button.click(_run_training, inputs=inputs, outputs=output_md)
+        demo.load(
+            _update_project_name,
+            outputs=[project_name, train_button],
+        )
+    return demo
+
+
+if __name__ == "__main__":
+    demo = main()
+    demo.launch()

autotrain-advanced/src/autotrain/help.py

@@ -0,0 +1,28 @@
+APP_AUTOTRAIN_USERNAME = """Please choose the user or organization who is creating the AutoTrain Project.
+In case of non-free tier, this user or organization will be billed.
+"""
+
+APP_PROJECT_NAME = """A unique name for the AutoTrain Project.
+This name will be used to identify the project in the AutoTrain dashboard."""
+
+
+APP_IMAGE_CLASSIFICATION_DATA_HELP = """The data for the Image Classification task should be in the following format:
+- The data should be in a zip file.
+- The zip file should contain multiple folders (the classes), each folder should contain images of a single class.
+- The name of the folder should be the name of the class.
+- The images must be jpeg, jpg or png.
+- There should be at least 5 images per class.
+- There should not be any other files in the zip file.
+- There should not be any other folders inside the zip folder.
+"""
+
+APP_LM_TRAINING_TYPE = """There are two types of Language Model Training:
+- generic
+- chat
+
+In the generic mode, you provide a CSV with a text column which has already been formatted by you for training a language model.
+In the chat mode, you provide a CSV with two or three text columns: prompt, context (optional) and response.
+Context column can be empty for samples if not needed. You can also have a "prompt start" column. If provided, "prompt start" will be prepended before the prompt column.
+
+Please see [this](https://huggingface.co/datasets/tatsu-lab/alpaca) dataset which has both formats in the same dataset.
+"""

autotrain-advanced/src/autotrain/infer/text_generation.py

@@ -0,0 +1,50 @@
+from dataclasses import dataclass
+from typing import Optional
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig
+
+
+@dataclass
+class TextGenerationInference:
+    model_path: str = "gpt2"
+    use_int4: Optional[bool] = False
+    use_int8: Optional[bool] = False
+    temperature: Optional[float] = 1.0
+    top_k: Optional[int] = 50
+    top_p: Optional[float] = 0.95
+    repetition_penalty: Optional[float] = 1.0
+    num_return_sequences: Optional[int] = 1
+    num_beams: Optional[int] = 1
+    max_new_tokens: Optional[int] = 1024
+    do_sample: Optional[bool] = True
+
+    def __post_init__(self):
+        self.model = AutoModelForCausalLM.from_pretrained(
+            self.model_path,
+            load_in_4bit=self.use_int4,
+            load_in_8bit=self.use_int8,
+            torch_dtype=torch.float16,
+            trust_remote_code=True,
+            device_map="auto",
+        )
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_path, trust_remote_code=True)
+        self.model.eval()
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.generation_config = GenerationConfig(
+            temperature=self.temperature,
+            top_k=self.top_k,
+            top_p=self.top_p,
+            repetition_penalty=self.repetition_penalty,
+            num_return_sequences=self.num_return_sequences,
+            num_beams=self.num_beams,
+            max_length=self.max_new_tokens,
+            eos_token_id=self.tokenizer.eos_token_id,
+            do_sample=self.do_sample,
+            max_new_tokens=self.max_new_tokens,
+        )
+
+    def chat(self, prompt):
+        inputs = self.tokenizer([prompt], return_tensors="pt").to(self.device)
+        outputs = self.model.generate(**inputs, generation_config=self.generation_config)
+        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)

autotrain-advanced/src/autotrain/languages.py

@@ -0,0 +1,19 @@
+SUPPORTED_LANGUAGES = [
+    "en",
+    "ar",
+    "bn",
+    "de",
+    "es",
+    "fi",
+    "fr",
+    "hi",
+    "it",
+    "ja",
+    "ko",
+    "nl",
+    "pt",
+    "sv",
+    "tr",
+    "zh",
+    "unk",
+]

autotrain-advanced/src/autotrain/params.py

@@ -0,0 +1,512 @@
+from dataclasses import dataclass
+from typing import Literal
+
+import gradio as gr
+from pydantic import BaseModel, Field
+
+from autotrain.languages import SUPPORTED_LANGUAGES
+from autotrain.tasks import TASKS
+
+
+class LoraR:
+    TYPE = "int"
+    MIN_VALUE = 1
+    MAX_VALUE = 100
+    DEFAULT = 16
+    STEP = 1
+    STREAMLIT_INPUT = "number_input"
+    PRETTY_NAME = "LoRA R"
+    GRADIO_INPUT = gr.Slider(minimum=MIN_VALUE, maximum=MAX_VALUE, value=DEFAULT, step=STEP)
+
+
+class LoraAlpha:
+    TYPE = "int"
+    MIN_VALUE = 1
+    MAX_VALUE = 256
+    DEFAULT = 32
+    STEP = 1
+    STREAMLIT_INPUT = "number_input"
+    PRETTY_NAME = "LoRA Alpha"
+    GRADIO_INPUT = gr.Slider(minimum=MIN_VALUE, maximum=MAX_VALUE, value=DEFAULT, step=STEP)
+
+
+class LoraDropout:
+    TYPE = "float"
+    MIN_VALUE = 0.0
+    MAX_VALUE = 1.0
+    DEFAULT = 0.05
+    STEP = 0.01
+    STREAMLIT_INPUT = "number_input"
+    PRETTY_NAME = "LoRA Dropout"
+    GRADIO_INPUT = gr.Slider(minimum=MIN_VALUE, maximum=MAX_VALUE, value=DEFAULT, step=STEP)
+
+
+class LearningRate:
+    TYPE = "float"
+    MIN_VALUE = 1e-7
+    MAX_VALUE = 1e-1
+    DEFAULT = 1e-3
+    STEP = 1e-6
+    FORMAT = "%.2E"
+    STREAMLIT_INPUT = "number_input"
+    PRETTY_NAME = "Learning Rate"
+    GRADIO_INPUT = gr.Slider(minimum=MIN_VALUE, maximum=MAX_VALUE, value=DEFAULT, step=STEP)
+
+
+class LMLearningRate(LearningRate):
+    DEFAULT = 5e-5
+
+
+class Optimizer:
+    TYPE = "str"
+    DEFAULT = "adamw_torch"
+    CHOICES = ["adamw_torch", "adamw_hf", "sgd", "adafactor", "adagrad"]
+    STREAMLIT_INPUT = "selectbox"
+    PRETTY_NAME = "Optimizer"
+    GRADIO_INPUT = gr.Dropdown(CHOICES, value=DEFAULT)
+
+
+class LMTrainingType:
+    TYPE = "str"
+    DEFAULT = "generic"
+    CHOICES = ["generic", "chat"]
+    STREAMLIT_INPUT = "selectbox"
+    PRETTY_NAME = "LM Training Type"
+    GRAIDO_INPUT = gr.Dropdown(CHOICES, value=DEFAULT)
+
+
+class Scheduler:
+    TYPE = "str"
+    DEFAULT = "linear"
+    CHOICES = ["linear", "cosine"]
+    STREAMLIT_INPUT = "selectbox"
+    PRETTY_NAME = "Scheduler"
+    GRADIO_INPUT = gr.Dropdown(CHOICES, value=DEFAULT)
+
+
+class TrainBatchSize:
+    TYPE = "int"
+    MIN_VALUE = 1
+    MAX_VALUE = 128
+    DEFAULT = 2
+    STEP = 2
+    STREAMLIT_INPUT = "number_input"
+    PRETTY_NAME = "Train Batch Size"
+    GRADIO_INPUT = gr.Slider(minimum=MIN_VALUE, maximum=MAX_VALUE, value=DEFAULT, step=STEP)
+
+
+class LMTrainBatchSize(TrainBatchSize):
+    DEFAULT = 4
+
+
+class Epochs:
+    TYPE = "int"
+    MIN_VALUE = 1
+    MAX_VALUE = 1000
+    DEFAULT = 10
+    STREAMLIT_INPUT = "number_input"
+    PRETTY_NAME = "Epochs"
+    GRADIO_INPUT = gr.Number(value=DEFAULT)
+
+
+class LMEpochs(Epochs):
+    DEFAULT = 1
+
+
+class PercentageWarmup:
+    TYPE = "float"
+    MIN_VALUE = 0.0
+    MAX_VALUE = 1.0
+    DEFAULT = 0.1
+    STEP = 0.01
+    STREAMLIT_INPUT = "number_input"
+    PRETTY_NAME = "Percentage Warmup"
+    GRADIO_INPUT = gr.Slider(minimum=MIN_VALUE, maximum=MAX_VALUE, value=DEFAULT, step=STEP)
+
+
+class GradientAccumulationSteps:
+    TYPE = "int"
+    MIN_VALUE = 1
+    MAX_VALUE = 100
+    DEFAULT = 1
+    STREAMLIT_INPUT = "number_input"
+    PRETTY_NAME = "Gradient Accumulation Steps"
+    GRADIO_INPUT = gr.Number(value=DEFAULT)
+
+
+class WeightDecay:
+    TYPE = "float"
+    MIN_VALUE = 0.0
+    MAX_VALUE = 1.0
+    DEFAULT = 0.0
+    STREAMLIT_INPUT = "number_input"
+    PRETTY_NAME = "Weight Decay"
+    GRADIO_INPUT = gr.Number(value=DEFAULT)
+
+
+class SourceLanguage:
+    TYPE = "str"
+    DEFAULT = "en"
+    CHOICES = SUPPORTED_LANGUAGES
+    STREAMLIT_INPUT = "selectbox"
+    PRETTY_NAME = "Source Language"
+    GRADIO_INPUT = gr.Dropdown(CHOICES, value=DEFAULT)
+
+
+class TargetLanguage:
+    TYPE = "str"
+    DEFAULT = "en"
+    CHOICES = SUPPORTED_LANGUAGES
+    STREAMLIT_INPUT = "selectbox"
+    PRETTY_NAME = "Target Language"
+    GRADIO_INPUT = gr.Dropdown(CHOICES, value=DEFAULT)
+
+
+class NumModels:
+    TYPE = "int"
+    MIN_VALUE = 1
+    MAX_VALUE = 25
+    DEFAULT = 1
+    STREAMLIT_INPUT = "number_input"
+    PRETTY_NAME = "Number of Models"
+    GRADIO_INPUT = gr.Slider(minimum=MIN_VALUE, maximum=MAX_VALUE, value=DEFAULT, step=1)
+
+
+class DBNumSteps:
+    TYPE = "int"
+    MIN_VALUE = 100
+    MAX_VALUE = 10000
+    DEFAULT = 1500
+    STREAMLIT_INPUT = "number_input"
+    PRETTY_NAME = "Number of Steps"
+    GRADIO_INPUT = gr.Slider(minimum=MIN_VALUE, maximum=MAX_VALUE, value=DEFAULT, step=100)
+
+
+class DBTextEncoderStepsPercentage:
+    TYPE = "int"
+    MIN_VALUE = 1
+    MAX_VALUE = 100
+    DEFAULT = 30
+    STREAMLIT_INPUT = "number_input"
+    PRETTY_NAME = "Text encoder steps percentage"
+    GRADIO_INPUT = gr.Slider(minimum=MIN_VALUE, maximum=MAX_VALUE, value=DEFAULT, step=1)
+
+
+class DBPriorPreservation:
+    TYPE = "bool"
+    DEFAULT = False
+    STREAMLIT_INPUT = "checkbox"
+    PRETTY_NAME = "Prior preservation"
+    GRADIO_INPUT = gr.Dropdown(["True", "False"], value="False")
+
+
+class ImageSize:
+    TYPE = "int"
+    MIN_VALUE = 64
+    MAX_VALUE = 2048
+    DEFAULT = 512
+    STREAMLIT_INPUT = "number_input"
+    PRETTY_NAME = "Image Size"
+    GRADIO_INPUT = gr.Slider(minimum=MIN_VALUE, maximum=MAX_VALUE, value=DEFAULT, step=64)
+
+
+class DreamboothConceptType:
+    TYPE = "str"
+    DEFAULT = "person"
+    CHOICES = ["person", "object"]
+    STREAMLIT_INPUT = "selectbox"
+    PRETTY_NAME = "Concept Type"
+    GRADIO_INPUT = gr.Dropdown(CHOICES, value=DEFAULT)
+
+
+class SourceLanguageUnk:
+    TYPE = "str"
+    DEFAULT = "unk"
+    CHOICES = ["unk"]
+    STREAMLIT_INPUT = "selectbox"
+    PRETTY_NAME = "Source Language"
+    GRADIO_INPUT = gr.Dropdown(CHOICES, value=DEFAULT)
+
+
+class HubModel:
+    TYPE = "str"
+    DEFAULT = "bert-base-uncased"
+    PRETTY_NAME = "Hub Model"
+    GRADIO_INPUT = gr.Textbox(lines=1, max_lines=1, label="Hub Model")
+
+
+class TextBinaryClassificationParams(BaseModel):
+    task: Literal["text_binary_classification"]
+    learning_rate: float = Field(5e-5, title="Learning rate")
+    num_train_epochs: int = Field(3, title="Number of training epochs")
+    max_seq_length: int = Field(128, title="Max sequence length")
+    train_batch_size: int = Field(32, title="Training batch size")
+    warmup_ratio: float = Field(0.1, title="Warmup proportion")
+    gradient_accumulation_steps: int = Field(1, title="Gradient accumulation steps")
+    optimizer: str = Field("adamw_torch", title="Optimizer")
+    scheduler: str = Field("linear", title="Scheduler")
+    weight_decay: float = Field(0.0, title="Weight decay")
+    max_grad_norm: float = Field(1.0, title="Max gradient norm")
+    seed: int = Field(42, title="Seed")
+
+
+class TextMultiClassClassificationParams(BaseModel):
+    task: Literal["text_multi_class_classification"]
+    learning_rate: float = Field(5e-5, title="Learning rate")
+    num_train_epochs: int = Field(3, title="Number of training epochs")
+    max_seq_length: int = Field(128, title="Max sequence length")
+    train_batch_size: int = Field(32, title="Training batch size")
+    warmup_ratio: float = Field(0.1, title="Warmup proportion")
+    gradient_accumulation_steps: int = Field(1, title="Gradient accumulation steps")
+    optimizer: str = Field("adamw_torch", title="Optimizer")
+    scheduler: str = Field("linear", title="Scheduler")
+    weight_decay: float = Field(0.0, title="Weight decay")
+    max_grad_norm: float = Field(1.0, title="Max gradient norm")
+    seed: int = Field(42, title="Seed")
+
+
+class DreamboothParams(BaseModel):
+    task: Literal["dreambooth"]
+    num_steps: int = Field(1500, title="Number of steps")
+    image_size: int = Field(512, title="Image size")
+    text_encoder_steps_percentage: int = Field(30, title="Text encoder steps percentage")
+    prior_preservation: bool = Field(False, title="Prior preservation")
+    learning_rate: float = Field(2e-6, title="Learning rate")
+    train_batch_size: int = Field(1, title="Training batch size")
+    gradient_accumulation_steps: int = Field(1, title="Gradient accumulation steps")
+
+
+class ImageBinaryClassificationParams(BaseModel):
+    task: Literal["image_binary_classification"]
+    learning_rate: float = Field(3e-5, title="Learning rate")
+    num_train_epochs: int = Field(3, title="Number of training epochs")
+    train_batch_size: int = Field(8, title="Training batch size")
+    warmup_ratio: float = Field(0.1, title="Warmup proportion")
+    gradient_accumulation_steps: int = Field(1, title="Gradient accumulation steps")
+    optimizer: str = Field("adamw_torch", title="Optimizer")
+    scheduler: str = Field("linear", title="Scheduler")
+    weight_decay: float = Field(0.0, title="Weight decay")
+    max_grad_norm: float = Field(1.0, title="Max gradient norm")
+    seed: int = Field(42, title="Seed")
+
+
+class ImageMultiClassClassificationParams(BaseModel):
+    task: Literal["image_multi_class_classification"]
+    learning_rate: float = Field(3e-5, title="Learning rate")
+    num_train_epochs: int = Field(3, title="Number of training epochs")
+    train_batch_size: int = Field(8, title="Training batch size")
+    warmup_ratio: float = Field(0.1, title="Warmup proportion")
+    gradient_accumulation_steps: int = Field(1, title="Gradient accumulation steps")
+    optimizer: str = Field("adamw_torch", title="Optimizer")
+    scheduler: str = Field("linear", title="Scheduler")
+    weight_decay: float = Field(0.0, title="Weight decay")
+    max_grad_norm: float = Field(1.0, title="Max gradient norm")
+    seed: int = Field(42, title="Seed")
+
+
+class LMTrainingParams(BaseModel):
+    task: Literal["lm_training"]
+    learning_rate: float = Field(3e-5, title="Learning rate")
+    num_train_epochs: int = Field(3, title="Number of training epochs")
+    train_batch_size: int = Field(8, title="Training batch size")
+    warmup_ratio: float = Field(0.1, title="Warmup proportion")
+    gradient_accumulation_steps: int = Field(1, title="Gradient accumulation steps")
+    optimizer: str = Field("adamw_torch", title="Optimizer")
+    scheduler: str = Field("linear", title="Scheduler")
+    weight_decay: float = Field(0.0, title="Weight decay")
+    max_grad_norm: float = Field(1.0, title="Max gradient norm")
+    seed: int = Field(42, title="Seed")
+    add_eos_token: bool = Field(True, title="Add EOS token")
+    block_size: int = Field(-1, title="Block size")
+    lora_r: int = Field(16, title="Lora r")
+    lora_alpha: int = Field(32, title="Lora alpha")
+    lora_dropout: float = Field(0.05, title="Lora dropout")
+    training_type: str = Field("generic", title="Training type")
+    train_on_inputs: bool = Field(False, title="Train on inputs")
+
+
+@dataclass
+class Params:
+    task: str
+    param_choice: str
+    model_choice: str
+
+    def __post_init__(self):
+        # task should be one of the keys in TASKS
+        if self.task not in TASKS:
+            raise ValueError(f"task must be one of {TASKS.keys()}")
+        self.task_id = TASKS[self.task]
+
+        if self.param_choice not in ("autotrain", "manual"):
+            raise ValueError("param_choice must be either autotrain or manual")
+
+        if self.model_choice not in ("autotrain", "hub_model"):
+            raise ValueError("model_choice must be either autotrain or hub_model")
+
+    def _dreambooth(self):
+        if self.param_choice == "manual":
+            return {
+                "hub_model": HubModel,
+                "image_size": ImageSize,
+                "learning_rate": LearningRate,
+                "train_batch_size": TrainBatchSize,
+                "num_steps": DBNumSteps,
+                "gradient_accumulation_steps": GradientAccumulationSteps,
+            }
+        if self.param_choice == "autotrain":
+            if self.model_choice == "hub_model":
+                return {
+                    "hub_model": HubModel,
+                    "image_size": ImageSize,
+                    "num_models": NumModels,
+                }
+            else:
+                return {
+                    "num_models": NumModels,
+                }
+
+    def _tabular_binary_classification(self):
+        return {
+            "num_models": NumModels,
+        }
+
+    def _lm_training(self):
+        if self.param_choice == "manual":
+            return {
+                "hub_model": HubModel,
+                "learning_rate": LMLearningRate,
+                "optimizer": Optimizer,
+                "scheduler": Scheduler,
+                "train_batch_size": LMTrainBatchSize,
+                "num_train_epochs": LMEpochs,
+                "percentage_warmup": PercentageWarmup,
+                "gradient_accumulation_steps": GradientAccumulationSteps,
+                "weight_decay": WeightDecay,
+                "lora_r": LoraR,
+                "lora_alpha": LoraAlpha,
+                "lora_dropout": LoraDropout,
+                "training_type": LMTrainingType,
+            }
+        if self.param_choice == "autotrain":
+            if self.model_choice == "autotrain":
+                return {
+                    "num_models": NumModels,
+                    "training_type": LMTrainingType,
+                }
+            else:
+                return {
+                    "hub_model": HubModel,
+                    "num_models": NumModels,
+                    "training_type": LMTrainingType,
+                }
+        raise ValueError("param_choice must be either autotrain or manual")
+
+    def _tabular_multi_class_classification(self):
+        return self._tabular_binary_classification()
+
+    def _tabular_single_column_regression(self):
+        return self._tabular_binary_classification()
+
+    def tabular_multi_label_classification(self):
+        return self._tabular_binary_classification()
+
+    def _text_binary_classification(self):
+        if self.param_choice == "manual":
+            return {
+                "hub_model": HubModel,
+                "learning_rate": LearningRate,
+                "optimizer": Optimizer,
+                "scheduler": Scheduler,
+                "train_batch_size": TrainBatchSize,
+                "num_train_epochs": Epochs,
+                "percentage_warmup": PercentageWarmup,
+                "gradient_accumulation_steps": GradientAccumulationSteps,
+                "weight_decay": WeightDecay,
+            }
+        if self.param_choice == "autotrain":
+            if self.model_choice == "autotrain":
+                return {
+                    "source_language": SourceLanguage,
+                    "num_models": NumModels,
+                }
+            return {
+                "hub_model": HubModel,
+                "source_language": SourceLanguageUnk,
+                "num_models": NumModels,
+            }
+        raise ValueError("param_choice must be either autotrain or manual")
+
+    def _text_multi_class_classification(self):
+        return self._text_binary_classification()
+
+    def _text_entity_extraction(self):
+        return self._text_binary_classification()
+
+    def _text_single_column_regression(self):
+        return self._text_binary_classification()
+
+    def _text_natural_language_inference(self):
+        return self._text_binary_classification()
+
+    def _image_binary_classification(self):
+        if self.param_choice == "manual":
+            return {
+                "hub_model": HubModel,
+                "learning_rate": LearningRate,
+                "optimizer": Optimizer,
+                "scheduler": Scheduler,
+                "train_batch_size": TrainBatchSize,
+                "num_train_epochs": Epochs,
+                "percentage_warmup": PercentageWarmup,
+                "gradient_accumulation_steps": GradientAccumulationSteps,
+                "weight_decay": WeightDecay,
+            }
+        if self.param_choice == "autotrain":
+            if self.model_choice == "autotrain":
+                return {
+                    "num_models": NumModels,
+                }
+            return {
+                "hub_model": HubModel,
+                "num_models": NumModels,
+            }
+        raise ValueError("param_choice must be either autotrain or manual")
+
+    def _image_multi_class_classification(self):
+        return self._image_binary_classification()
+
+    def get(self):
+        if self.task in ("text_binary_classification", "text_multi_class_classification"):
+            return self._text_binary_classification()
+
+        if self.task == "text_entity_extraction":
+            return self._text_entity_extraction()
+
+        if self.task == "text_single_column_regression":
+            return self._text_single_column_regression()
+
+        if self.task == "text_natural_language_inference":
+            return self._text_natural_language_inference()
+
+        if self.task == "tabular_binary_classification":
+            return self._tabular_binary_classification()
+
+        if self.task == "tabular_multi_class_classification":
+            return self._tabular_multi_class_classification()
+
+        if self.task == "tabular_single_column_regression":
+            return self._tabular_single_column_regression()
+
+        if self.task == "tabular_multi_label_classification":
+            return self.tabular_multi_label_classification()
+
+        if self.task in ("image_binary_classification", "image_multi_class_classification"):
+            return self._image_binary_classification()
+
+        if self.task == "dreambooth":
+            return self._dreambooth()
+
+        if self.task == "lm_training":
+            return self._lm_training()
+
+        raise ValueError(f"task {self.task} not supported")

autotrain-advanced/src/autotrain/preprocessor/dreambooth.py

@@ -0,0 +1,62 @@
+import io
+import json
+from dataclasses import dataclass
+from typing import Any, List
+
+from huggingface_hub import HfApi, create_repo
+from loguru import logger
+
+
+@dataclass
+class DreamboothPreprocessor:
+    concept_images: List[Any]
+    concept_name: str
+    username: str
+    project_name: str
+    token: str
+
+    def __post_init__(self):
+        self.repo_name = f"{self.username}/autotrain-data-{self.project_name}"
+        try:
+            create_repo(
+                repo_id=self.repo_name,
+                repo_type="dataset",
+                token=self.token,
+                private=True,
+                exist_ok=False,
+            )
+        except Exception:
+            logger.error("Error creating repo")
+            raise ValueError("Error creating repo")
+
+    def _upload_concept_images(self, file, api):
+        logger.info(f"Uploading {file} to concept1")
+        api.upload_file(
+            path_or_fileobj=file.name,
+            path_in_repo=f"concept1/{file.name.split('/')[-1]}",
+            repo_id=self.repo_name,
+            repo_type="dataset",
+            token=self.token,
+        )
+
+    def _upload_concept_prompts(self, api):
+        _prompts = {}
+        _prompts["concept1"] = self.concept_name
+
+        prompts = json.dumps(_prompts)
+        prompts = prompts.encode("utf-8")
+        prompts = io.BytesIO(prompts)
+        api.upload_file(
+            path_or_fileobj=prompts,
+            path_in_repo="prompts.json",
+            repo_id=self.repo_name,
+            repo_type="dataset",
+            token=self.token,
+        )
+
+    def prepare(self):
+        api = HfApi()
+        for _file in self.concept_images:
+            self._upload_concept_images(_file, api)
+
+        self._upload_concept_prompts(api)

autotrain-advanced/src/autotrain/preprocessor/tabular.py

@@ -0,0 +1,99 @@
+from dataclasses import dataclass
+from typing import Optional
+
+import pandas as pd
+from datasets import Dataset
+from sklearn.model_selection import train_test_split
+
+
+RESERVED_COLUMNS = ["autotrain_id", "autotrain_label"]
+
+
+@dataclass
+class TabularBinaryClassificationPreprocessor:
+    train_data: pd.DataFrame
+    label_column: str
+    username: str
+    project_name: str
+    id_column: Optional[str] = None
+    valid_data: Optional[pd.DataFrame] = None
+    test_size: Optional[float] = 0.2
+    seed: Optional[int] = 42
+
+    def __post_init__(self):
+        # check if id_column and label_column are in train_data
+        if self.id_column is not None:
+            if self.id_column not in self.train_data.columns:
+                raise ValueError(f"{self.id_column} not in train data")
+
+        if self.label_column not in self.train_data.columns:
+            raise ValueError(f"{self.label_column} not in train data")
+
+        # check if id_column and label_column are in valid_data
+        if self.valid_data is not None:
+            if self.id_column is not None:
+                if self.id_column not in self.valid_data.columns:
+                    raise ValueError(f"{self.id_column} not in valid data")
+            if self.label_column not in self.valid_data.columns:
+                raise ValueError(f"{self.label_column} not in valid data")
+
+        # make sure no reserved columns are in train_data or valid_data
+        for column in RESERVED_COLUMNS:
+            if column in self.train_data.columns:
+                raise ValueError(f"{column} is a reserved column name")
+            if self.valid_data is not None:
+                if column in self.valid_data.columns:
+                    raise ValueError(f"{column} is a reserved column name")
+
+    def split(self):
+        if self.valid_data is not None:
+            return self.train_data, self.valid_data
+        else:
+            train_df, valid_df = train_test_split(
+                self.train_data,
+                test_size=self.test_size,
+                random_state=self.seed,
+                stratify=self.train_data[self.label_column],
+            )
+            train_df = train_df.reset_index(drop=True)
+            valid_df = valid_df.reset_index(drop=True)
+            return train_df, valid_df
+
+    def prepare_columns(self, train_df, valid_df):
+        train_df.loc[:, "autotrain_id"] = train_df[self.id_column]
+        train_df.loc[:, "autotrain_label"] = train_df[self.label_column]
+        valid_df.loc[:, "autotrain_id"] = valid_df[self.id_column]
+        valid_df.loc[:, "autotrain_label"] = valid_df[self.label_column]
+
+        # drop id_column and label_column
+        train_df = train_df.drop(columns=[self.id_column, self.label_column])
+        valid_df = valid_df.drop(columns=[self.id_column, self.label_column])
+        return train_df, valid_df
+
+    def prepare(self):
+        train_df, valid_df = self.split()
+        train_df, valid_df = self.prepare_columns(train_df, valid_df)
+        train_df = Dataset.from_pandas(train_df)
+        valid_df = Dataset.from_pandas(valid_df)
+        train_df.push_to_hub(f"{self.username}/autotrain-data-{self.project_name}", split="train", private=True)
+        valid_df.push_to_hub(f"{self.username}/autotrain-data-{self.project_name}", split="validation", private=True)
+        return train_df, valid_df
+
+
+class TabularMultiClassClassificationPreprocessor(TabularBinaryClassificationPreprocessor):
+    pass
+
+
+class TabularSingleColumnRegressionPreprocessor(TabularBinaryClassificationPreprocessor):
+    def split(self):
+        if self.valid_data is not None:
+            return self.train_data, self.valid_data
+        else:
+            train_df, valid_df = train_test_split(
+                self.train_data,
+                test_size=self.test_size,
+                random_state=self.seed,
+            )
+            train_df = train_df.reset_index(drop=True)
+            valid_df = valid_df.reset_index(drop=True)
+            return train_df, valid_df