@huggingface/tasks 0.2.0 → 0.2.2

package/src/tasks/text-classification/inference.ts

@@ -0,0 +1,51 @@
+/**
+ * Inference code generated from the JSON schema spec in ./spec
+ *
+ * Using src/scripts/inference-codegen
+ */
+/**
+ * Inputs for Text Classification inference
+ */
+export interface TextClassificationInput {
+	/**
+	 * The text to classify
+	 */
+	data: string;
+	/**
+	 * Additional inference parameters
+	 */
+	parameters?: TextClassificationParameters;
+	[property: string]: unknown;
+}
+/**
+ * Additional inference parameters
+ *
+ * Additional inference parameters for Text Classification
+ */
+export interface TextClassificationParameters {
+	functionToApply?: ClassificationOutputTransform;
+	/**
+	 * When specified, limits the output to the top K most probable classes.
+	 */
+	topK?: number;
+	[property: string]: unknown;
+}
+/**
+ * The function to apply to the model outputs in order to retrieve the scores.
+ */
+export type ClassificationOutputTransform = "sigmoid" | "softmax" | "none";
+export type TextClassificationOutput = TextClassificationOutputElement[];
+/**
+ * Outputs of inference for the Text Classification task
+ */
+export interface TextClassificationOutputElement {
+	/**
+	 * The predicted class label.
+	 */
+	label: string;
+	/**
+	 * The corresponding probability.
+	 */
+	score: number;
+	[property: string]: unknown;
+}

package/src/tasks/text-classification/spec/input.json

@@ -0,0 +1,35 @@
+{
+	"$id": "/inference/schemas/text-classification/input.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Inputs for Text Classification inference",
+	"title": "TextClassificationInput",
+	"type": "object",
+	"properties": {
+		"data": {
+			"description": "The text to classify",
+			"type": "string"
+		},
+		"parameters": {
+			"description": "Additional inference parameters",
+			"$ref": "#/$defs/TextClassificationParameters"
+		}
+	},
+	"$defs": {
+		"TextClassificationParameters": {
+			"title": "TextClassificationParameters",
+			"description": "Additional inference parameters for Text Classification",
+			"type": "object",
+			"properties": {
+				"functionToApply": {
+					"title": "TextClassificationOutputTransform",
+					"$ref": "/inference/schemas/common-definitions.json#/definitions/ClassificationOutputTransform"
+				},
+				"topK": {
+					"type": "integer",
+					"description": "When specified, limits the output to the top K most probable classes."
+				}
+			}
+		}
+	},
+	"required": ["data"]
+}

package/src/tasks/text-classification/spec/output.json

@@ -0,0 +1,10 @@
+{
+	"$id": "/inference/schemas/text-classification/output.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Outputs of inference for the Text Classification task",
+	"title": "TextClassificationOutput",
+	"type": "array",
+	"items": {
+		"$ref": "/inference/schemas/common-definitions.json#/definitions/ClassificationOutput"
+	}
+}

package/src/tasks/text-generation/about.md

@@ -110,25 +110,36 @@ Would you like to learn more about the topic? Awesome! Here you can find some cu
 - [ChatUI Docker Spaces](https://huggingface.co/docs/hub/spaces-sdks-docker-chatui)
 - [Causal language modeling task guide](https://huggingface.co/docs/transformers/tasks/language_modeling)
 - [Text generation strategies](https://huggingface.co/docs/transformers/generation_strategies)
+- [Course chapter on training a causal language model from scratch](https://huggingface.co/course/chapter7/6?fw=pt)
 
-### Course and Blogs
+### Model Inference & Deployment
 
-- [Course Chapter on Training a causal language model from scratch](https://huggingface.co/course/chapter7/6?fw=pt)
-- [TO Discussion with Victor Sanh](https://www.youtube.com/watch?v=Oy49SCW_Xpw&ab_channel=HuggingFace)
-- [Hugging Face Course Workshops: Pretraining Language Models & CodeParrot](https://www.youtube.com/watch?v=ExUR7w6xe94&ab_channel=HuggingFace)
-- [Training CodeParrot 🦜 from Scratch](https://huggingface.co/blog/codeparrot)
-- [How to generate text: using different decoding methods for language generation with Transformers](https://huggingface.co/blog/how-to-generate)
+- [Optimizing your LLM in production](https://huggingface.co/blog/optimize-llm)
+- [Open-Source Text Generation & LLM Ecosystem at Hugging Face](https://huggingface.co/blog/os-llms)
+- [Introducing RWKV - An RNN with the advantages of a transformer](https://huggingface.co/blog/rwkv)
+- [Llama 2 is at Hugging Face](https://huggingface.co/blog/llama2)
 - [Guiding Text Generation with Constrained Beam Search in 🤗 Transformers](https://huggingface.co/blog/constrained-beam-search)
 - [Code generation with Hugging Face](https://huggingface.co/spaces/codeparrot/code-generation-models)
-- [🌸 Introducing The World's Largest Open Multilingual Language Model: BLOOM 🌸](https://huggingface.co/blog/bloom)
-- [The Technology Behind BLOOM Training](https://huggingface.co/blog/bloom-megatron-deepspeed)
-- [Faster Text Generation with TensorFlow and XLA](https://huggingface.co/blog/tf-xla-generate)
 - [Assisted Generation: a new direction toward low-latency text generation](https://huggingface.co/blog/assisted-generation)
-- [Introducing RWKV - An RNN with the advantages of a transformer](https://huggingface.co/blog/rwkv)
+- [How to generate text: using different decoding methods for language generation with Transformers](https://huggingface.co/blog/how-to-generate)
+- [Faster Text Generation with TensorFlow and XLA](https://huggingface.co/blog/tf-xla-generate)
+
+### Model Fine-tuning/Training
+
+- [Non-engineers guide: Train a LLaMA 2 chatbot](https://huggingface.co/blog/Llama2-for-non-engineers)
+- [Training CodeParrot 🦜 from Scratch](https://huggingface.co/blog/codeparrot)
 - [Creating a Coding Assistant with StarCoder](https://huggingface.co/blog/starchat-alpha)
-- [StarCoder: A State-of-the-Art LLM for Code](https://huggingface.co/blog/starcoder)
-- [Open-Source Text Generation & LLM Ecosystem at Hugging Face](https://huggingface.co/blog/os-llms)
-- [Llama 2 is at Hugging Face](https://huggingface.co/blog/llama2)
+
+### Advanced Concepts Explained Simply
+
+- [Mixture of Experts Explained](https://huggingface.co/blog/moe)
+
+### Advanced Fine-tuning/Training Recipes
+
+- [Fine-tuning Llama 2 70B using PyTorch FSDP](https://huggingface.co/blog/ram-efficient-pytorch-fsdp)
+- [The N Implementation Details of RLHF with PPO](https://huggingface.co/blog/the_n_implementation_details_of_rlhf_with_ppo)
+- [Preference Tuning LLMs with Direct Preference Optimization Methods](https://huggingface.co/blog/pref-tuning)
+- [Fine-tune Llama 2 with DPO](https://huggingface.co/blog/dpo-trl)
 
 ### Notebooks
 

package/src/tasks/text-generation/data.ts

@@ -12,12 +12,12 @@ const taskData: TaskDataCustom = {
 			id: "the_pile",
 		},
 		{
-			description: "A crowd-sourced instruction dataset to develop an AI assistant.",
-			id: "OpenAssistant/oasst1",
+			description: "Truly open-source, curated and cleaned dialogue dataset.",
+			id: "HuggingFaceH4/ultrachat_200k",
 		},
 		{
-			description: "A crowd-sourced instruction dataset created by Databricks employees.",
-			id: "databricks/databricks-dolly-15k",
+			description: "An instruction dataset with preference ratings on responses.",
+			id: "openbmb/UltraFeedback",
 		},
 	],
 	demo: {
@@ -59,66 +59,50 @@ const taskData: TaskDataCustom = {
 			id: "bigcode/starcoder",
 		},
 		{
-			description: "A model trained to follow instructions, uses Pythia-12b as base model.",
-			id: "databricks/dolly-v2-12b",
+			description: "A very powerful text generation model.",
+			id: "mistralai/Mixtral-8x7B-Instruct-v0.1",
 		},
 		{
-			description: "A model trained to follow instructions curated by community, uses Pythia-12b as base model.",
-			id: "OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5",
+			description: "Small yet powerful text generation model.",
+			id: "microsoft/phi-2",
 		},
 		{
-			description: "A large language model trained to generate text in English.",
-			id: "stabilityai/stablelm-tuned-alpha-7b",
+			description: "A very powerful model that can chat, do mathematical reasoning and write code.",
+			id: "openchat/openchat-3.5-0106",
 		},
 		{
-			description: "A model trained to follow instructions, based on mosaicml/mpt-7b.",
-			id: "mosaicml/mpt-7b-instruct",
+			description: "Very strong yet small assistant model.",
+			id: "HuggingFaceH4/zephyr-7b-beta",
 		},
 		{
-			description: "A large language model trained to generate text in English.",
-			id: "EleutherAI/pythia-12b",
-		},
-		{
-			description: "A large text-to-text model trained to follow instructions.",
-			id: "google/flan-ul2",
-		},
-		{
-			description: "A large and powerful text generation model.",
-			id: "tiiuae/falcon-40b",
-		},
-		{
-			description: "State-of-the-art open-source large language model.",
+			description: "Very strong open-source large language model.",
 			id: "meta-llama/Llama-2-70b-hf",
 		},
 	],
 	spaces: [
 		{
-			description: "A robust text generation model that can perform various tasks through natural language prompting.",
-			id: "huggingface/bloom_demo",
+			description: "A leaderboard to compare different open-source text generation models based on various benchmarks.",
+			id: "HuggingFaceH4/open_llm_leaderboard",
 		},
 		{
-			description: "An text generation based application that can write code for 80+ languages.",
-			id: "bigcode/bigcode-playground",
+			description: "An text generation based application based on a very powerful LLaMA2 model.",
+			id: "ysharma/Explore_llamav2_with_TGI",
 		},
 		{
-			description: "An text generation based application for conversations.",
-			id: "h2oai/h2ogpt-chatbot",
+			description: "An text generation based application to converse with Zephyr model.",
+			id: "HuggingFaceH4/zephyr-chat",
 		},
 		{
 			description: "An text generation application that combines OpenAI and Hugging Face models.",
 			id: "microsoft/HuggingGPT",
 		},
 		{
-			description: "An text generation application that uses StableLM-tuned-alpha-7b.",
-			id: "stabilityai/stablelm-tuned-alpha-chat",
-		},
-		{
-			description: "An UI that uses StableLM-tuned-alpha-7b.",
-			id: "togethercomputer/OpenChatKit",
+			description: "An chatbot to converse with a very powerful text generation model.",
+			id: "mlabonne/phixtral-chat",
 		},
 	],
 	summary:
-		"Generating text is the task of producing new text. These models can, for example, fill in incomplete text or paraphrase.",
+		"Generating text is the task of generating new text given another text. These models can, for example, fill in incomplete text or paraphrase.",
 	widgetModels: ["HuggingFaceH4/zephyr-7b-beta"],
 	youtubeId: "Vpjb1lu0MDk",
 };

package/src/tasks/text-generation/inference.ts

@@ -0,0 +1,85 @@
+/**
+ * Inference code generated from the JSON schema spec in ./spec
+ *
+ * Using src/scripts/inference-codegen
+ */
+/**
+ * Inputs for Text Generation inference
+ */
+export interface TextGenerationInput {
+	/**
+	 * The text to initialize generation with
+	 */
+	data: string;
+	/**
+	 * Additional inference parameters
+	 */
+	parameters?: TextGenerationParameters;
+	[property: string]: unknown;
+}
+/**
+ * Additional inference parameters
+ *
+ * Additional inference parameters for Text Generation
+ */
+export interface TextGenerationParameters {
+	/**
+	 * Whether to use logit sampling (true) or greedy search (false).
+	 */
+	doSample?: boolean;
+	/**
+	 * Maximum number of generated tokens.
+	 */
+	maxNewTokens?: number;
+	/**
+	 * The parameter for repetition penalty. A value of 1.0 means no penalty. See [this
+	 * paper](https://hf.co/papers/1909.05858) for more details.
+	 */
+	repetitionPenalty?: number;
+	/**
+	 * Whether to prepend the prompt to the generated text.
+	 */
+	returnFullText?: boolean;
+	/**
+	 * Stop generating tokens if a member of `stop_sequences` is generated.
+	 */
+	stopSequences?: string[];
+	/**
+	 * The value used to modulate the logits distribution.
+	 */
+	temperature?: number;
+	/**
+	 * The number of highest probability vocabulary tokens to keep for top-k-filtering.
+	 */
+	topK?: number;
+	/**
+	 * If set to < 1, only the smallest set of most probable tokens with probabilities that add
+	 * up to `top_p` or higher are kept for generation.
+	 */
+	topP?: number;
+	/**
+	 * Truncate input tokens to the given size.
+	 */
+	truncate?: number;
+	/**
+	 * Typical Decoding mass. See [Typical Decoding for Natural Language
+	 * Generation](https://hf.co/papers/2202.00666) for more information
+	 */
+	typicalP?: number;
+	/**
+	 * Watermarking with [A Watermark for Large Language Models](https://hf.co/papers/2301.10226)
+	 */
+	watermark?: boolean;
+	[property: string]: unknown;
+}
+export type TextGenerationOutput = TextGenerationOutputElement[];
+/**
+ * Outputs for Text Generation inference
+ */
+export interface TextGenerationOutputElement {
+	/**
+	 * The generated text
+	 */
+	generatedText: string;
+	[property: string]: unknown;
+}

package/src/tasks/text-generation/spec/input.json

@@ -0,0 +1,74 @@
+{
+	"$id": "/inference/schemas/text-generation/input.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Inputs for Text Generation inference",
+	"title": "TextGenerationInput",
+	"type": "object",
+	"properties": {
+		"data": {
+			"description": "The text to initialize generation with",
+			"type": "string"
+		},
+		"parameters": {
+			"description": "Additional inference parameters",
+			"$ref": "#/$defs/TextGenerationParameters"
+		}
+	},
+	"$defs": {
+		"TextGenerationParameters": {
+			"title": "TextGenerationParameters",
+			"description": "Additional inference parameters for Text Generation",
+			"type": "object",
+			"properties": {
+				"doSample": {
+					"type": "boolean",
+					"description": "Whether to use logit sampling (true) or greedy search (false)."
+				},
+				"maxNewTokens": {
+					"type": "integer",
+					"description": "Maximum number of generated tokens."
+				},
+				"repetitionPenalty": {
+					"type": "number",
+					"description": "The parameter for repetition penalty. A value of 1.0 means no penalty. See [this paper](https://hf.co/papers/1909.05858) for more details."
+				},
+				"returnFullText": {
+					"type": "boolean",
+					"description": "Whether to prepend the prompt to the generated text."
+				},
+				"stopSequences": {
+					"type": "array",
+					"items": {
+						"type": "string"
+					},
+					"description": "Stop generating tokens if a member of `stop_sequences` is generated."
+				},
+				"temperature": {
+					"type": "number",
+					"description": "The value used to modulate the logits distribution."
+				},
+				"topK": {
+					"type": "integer",
+					"description": "The number of highest probability vocabulary tokens to keep for top-k-filtering."
+				},
+				"topP": {
+					"type": "number",
+					"description": "If set to < 1, only the smallest set of most probable tokens with probabilities that add up to `top_p` or higher are kept for generation."
+				},
+				"truncate": {
+					"type": "integer",
+					"description": "Truncate input tokens to the given size."
+				},
+				"typicalP": {
+					"type": "number",
+					"description": "Typical Decoding mass. See [Typical Decoding for Natural Language Generation](https://hf.co/papers/2202.00666) for more information"
+				},
+				"watermark": {
+					"type": "boolean",
+					"description": "Watermarking with [A Watermark for Large Language Models](https://hf.co/papers/2301.10226)"
+				}
+			}
+		}
+	},
+	"required": ["data"]
+}

package/src/tasks/text-generation/spec/output.json

@@ -0,0 +1,17 @@
+{
+	"$id": "/inference/schemas/text-generation/output.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Outputs for Text Generation inference",
+	"title": "TextGenerationOutput",
+	"type": "array",
+	"items": {
+		"type": "object",
+		"properties": {
+			"generatedText": {
+				"type": "string",
+				"description": "The generated text"
+			}
+		},
+		"required": ["generatedText"]
+	}
+}

package/src/tasks/text-to-audio/inference.ts

@@ -0,0 +1,138 @@
+/**
+ * Inference code generated from the JSON schema spec in ./spec
+ *
+ * Using src/scripts/inference-codegen
+ */
+/**
+ * Inputs for Text To Audio inference
+ */
+export interface TextToAudioInput {
+	/**
+	 * The input text data
+	 */
+	data: string;
+	/**
+	 * Additional inference parameters
+	 */
+	parameters?: TextToAudioParameters;
+	[property: string]: unknown;
+}
+/**
+ * Additional inference parameters
+ *
+ * Additional inference parameters for Text To Audio
+ */
+export interface TextToAudioParameters {
+	/**
+	 * Parametrization of the text generation process
+	 */
+	generate?: GenerationParameters;
+	[property: string]: unknown;
+}
+/**
+ * Parametrization of the text generation process
+ *
+ * Ad-hoc parametrization of the text generation process
+ */
+export interface GenerationParameters {
+	/**
+	 * Whether to use sampling instead of greedy decoding when generating new tokens.
+	 */
+	doSample?: boolean;
+	/**
+	 * Controls the stopping condition for beam-based methods.
+	 */
+	earlyStopping?: EarlyStoppingUnion;
+	/**
+	 * If set to float strictly between 0 and 1, only tokens with a conditional probability
+	 * greater than epsilon_cutoff will be sampled. In the paper, suggested values range from
+	 * 3e-4 to 9e-4, depending on the size of the model. See [Truncation Sampling as Language
+	 * Model Desmoothing](https://hf.co/papers/2210.15191) for more details.
+	 */
+	epsilonCutoff?: number;
+	/**
+	 * Eta sampling is a hybrid of locally typical sampling and epsilon sampling. If set to
+	 * float strictly between 0 and 1, a token is only considered if it is greater than either
+	 * eta_cutoff or sqrt(eta_cutoff) * exp(-entropy(softmax(next_token_logits))). The latter
+	 * term is intuitively the expected next token probability, scaled by sqrt(eta_cutoff). In
+	 * the paper, suggested values range from 3e-4 to 2e-3, depending on the size of the model.
+	 * See [Truncation Sampling as Language Model Desmoothing](https://hf.co/papers/2210.15191)
+	 * for more details.
+	 */
+	etaCutoff?: number;
+	/**
+	 * The maximum length (in tokens) of the generated text, including the input.
+	 */
+	maxLength?: number;
+	/**
+	 * The maximum number of tokens to generate. Takes precedence over maxLength.
+	 */
+	maxNewTokens?: number;
+	/**
+	 * The minimum length (in tokens) of the generated text, including the input.
+	 */
+	minLength?: number;
+	/**
+	 * The minimum number of tokens to generate. Takes precedence over maxLength.
+	 */
+	minNewTokens?: number;
+	/**
+	 * Number of groups to divide num_beams into in order to ensure diversity among different
+	 * groups of beams. See [this paper](https://hf.co/papers/1610.02424) for more details.
+	 */
+	numBeamGroups?: number;
+	/**
+	 * Number of beams to use for beam search.
+	 */
+	numBeams?: number;
+	/**
+	 * The value balances the model confidence and the degeneration penalty in contrastive
+	 * search decoding.
+	 */
+	penaltyAlpha?: number;
+	/**
+	 * The value used to modulate the next token probabilities.
+	 */
+	temperature?: number;
+	/**
+	 * The number of highest probability vocabulary tokens to keep for top-k-filtering.
+	 */
+	topK?: number;
+	/**
+	 * If set to float < 1, only the smallest set of most probable tokens with probabilities
+	 * that add up to top_p or higher are kept for generation.
+	 */
+	topP?: number;
+	/**
+	 * Local typicality measures how similar the conditional probability of predicting a target
+	 * token next is to the expected conditional probability of predicting a random token next,
+	 * given the partial text already generated. If set to float < 1, the smallest set of the
+	 * most locally typical tokens with probabilities that add up to typical_p or higher are
+	 * kept for generation. See [this paper](https://hf.co/papers/2202.00666) for more details.
+	 */
+	typicalP?: number;
+	/**
+	 * Whether the model should use the past last key/values attentions to speed up decoding
+	 */
+	useCache?: boolean;
+	[property: string]: unknown;
+}
+/**
+ * Controls the stopping condition for beam-based methods.
+ */
+export type EarlyStoppingUnion = boolean | "never";
+export type TextToAudioOutput = TextToAudioOutputElement[];
+/**
+ * Outputs of inference for the Text To Audio task
+ */
+export interface TextToAudioOutputElement {
+	/**
+	 * The generated audio waveform.
+	 */
+	audio: unknown;
+	/**
+	 * The sampling rate of the generated audio waveform.
+	 */
+	samplingRate: number;
+	[property: string]: unknown;
+}

package/src/tasks/text-to-audio/spec/input.json

@@ -0,0 +1,31 @@
+{
+	"$id": "/inference/schemas/text-to-audio/input.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Inputs for Text To Audio inference",
+	"title": "TextToAudioInput",
+	"type": "object",
+	"properties": {
+		"data": {
+			"description": "The input text data",
+			"type": "string"
+		},
+		"parameters": {
+			"description": "Additional inference parameters",
+			"$ref": "#/$defs/TextToAudioParameters"
+		}
+	},
+	"$defs": {
+		"TextToAudioParameters": {
+			"title": "TextToAudioParameters",
+			"description": "Additional inference parameters for Text To Audio",
+			"type": "object",
+			"properties": {
+				"generate": {
+					"description": "Parametrization of the text generation process",
+					"$ref": "/inference/schemas/common-definitions.json#/definitions/GenerationParameters"
+				}
+			}
+		}
+	},
+	"required": ["data"]
+}

package/src/tasks/text-to-audio/spec/output.json

@@ -0,0 +1,20 @@
+{
+	"$id": "/inference/schemas/text-to-audio/output.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Outputs of inference for the Text To Audio task",
+	"title": "TextToAudioOutput",
+	"type": "array",
+	"items": {
+		"type": "object",
+		"properties": {
+			"audio": {
+				"description": "The generated audio waveform."
+			},
+			"samplingRate": {
+				"type": "number",
+				"description": "The sampling rate of the generated audio waveform."
+			}
+		},
+		"required": ["audio", "samplingRate"]
+	}
+}

package/src/tasks/text-to-image/about.md

@@ -53,14 +53,23 @@ await inference.textToImage({
 
 ## Useful Resources
 
+### Model Inference
+
 - [Hugging Face Diffusion Models Course](https://github.com/huggingface/diffusion-models-class)
 - [Getting Started with Diffusers](https://huggingface.co/docs/diffusers/index)
 - [Text-to-Image Generation](https://huggingface.co/docs/diffusers/using-diffusers/conditional_image_generation)
-- [MinImagen - Build Your Own Imagen Text-to-Image Model](https://www.assemblyai.com/blog/minimagen-build-your-own-imagen-text-to-image-model/)
-- [Using LoRA for Efficient Stable Diffusion Fine-Tuning](https://huggingface.co/blog/lora)
 - [Using Stable Diffusion with Core ML on Apple Silicon](https://huggingface.co/blog/diffusers-coreml)
 - [A guide on Vector Quantized Diffusion](https://huggingface.co/blog/vq-diffusion)
 - [🧨 Stable Diffusion in JAX/Flax](https://huggingface.co/blog/stable_diffusion_jax)
 - [Running IF with 🧨 diffusers on a Free Tier Google Colab](https://huggingface.co/blog/if)
+- [Introducing Würstchen: Fast Diffusion for Image Generation](https://huggingface.co/blog/wuerstchen)
+- [Efficient Controllable Generation for SDXL with T2I-Adapters](https://huggingface.co/blog/t2i-sdxl-adapters)
+- [Welcome aMUSEd: Efficient Text-to-Image Generation](https://huggingface.co/blog/amused)
+
+### Model Fine-tuning
+
+- [Finetune Stable Diffusion Models with DDPO via TRL](https://huggingface.co/blog/pref-tuning)
+- [LoRA training scripts of the world, unite!](https://huggingface.co/blog/sdxl_lora_advanced_script)
+- [Using LoRA for Efficient Stable Diffusion Fine-Tuning](https://huggingface.co/blog/lora)
 
 This page was made possible thanks to the efforts of [Ishan Dutta](https://huggingface.co/ishandutta), [Enrique Elias Ubaldo](https://huggingface.co/herrius) and [Oğuz Akif](https://huggingface.co/oguzakif).