Initial commit.

Signed-off-by: Kieran Fraser <Kieran.Fraser@ibm.com>

.gitignore

@@ -0,0 +1,259 @@
+# 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/
+
+!.vscode/*.code-snippets
+!.vscode/extensions.json
+!.vscode/launch.json
+!.vscode/settings.json
+!.vscode/tasks.json
+*$py.class
+*.code-workspace
+*.cover
+*.egg
+*.egg-info/
+*.iws
+*.log
+*.manifest
+*.mo
+*.pot
+*.py,cover
+*.py[cod]
+*.sage.py
+*.so
+*.spec
+*.vsix
+.Python
+.cache
+.coverage
+.coverage.*
+.dmypy.json
+.eggs/
+.env
+.history
+.history/
+.hypothesis/
+.idea/$CACHE_FILE$
+.idea/**/aws.xml
+.idea/**/azureSettings.xml
+.idea/**/contentModel.xml
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/dataSources/
+.idea/**/dbnavigator.xml
+.idea/**/dictionaries
+.idea/**/dynamic.xml
+.idea/**/gradle.xml
+.idea/**/libraries
+.idea/**/markdown-navigator-enh.xml
+.idea/**/markdown-navigator.xml
+.idea/**/markdown-navigator/
+.idea/**/mongoSettings.xml
+.idea/**/shelf
+.idea/**/sonarIssues.xml
+.idea/**/sonarlint/
+.idea/**/sqlDataSources.xml
+.idea/**/tasks.xml
+.idea/**/uiDesigner.xml
+.idea/**/usage.statistics.xml
+.idea/**/workspace.xml
+.idea/caches/build_file_checksums.ser
+.idea/codestream.xml
+.idea/httpRequests
+.idea/replstate.xml
+.idea/sonarlint/
+.idea_modules/
+.installed.cfg
+.ionide
+.ipynb_checkpoints
+.mypy_cache/
+.nox/
+.pdm.toml
+.pybuilder/
+.pyre/
+.pytest_cache/
+.pytype/
+.ropeproject
+.scrapy
+.spyderproject
+.spyproject
+.tox/
+.venv
+.vscode/*
+.vscode/*.code-snippets
+.webassets-cache
+/site
+ENV/
+MANIFEST
+__pycache__/
+__pypackages__/
+atlassian-ide-plugin.xml
+build/
+celerybeat-schedule
+celerybeat.pid
+cmake-build-*/
+com_crashlytics_export_strings.xml
+cover/
+coverage.xml
+crashlytics-build.properties
+crashlytics.properties
+cython_debug/
+db.sqlite3
+db.sqlite3-journal
+develop-eggs/
+dist/
+dmypy.json
+docs/_build/
+downloads/
+eggs/
+env.bak/
+env/
+fabric.properties
+htmlcov/
+instance/
+ipython_config.py
+lib/
+lib64/
+local_settings.py
+nosetests.xml
+out/
+parts/
+pip-delete-this-directory.txt
+pip-log.txt
+profile_default/
+sdist/
+share/python-wheels/
+target/
+var/
+venv.bak/
+venv/
+wheels/
+Pipfile
+.vscode
+Pipfile.lock

README.md

@@ -1,12 +1,13 @@
 ---
-title: Art Huggingface Poisoning
-emoji: 📉
-colorFrom: gray
-colorTo: gray
+title: Red-teaming Hugging Face with ART [Poisoning]
+emoji: 🧪
+colorFrom: red
+colorTo: green
 sdk: gradio
 sdk_version: 4.15.0
 app_file: app.py
 pinned: false
+license: mit
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,333 @@
+'''
+ART Gradio Example App [Evasion]
+
+To run: 
+- clone the repository
+- execute: gradio examples/gradio_app.py or python examples/gradio_app.py
+- navigate to local URL e.g. http://127.0.0.1:7860
+'''
+
+import gradio as gr
+import numpy as np
+from carbon_theme import Carbon
+
+import numpy as np
+import torch
+import transformers
+
+from art.estimators.classification.hugging_face import HuggingFaceClassifierPyTorch
+from art.attacks.evasion import ProjectedGradientDescentPyTorch, AdversarialPatchPyTorch
+from art.utils import load_dataset
+
+from art.attacks.poisoning import PoisoningAttackBackdoor
+from art.attacks.poisoning.perturbations import insert_image
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+css = """
+
+.custom-text {
+    --text-md: 20px !important;
+    --text-sm: 18px !important;
+    --block-info-text-size: var(--text-sm);
+    --block-label-text-size: var(--text-sm);
+    --block-title-text-size: var(--text-md);
+    --body-text-size: var(--text-md);
+    --button-small-text-size: var(--text-md);
+    --checkbox-label-text-size: var(--text-md);
+    --input-text-size: var(--text-md);
+    --prose-text-size: var(--text-md);
+    --section-header-text-size: var(--text-md);
+}
+.input-image { margin: auto !important }
+.plot-padding { padding: 20px; }
+.eta-bar.svelte-1occ011.svelte-1occ011 {
+    background: #ccccff !important;
+}
+.center-text { text-align: center !important }
+.larger-gap { gap: 100px !important; }
+.symbols { text-align: center !important; margin: auto !important; }
+
+div.svelte-15lo0d8>*, div.svelte-15lo0d8>.form > * {
+    min-width: 0px !important;
+}
+"""
+
+def sample_imagenette():
+    import torchvision
+    label_names = [
+            'fish',
+            'dog',
+            'cassette player',
+            'chainsaw',
+            'church',
+            'french horn',
+            'garbage truck',
+            'gas pump',
+            'golf ball',
+            'parachutte',
+        ]
+    transform = torchvision.transforms.Compose([
+        torchvision.transforms.Resize((224, 224)),
+        torchvision.transforms.ToTensor(),
+    ])
+    train_dataset = torchvision.datasets.ImageFolder(root="./data/imagenette2-320/train", transform=transform)
+    labels = np.asarray(train_dataset.targets)
+    classes = np.unique(labels)
+    samples_per_class = 1
+
+    x_subset = []
+    y_subset = []
+
+    for c in classes:
+        indices = np.where(labels == c)[0][:samples_per_class]
+        for i in indices:
+            x_subset.append(train_dataset[i][0])
+            y_subset.append(train_dataset[i][1])
+
+    x_subset = np.stack(x_subset)
+    y_subset = np.asarray(y_subset)
+    
+    gallery_out = []
+    for i, im in enumerate(x_subset):
+        gallery_out.append( (im.transpose(1,2,0), label_names[y_subset[i]]) )
+    return gallery_out
+
+def clf_poison_evaluate(*args):
+    label_names = [
+            'fish',
+            'dog',
+            'cassette player',
+            'chainsaw',
+            'church',
+            'french horn',
+            'garbage truck',
+            'gas pump',
+            'golf ball',
+            'parachutte',
+        ]
+    
+    attack = args[0]
+    trigger_image = args[1]
+    target_class = args[2]
+
+    target_class = label_names.index(target_class)
+    
+    model = transformers.AutoModelForImageClassification.from_pretrained(
+        'facebook/deit-tiny-distilled-patch16-224',
+        ignore_mismatched_sizes=True,
+        force_download=True,
+        num_labels=10
+    )
+    optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
+    loss_fn = torch.nn.CrossEntropyLoss()
+
+    poison_hf_model = HuggingFaceClassifierPyTorch(
+        model=model,
+        loss=loss_fn,
+        optimizer=optimizer,
+        input_shape=(3, 224, 224),
+        nb_classes=10,
+        clip_values=(0, 1),
+    )
+    
+    model_checkpoint_path = './poisoned_models/deit_imagenette_poisoned_model_'+str(target_class)+'.pt'
+    poison_hf_model.model.load_state_dict(torch.load(model_checkpoint_path, map_location=device))
+        
+    import torchvision
+    transform = torchvision.transforms.Compose([
+        torchvision.transforms.Resize((224, 224)),
+        torchvision.transforms.ToTensor(),
+    ])
+    train_dataset = torchvision.datasets.ImageFolder(root="./data/imagenette2-320/train", transform=transform)
+    labels = np.asarray(train_dataset.targets)
+    classes = np.unique(labels)
+    samples_per_class = 10
+
+    x_subset = []
+    y_subset = []
+
+    for c in classes:
+        indices = np.where(labels == c)[0][:samples_per_class]
+        for i in indices:
+            x_subset.append(train_dataset[i][0])
+            y_subset.append(train_dataset[i][1])
+
+    x_subset = np.stack(x_subset)
+    y_subset = np.asarray(y_subset)
+        
+    if attack == "Backdoor":
+        from PIL import Image
+        im = Image.fromarray(trigger_image)
+        im.save("./tmp.png")
+        
+        def poison_func(x):
+            return insert_image(
+                x,
+                backdoor_path='./baby-on-board.png',
+                channels_first=True,
+                random=False,
+                x_shift=0,
+                y_shift=0,
+                size=(32, 32),
+                mode='RGB',
+                blend=0.8
+            )
+            
+        backdoor = PoisoningAttackBackdoor(poison_func)
+        source_class = 0
+        poison_percent = 0.5
+
+        x_poison = np.copy(x_subset)
+        y_poison = np.copy(y_subset)
+        is_poison = np.zeros(len(x_subset)).astype(bool)
+
+        indices = np.where(y_subset == source_class)[0]
+        num_poison = int(poison_percent * len(indices))
+
+        for i in indices[:num_poison]:
+            x_poison[i], _ = backdoor.poison(x_poison[i], [])
+            y_poison[i] = target_class
+            is_poison[i] = True
+
+        poison_indices = np.where(is_poison)[0]
+        #poison_hf_model.fit(x_poison, y_poison, nb_epochs=2)
+        
+        clean_x = x_poison[~is_poison]
+        clean_y = y_poison[~is_poison]
+
+        outputs = poison_hf_model.predict(clean_x)
+        clean_preds = np.argmax(outputs, axis=1)
+        clean_acc = np.mean(clean_preds == clean_y)
+        
+        clean_out = []
+        for i, im in enumerate(clean_x):
+            clean_out.append( (im.transpose(1,2,0), label_names[clean_preds[i]]) )
+        
+        poison_x = x_poison[is_poison]
+        poison_y = y_poison[is_poison]
+
+        outputs = poison_hf_model.predict(poison_x)
+        poison_preds = np.argmax(outputs, axis=1)
+        poison_acc = np.mean(poison_preds == poison_y)
+        
+        poison_out = []
+        for i, im in enumerate(poison_x):
+            poison_out.append( (im.transpose(1,2,0), label_names[poison_preds[i]]) )
+            
+        
+        return clean_out, poison_out, clean_acc, poison_acc
+  
+def show_params(type):
+    '''
+    Show model parameters based on selected model type
+    '''
+    if type!="Example":
+        return gr.Column(visible=True)
+    return gr.Column(visible=False)  
+
+# e.g. To use a local alternative theme: carbon_theme = Carbon()
+carbon_theme = Carbon()
+with gr.Blocks(css=css, theme='Tshackelton/IBMPlex-DenseReadable') as demo:
+    import art
+    text = art.__version__
+    
+    with gr.Row(elem_classes="custom-text"):
+        with gr.Column(scale=1,):
+            gr.Image(value="./art_lfai.png", show_label=False, show_download_button=False, width=100, show_share_button=False)
+        with gr.Column(scale=2):
+            gr.Markdown(f"<h1>🧪 Red-teaming HuggingFace with ART [Poisoning]</h1>", elem_classes="plot-padding")
+        
+    
+    gr.Markdown('''<p style="font-size: 20px; text-align: justify">ℹ️ Red-teaming in AI is an activity where we masquerade
+                as evil attackers 😈 and attempt to find vulnerabilities in our AI models. Identifying scenarios where
+                our AI models do not work as expected, or fail, is important as it helps us better understand
+                its limitations and vulnerability when deployed in the real world 🧐</p>''')
+    gr.Markdown('''<p style="font-size: 20px; text-align: justify">ℹ️ By attacking our AI models ourselves, we can better the risks associated with use
+                in the real world and implement mechanisms which can mitigate and protect our model. The example below demonstrates a
+                common red-team workflow to assess model vulnerability to data poisoning attacks 🧪</p>''')
+    
+    gr.Markdown('''<p style="font-size: 18px; text-align: justify"><i>Check out the full suite of features provided by ART <a href="https://github.com/Trusted-AI/adversarial-robustness-toolbox"
+                    target="blank_">here</a>.</i>
+                    add link to notebook</p>''')
+    
+    gr.Markdown('''<hr/>''')
+    
+    
+    with gr.Row(elem_classes=["larger-gap", "custom-text"]):
+        with gr.Column(scale=1):
+            gr.Markdown('''<p style="font-size: 20px; text-align: justify">ℹ️ First lets set the scene. You have a dataset of images, such as Imagenette.</p>''')
+            gr.Markdown('''<p style="font-size: 18px; text-align: justify"><i>Note: Imagenette is a subset of 10 easily classified classes from Imagenet as shown.</i></p>''')
+            gr.Markdown('''<p style="font-size: 20px; text-align: justify">ℹ️ Your goal is to have an AI model capable of classifying these images. So you 
+                        find a pre-trained model from Hugging Face,
+                        such as Meta's Distilled Data-efficient Image Transformer, which has been trained on this data (or so you think ☠️).</p>''')
+        with gr.Column(scale=1): 
+            gr.Markdown('''
+                            <p style="font-size: 20px;"><b>Hugging Face dataset:</b> 
+                            <a href="https://huggingface.co/datasets/frgfm/imagenette" target="_blank">Imagenette</a></p>
+                            <p style="font-size: 18px; padding-left: 20px;"><i>Imagenette labels:</i>
+                                <i>{fish, dog, cassette player, chain saw, church, French horn, garbage truck, gas pump, golf ball, parachute}</i>
+                            </p>
+                            <p style="font-size: 20px;"><b>Hugging Face model:</b><br/>
+                            <a href="https://huggingface.co/facebook/deit-tiny-patch16-224"
+                            target="_blank">facebook/deit-tiny-distilled-patch16-224</a></p>
+                            <br/>
+                            <p style="font-size: 20px;">👀 take a look at the sample images from the Imagenette dataset and their respective labels.</p>
+                        ''')
+        with gr.Column(scale=1):
+            gr.Gallery(label="Imagenette", preview=False, value=sample_imagenette(), height=420)
+            
+    gr.Markdown('''<hr/>''')
+    
+    gr.Markdown('''<p style="text-align: justify; font-size: 18px">ℹ️ Now as a responsible AI expert, you wish to assert that your model is not vulnerable to
+                attacks which might manipulate the prediction. For instance, fish become classified as dogs or golf balls. To do this, you will deploy
+                a backdoor poisoning attack against your own model and assess its performance.</p>''')
+
+    with gr.Row(elem_classes="custom-text"):
+        with gr.Column(scale=1):
+            attack = gr.Textbox(visible=True, value="Backdoor", label="Attack", interactive=False)
+            target_class = gr.Radio(label="Target class", info="The class you wish to force the model to predict.",
+                                        choices=['dog',
+                                        'cassette player',
+                                        'chainsaw',
+                                        'church',
+                                        'french horn',
+                                        'garbage truck',
+                                        'gas pump',
+                                        'golf ball',
+                                        'parachutte',], value='dog')
+            eval_btn_patch = gr.Button("Evaluate")
+    with gr.Row(elem_classes="custom-text"):
+        with gr.Column(scale=10):
+            clean_gallery = gr.Gallery(label="Clean", preview=False, show_download_button=True)
+            clean_accuracy = gr.Number(label="Clean Accuracy", precision=2)
+        with gr.Column(scale=1, min_width='0px', elem_classes='symbols'):
+            gr.Markdown('''➕''')
+        with gr.Column(scale=5):
+            trigger_image = gr.Image(label="Trigger Image",  value="./baby-on-board.png", interactive=False)
+        with gr.Column(scale=1, min_width='0px'):
+            gr.Markdown('''🟰''', elem_classes='symbols')
+        with gr.Column(scale=10):
+            poison_gallery = gr.Gallery(label="Poisoned", preview=False, show_download_button=True)
+            poison_success = gr.Number(label="Poison Success", precision=2)
+        
+    eval_btn_patch.click(clf_poison_evaluate, inputs=[attack, trigger_image, target_class],
+                outputs=[clean_gallery, poison_gallery, clean_accuracy, poison_success])  
+        
+    
+        
+        
+    
+    gr.Markdown('''<br/>''')
+            
+if __name__ == "__main__":
+    
+    # For development
+    demo.launch(show_api=False, debug=True, share=False,
+                server_name="0.0.0.0", 
+                server_port=7777, 
+                ssl_verify=False,
+                max_threads=20)
+                
+    # For deployment
+    '''demo.launch(share=True, ssl_verify=False)'''

carbon_colors.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+
+class Color:
+    all = []
+
+    def __init__(
+        self,
+        c50: str,
+        c100: str,
+        c200: str,
+        c300: str,
+        c400: str,
+        c500: str,
+        c600: str,
+        c700: str,
+        c800: str,
+        c900: str,
+        c950: str,
+        name: str | None = None,
+    ):
+        self.c50 = c50
+        self.c100 = c100
+        self.c200 = c200
+        self.c300 = c300
+        self.c400 = c400
+        self.c500 = c500
+        self.c600 = c600
+        self.c700 = c700
+        self.c800 = c800
+        self.c900 = c900
+        self.c950 = c950
+        self.name = name
+        Color.all.append(self)
+
+    def expand(self) -> list[str]:
+        return [
+            self.c50,
+            self.c100,
+            self.c200,
+            self.c300,
+            self.c400,
+            self.c500,
+            self.c600,
+            self.c700,
+            self.c800,
+            self.c900,
+            self.c950,
+        ]
+
+
+black = Color(
+    name="black",
+    c50="#000000",
+    c100="#000000",
+    c200="#000000",
+    c300="#000000",
+    c400="#000000",
+    c500="#000000",
+    c600="#000000",
+    c700="#000000",
+    c800="#000000",
+    c900="#000000",
+    c950="#000000",
+)
+
+blackHover = Color(
+    name="blackHover",
+    c50="#212121",
+    c100="#212121",
+    c200="#212121",
+    c300="#212121",
+    c400="#212121",
+    c500="#212121",
+    c600="#212121",
+    c700="#212121",
+    c800="#212121",
+    c900="#212121",
+    c950="#212121",
+)
+
+white = Color(
+    name="white",
+    c50="#ffffff",
+    c100="#ffffff",
+    c200="#ffffff",
+    c300="#ffffff",
+    c400="#ffffff",
+    c500="#ffffff",
+    c600="#ffffff",
+    c700="#ffffff",
+    c800="#ffffff",
+    c900="#ffffff",
+    c950="#ffffff",
+)
+
+whiteHover = Color(
+    name="whiteHover",
+    c50="#e8e8e8",
+    c100="#e8e8e8",
+    c200="#e8e8e8",
+    c300="#e8e8e8",
+    c400="#e8e8e8",
+    c500="#e8e8e8",
+    c600="#e8e8e8",
+    c700="#e8e8e8",
+    c800="#e8e8e8",
+    c900="#e8e8e8",
+    c950="#e8e8e8",
+)
+
+red = Color(
+    name="red",
+    c50="#fff1f1",
+    c100="#ffd7d9",
+    c200="#ffb3b8",
+    c300="#ff8389",
+    c400="#fa4d56",
+    c500="#da1e28",
+    c600="#a2191f",
+    c700="#750e13",
+    c800="#520408",
+    c900="#2d0709",
+    c950="#2d0709",
+)
+
+redHover = Color(
+    name="redHover",
+    c50="#540d11",
+    c100="#66050a",
+    c200="#921118",
+    c300="#c21e25",
+    c400="#b81922",
+    c500="#ee0713",
+    c600="#ff6168",
+    c700="#ff99a0",
+    c800="#ffc2c5",
+    c900="#ffe0e0",
+    c950="#ffe0e0",
+)
+
+blue = Color(
+    name="blue",
+    c50="#edf5ff",
+    c100="#d0e2ff",
+    c200="#a6c8ff",
+    c300="#78a9ff",
+    c400="#4589ff",
+    c500="#0f62fe",
+    c600="#0043ce",
+    c700="#002d9c",
+    c800="#001d6c",
+    c900="#001141",
+    c950="#001141",
+)
+
+blueHover = Color(
+    name="blueHover",
+    
+    c50="#001f75",
+    c100="#00258a",
+    c200="#0039c7",
+    c300="#0053ff",
+    c400="#0050e6",
+    c500="#1f70ff",
+    c600="#5c97ff",
+    c700="#8ab6ff",
+    c800="#b8d3ff",
+    c900="#dbebff",
+    c950="#dbebff",
+)
+
+

carbon_theme.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from typing import Iterable
+
+from gradio.themes.base import Base
+from gradio.themes.utils import colors, fonts, sizes
+import carbon_colors
+
+
+class Carbon(Base):
+    def __init__(
+        self,
+        *,
+        primary_hue: carbon_colors.Color | str = carbon_colors.white,
+        secondary_hue: carbon_colors.Color | str = carbon_colors.red,
+        neutral_hue: carbon_colors.Color | str = carbon_colors.blue,
+        spacing_size: sizes.Size | str = sizes.spacing_lg,
+        radius_size: sizes.Size | str = sizes.radius_none,
+        text_size: sizes.Size | str = sizes.text_md,
+        font: fonts.Font
+        | str
+        | Iterable[fonts.Font | str] = (
+            fonts.GoogleFont("IBM Plex Mono"),
+            fonts.GoogleFont("IBM Plex Sans"),
+            fonts.GoogleFont("IBM Plex Serif"),
+        ),
+        font_mono: fonts.Font
+        | str
+        | Iterable[fonts.Font | str] = (
+            fonts.GoogleFont("IBM Plex Mono"),
+        ),
+    ):
+        super().__init__(
+            primary_hue=primary_hue,
+            secondary_hue=secondary_hue,
+            neutral_hue=neutral_hue,
+            spacing_size=spacing_size,
+            radius_size=radius_size,
+            text_size=text_size,
+            font=font,
+            font_mono=font_mono,
+        )
+        self.name = "carbon"
+        super().set(
+            # Colors 
+            slider_color="*neutral_900", 
+            slider_color_dark="*neutral_500",
+            body_text_color="*neutral_900",
+            block_label_text_color="*body_text_color",
+            block_title_text_color="*body_text_color",
+            body_text_color_subdued="*neutral_700",
+            background_fill_primary_dark="*neutral_900",
+            background_fill_secondary_dark="*neutral_800",
+            block_background_fill_dark="*neutral_800",
+            input_background_fill_dark="*neutral_700",
+            # Button Colors
+            button_primary_background_fill=carbon_colors.blue.c500,
+            button_primary_background_fill_hover="*neutral_300",
+            button_primary_text_color="white",
+            button_primary_background_fill_dark="*neutral_600",
+            button_primary_background_fill_hover_dark="*neutral_600",
+            button_primary_text_color_dark="white",
+            button_secondary_background_fill="*button_primary_background_fill",
+            button_secondary_background_fill_hover="*button_primary_background_fill_hover",
+            button_secondary_text_color="*button_primary_text_color",
+            button_cancel_background_fill="*button_primary_background_fill",
+            button_cancel_background_fill_hover="*button_primary_background_fill_hover",
+            button_cancel_text_color="*button_primary_text_color",
+            checkbox_background_color=carbon_colors.black.c50,
+            checkbox_label_background_fill="*button_primary_background_fill",
+            checkbox_label_background_fill_hover="*button_primary_background_fill_hover",
+            checkbox_label_text_color="*button_primary_text_color",
+            checkbox_background_color_selected=carbon_colors.black.c50,
+            checkbox_border_width="1px",
+            checkbox_border_width_dark="1px",
+            checkbox_border_color=carbon_colors.white.c50,
+            checkbox_border_color_dark=carbon_colors.white.c50,
+            
+            checkbox_border_color_focus=carbon_colors.blue.c900,
+            checkbox_border_color_focus_dark=carbon_colors.blue.c900,
+            checkbox_border_color_selected=carbon_colors.white.c50,
+            checkbox_border_color_selected_dark=carbon_colors.white.c50,
+            
+            checkbox_background_color_hover=carbon_colors.black.c50,
+            checkbox_background_color_hover_dark=carbon_colors.black.c50,
+            checkbox_background_color_dark=carbon_colors.black.c50,
+            checkbox_background_color_selected_dark=carbon_colors.black.c50,
+            # Padding
+            checkbox_label_padding="16px",
+            button_large_padding="*spacing_lg",
+            button_small_padding="*spacing_sm",
+            # Borders
+            block_border_width="0px",
+            block_border_width_dark="1px",
+            shadow_drop_lg="0 1px 4px 0 rgb(0 0 0 / 0.1)",
+            block_shadow="*shadow_drop_lg",
+            block_shadow_dark="none",
+            # Block Labels
+            block_title_text_weight="600",
+            block_label_text_weight="600",
+            block_label_text_size="*text_md",
+        )