




import json
import os
import shutil
import tempfile
import unittest
from multiprocessing import get_context
from pathlib import Path

import datasets
import numpy as np
from datasets import load_dataset
from parameterized import parameterized

from transformers import AutoProcessor
from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.testing_utils import require_pyctcdecode, require_torch, require_torchaudio, slow
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_pyctcdecode_available, is_torch_available

from ..wavaveca.test_feature_extraction_wavaveca import floats_list


if is_pyctcdecode_available():
		from huggingface_hub import snapshot_download
		from pyctcdecode import BeamSearchDecoderCTC

		from transformers.models.wavaveca_with_lm import WavaVecaProcessorWithLM
		from transformers.models.wavaveca_with_lm.processing_wavaveca_with_lm import WavaVecaDecoderWithLMOutput

if is_torch_available():
		from transformers import WavaVecaForCTC


@require_pyctcdecode
class 							__UpperCamelCase			( unittest.TestCase  ):





				'''simple docstring'''



				def       __snake_case		( self						):
											lowerCAmelCase   =		'''| <pad> <unk> <s> </s> a b c d e f g h i j k'''.split()
											lowerCAmelCase   =		dict(zip(UpperCAmelCase_       , range(len(UpperCAmelCase_						)						)						)						)

											lowerCAmelCase   =		{
											    '''unk_token''': '''<unk>''',
											    '''bos_token''': '''<s>''',
											    '''eos_token''': '''</s>''',
											}
											lowerCAmelCase   =		{
											    '''feature_size''': 1,
											    '''padding_value''': 0.0,
											    '''sampling_rate''': 1_60_00,
											    '''return_attention_mask''': False,
											    '''do_normalize''': True,
											}

											lowerCAmelCase   =		tempfile.mkdtemp()
											lowerCAmelCase   =		os.path.join(self.tmpdirname       , VOCAB_FILES_NAMES['''vocab_file''']						)
											lowerCAmelCase   =		os.path.join(self.tmpdirname       , UpperCAmelCase_						)
											with open(self.vocab_file       , '''w'''       , encoding='''utf-8'''						) as fp:
																		fp.write(json.dumps(UpperCAmelCase_						) + '''\n'''						)

											with open(self.feature_extraction_file       , '''w'''       , encoding='''utf-8'''						) as fp:
																		fp.write(json.dumps(UpperCAmelCase_						) + '''\n'''						)

											# load decoder from hub
											lowerCAmelCase   =		'''hf-internal-testing/ngram-beam-search-decoder'''



				def       __snake_case		( self       , **UpperCAmelCase_						):
											lowerCAmelCase   =		self.add_kwargs_tokens_map.copy()
											kwargs.update(UpperCAmelCase_						)
											return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname       , **UpperCAmelCase_						)



				def       __snake_case		( self       , **UpperCAmelCase_						):
											return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname       , **UpperCAmelCase_						)



				def       __snake_case		( self       , **UpperCAmelCase_						):
											return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name       , **UpperCAmelCase_						)



				def       __snake_case		( self						):
											shutil.rmtree(self.tmpdirname						)



				def       __snake_case		( self						):
											lowerCAmelCase   =		self.get_tokenizer()
											lowerCAmelCase   =		self.get_feature_extractor()
											lowerCAmelCase   =		self.get_decoder()

											lowerCAmelCase   =		WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_       , feature_extractor=UpperCAmelCase_       , decoder=UpperCAmelCase_						)

											processor.save_pretrained(self.tmpdirname						)
											lowerCAmelCase   =		WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname						)

											# tokenizer
											self.assertEqual(processor.tokenizer.get_vocab()       , tokenizer.get_vocab()						)
											self.assertIsInstance(processor.tokenizer       , UpperCAmelCase_						)

											# feature extractor
											self.assertEqual(processor.feature_extractor.to_json_string()       , feature_extractor.to_json_string()						)
											self.assertIsInstance(processor.feature_extractor       , UpperCAmelCase_						)

											# decoder
											self.assertEqual(processor.decoder._alphabet.labels       , decoder._alphabet.labels						)
											self.assertEqual(
											    processor.decoder.model_container[decoder._model_key]._unigram_set       , decoder.model_container[decoder._model_key]._unigram_set       , )
											self.assertIsInstance(processor.decoder       , UpperCAmelCase_						)



				def       __snake_case		( self						):
											lowerCAmelCase   =		WavaVecaProcessorWithLM(
											    tokenizer=self.get_tokenizer()       , feature_extractor=self.get_feature_extractor()       , decoder=self.get_decoder()						)
											processor.save_pretrained(self.tmpdirname						)

											# make sure that error is thrown when decoder alphabet doesn't match
											lowerCAmelCase   =		WavaVecaProcessorWithLM.from_pretrained(
											    self.tmpdirname       , alpha=5.0       , beta=3.0       , score_boundary=-7.0       , unk_score_offset=3						)

											# decoder
											self.assertEqual(processor.language_model.alpha       , 5.0						)
											self.assertEqual(processor.language_model.beta       , 3.0						)
											self.assertEqual(processor.language_model.score_boundary       , -7.0						)
											self.assertEqual(processor.language_model.unk_score_offset       , 3						)



				def       __snake_case		( self						):
											lowerCAmelCase   =		self.get_tokenizer()
											# add token to trigger raise
											tokenizer.add_tokens(['''xx''']						)
											with self.assertRaisesRegex(UpperCAmelCase_       , '''include'''						):
																		WavaVecaProcessorWithLM(
																		    tokenizer=UpperCAmelCase_       , feature_extractor=self.get_feature_extractor()       , decoder=self.get_decoder()						)



				def       __snake_case		( self						):
											lowerCAmelCase   =		self.get_feature_extractor()
											lowerCAmelCase   =		self.get_tokenizer()
											lowerCAmelCase   =		self.get_decoder()

											lowerCAmelCase   =		WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_       , feature_extractor=UpperCAmelCase_       , decoder=UpperCAmelCase_						)

											lowerCAmelCase   =		floats_list((3, 10_00)						)

											lowerCAmelCase   =		feature_extractor(UpperCAmelCase_       , return_tensors='''np'''						)
											lowerCAmelCase   =		processor(UpperCAmelCase_       , return_tensors='''np'''						)

											for key in input_feat_extract.keys():
																		self.assertAlmostEqual(input_feat_extract[key].sum()       , input_processor[key].sum()       , delta=1E-2						)



				def       __snake_case		( self						):
											lowerCAmelCase   =		self.get_feature_extractor()
											lowerCAmelCase   =		self.get_tokenizer()
											lowerCAmelCase   =		self.get_decoder()

											lowerCAmelCase   =		WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_       , feature_extractor=UpperCAmelCase_       , decoder=UpperCAmelCase_						)

											lowerCAmelCase   =		'''This is a test string'''

											lowerCAmelCase   =		processor(text=UpperCAmelCase_						)

											lowerCAmelCase   =		tokenizer(UpperCAmelCase_						)

											for key in encoded_tok.keys():
																		self.assertListEqual(encoded_tok[key]       , encoded_processor[key]						)



				def       __snake_case		( self       , UpperCAmelCase_=(2, 10, 16)       , UpperCAmelCase_=77						):
											np.random.seed(UpperCAmelCase_						)
											return np.random.rand(*UpperCAmelCase_						)



				def       __snake_case		( self						):
											lowerCAmelCase   =		self.get_feature_extractor()
											lowerCAmelCase   =		self.get_tokenizer()
											lowerCAmelCase   =		self.get_decoder()

											lowerCAmelCase   =		WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_       , feature_extractor=UpperCAmelCase_       , decoder=UpperCAmelCase_						)

											lowerCAmelCase   =		self._get_dummy_logits(shape=(10, 16)       , seed=13						)

											lowerCAmelCase   =		processor.decode(UpperCAmelCase_						)

											lowerCAmelCase   =		decoder.decode_beams(UpperCAmelCase_						)[0]

											self.assertEqual(decoded_decoder[0]       , decoded_processor.text						)
											self.assertEqual('''</s> <s> </s>'''       , decoded_processor.text						)
											self.assertEqual(decoded_decoder[-2]       , decoded_processor.logit_score						)
											self.assertEqual(decoded_decoder[-1]       , decoded_processor.lm_score						)



				@parameterized.expand([[None], ['''fork'''], ['''spawn''']]						)
				def       __snake_case		( self       , UpperCAmelCase_						):
											lowerCAmelCase   =		self.get_feature_extractor()
											lowerCAmelCase   =		self.get_tokenizer()
											lowerCAmelCase   =		self.get_decoder()

											lowerCAmelCase   =		WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_       , feature_extractor=UpperCAmelCase_       , decoder=UpperCAmelCase_						)

											lowerCAmelCase   =		self._get_dummy_logits()

											# note: pool should be instantiated *after* Wav2Vec2ProcessorWithLM.
											#       otherwise, the LM won't be available to the pool's sub-processes.
											# manual logic used to allow parameterized test for both pool=None and pool=Pool(...)
											if pool_context is None:
																		lowerCAmelCase   =		processor.batch_decode(UpperCAmelCase_						)
											else:
																		with get_context(UpperCAmelCase_						).Pool() as pool:
																									lowerCAmelCase   =		processor.batch_decode(UpperCAmelCase_       , UpperCAmelCase_						)

											lowerCAmelCase   =		list(UpperCAmelCase_						)

											with get_context('''fork'''						).Pool() as p:
																		lowerCAmelCase   =		decoder.decode_beams_batch(UpperCAmelCase_       , UpperCAmelCase_						)

											lowerCAmelCase   ,     lowerCAmelCase   ,     lowerCAmelCase   =		[], [], []
											for beams in decoded_beams:
																		texts_decoder.append(beams[0][0]						)
																		logit_scores_decoder.append(beams[0][-2]						)
																		lm_scores_decoder.append(beams[0][-1]						)

											self.assertListEqual(UpperCAmelCase_       , decoded_processor.text						)
											self.assertListEqual(['''<s> <s> </s>''', '''<s> <s> <s>''']       , decoded_processor.text						)
											self.assertListEqual(UpperCAmelCase_       , decoded_processor.logit_score						)
											self.assertListEqual(UpperCAmelCase_       , decoded_processor.lm_score						)



				def       __snake_case		( self						):
											lowerCAmelCase   =		self.get_feature_extractor()
											lowerCAmelCase   =		self.get_tokenizer()
											lowerCAmelCase   =		self.get_decoder()

											lowerCAmelCase   =		WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_       , feature_extractor=UpperCAmelCase_       , decoder=UpperCAmelCase_						)

											lowerCAmelCase   =		self._get_dummy_logits()

											lowerCAmelCase   =		15
											lowerCAmelCase   =		-20.0
											lowerCAmelCase   =		-4.0

											lowerCAmelCase   =		processor.batch_decode(
											    UpperCAmelCase_       , beam_width=UpperCAmelCase_       , beam_prune_logp=UpperCAmelCase_       , token_min_logp=UpperCAmelCase_       , )
											lowerCAmelCase   =		decoded_processor_out.text

											lowerCAmelCase   =		list(UpperCAmelCase_						)

											with get_context('''fork'''						).Pool() as pool:
																		lowerCAmelCase   =		decoder.decode_beams_batch(
																		    UpperCAmelCase_       , UpperCAmelCase_       , beam_width=UpperCAmelCase_       , beam_prune_logp=UpperCAmelCase_       , token_min_logp=UpperCAmelCase_       , )

											lowerCAmelCase   =		[d[0][0] for d in decoded_decoder_out]
											lowerCAmelCase   =		[d[0][2] for d in decoded_decoder_out]
											lowerCAmelCase   =		[d[0][3] for d in decoded_decoder_out]

											self.assertListEqual(UpperCAmelCase_       , UpperCAmelCase_						)
											self.assertListEqual(['''</s> <s> <s>''', '''<s> <s> <s>''']       , UpperCAmelCase_						)

											self.assertTrue(np.array_equal(UpperCAmelCase_       , decoded_processor_out.logit_score						)						)
											self.assertTrue(np.allclose([-20.054, -18.447]       , UpperCAmelCase_       , atol=1E-3						)						)

											self.assertTrue(np.array_equal(UpperCAmelCase_       , decoded_processor_out.lm_score						)						)
											self.assertTrue(np.allclose([-15.554, -13.9474]       , UpperCAmelCase_       , atol=1E-3						)						)



				def       __snake_case		( self						):
											lowerCAmelCase   =		self.get_feature_extractor()
											lowerCAmelCase   =		self.get_tokenizer()
											lowerCAmelCase   =		self.get_decoder()

											lowerCAmelCase   =		WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_       , feature_extractor=UpperCAmelCase_       , decoder=UpperCAmelCase_						)

											lowerCAmelCase   =		self._get_dummy_logits()

											lowerCAmelCase   =		2.0
											lowerCAmelCase   =		5.0
											lowerCAmelCase   =		-20.0
											lowerCAmelCase   =		True

											lowerCAmelCase   =		processor.batch_decode(
											    UpperCAmelCase_       , alpha=UpperCAmelCase_       , beta=UpperCAmelCase_       , unk_score_offset=UpperCAmelCase_       , lm_score_boundary=UpperCAmelCase_       , )
											lowerCAmelCase   =		decoded_processor_out.text

											lowerCAmelCase   =		list(UpperCAmelCase_						)
											decoder.reset_params(
											    alpha=UpperCAmelCase_       , beta=UpperCAmelCase_       , unk_score_offset=UpperCAmelCase_       , lm_score_boundary=UpperCAmelCase_       , )

											with get_context('''fork'''						).Pool() as pool:
																		lowerCAmelCase   =		decoder.decode_beams_batch(
																		    UpperCAmelCase_       , UpperCAmelCase_       , )

											lowerCAmelCase   =		[d[0][0] for d in decoded_decoder_out]

											self.assertListEqual(UpperCAmelCase_       , UpperCAmelCase_						)
											self.assertListEqual(['''<s> </s> <s> </s> </s>''', '''</s> </s> <s> </s> </s>''']       , UpperCAmelCase_						)
											lowerCAmelCase   =		processor.decoder.model_container[processor.decoder._model_key]
											self.assertEqual(lm_model.alpha       , 2.0						)
											self.assertEqual(lm_model.beta       , 5.0						)
											self.assertEqual(lm_model.unk_score_offset       , -20.0						)
											self.assertEqual(lm_model.score_boundary       , UpperCAmelCase_						)



				def       __snake_case		( self						):
											lowerCAmelCase   =		WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''						)

											lowerCAmelCase   =		processor.decoder.model_container[processor.decoder._model_key]
											lowerCAmelCase   =		Path(language_model._kenlm_model.path.decode('''utf-8'''						)						).parent.parent.absolute()

											lowerCAmelCase   =		os.listdir(UpperCAmelCase_						)
											lowerCAmelCase   =		['''alphabet.json''', '''language_model''']

											downloaded_decoder_files.sort()
											expected_decoder_files.sort()

											# test that only decoder relevant files from
											# https://huggingface.co/hf-internal-testing/processor_with_lm/tree/main
											# are downloaded and none of the rest (e.g. README.md, ...)
											self.assertListEqual(UpperCAmelCase_       , UpperCAmelCase_						)



				def       __snake_case		( self						):
											lowerCAmelCase   =		snapshot_download('''hf-internal-testing/processor_with_lm'''						)

											lowerCAmelCase   =		WavaVecaProcessorWithLM.from_pretrained(UpperCAmelCase_						)

											lowerCAmelCase   =		processor.decoder.model_container[processor.decoder._model_key]
											lowerCAmelCase   =		Path(language_model._kenlm_model.path.decode('''utf-8'''						)						).parent.parent.absolute()

											lowerCAmelCase   =		os.listdir(UpperCAmelCase_						)
											lowerCAmelCase   =		os.listdir(UpperCAmelCase_						)

											local_decoder_files.sort()
											expected_decoder_files.sort()

											# test that both decoder form hub and local files in cache are the same
											self.assertListEqual(UpperCAmelCase_       , UpperCAmelCase_						)



				def       __snake_case		( self						):
											lowerCAmelCase   =		WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''						)
											lowerCAmelCase   =		AutoProcessor.from_pretrained('''hf-internal-testing/processor_with_lm'''						)

											lowerCAmelCase   =		floats_list((3, 10_00)						)

											lowerCAmelCase   =		processor_wavaveca(UpperCAmelCase_       , return_tensors='''np'''						)
											lowerCAmelCase   =		processor_auto(UpperCAmelCase_       , return_tensors='''np'''						)

											for key in input_wavaveca.keys():
																		self.assertAlmostEqual(input_wavaveca[key].sum()       , input_auto[key].sum()       , delta=1E-2						)

											lowerCAmelCase   =		self._get_dummy_logits()

											lowerCAmelCase   =		processor_wavaveca.batch_decode(UpperCAmelCase_						)
											lowerCAmelCase   =		processor_auto.batch_decode(UpperCAmelCase_						)

											self.assertListEqual(decoded_wavaveca.text       , decoded_auto.text						)



				def       __snake_case		( self						):
											lowerCAmelCase   =		self.get_feature_extractor()
											lowerCAmelCase   =		self.get_tokenizer()
											lowerCAmelCase   =		self.get_decoder()

											lowerCAmelCase   =		WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_       , feature_extractor=UpperCAmelCase_       , decoder=UpperCAmelCase_						)

											self.assertListEqual(
											    processor.model_input_names       , feature_extractor.model_input_names       , msg='''`processor` and `feature_extractor` model input names do not match'''       , )



				@staticmethod
				def       __snake_case		( UpperCAmelCase_       , UpperCAmelCase_						):
											lowerCAmelCase   =		[d[key] for d in offsets]
											return retrieved_list



				def       __snake_case		( self						):
											lowerCAmelCase   =		WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''						)
											lowerCAmelCase   =		self._get_dummy_logits()[0]

											lowerCAmelCase   =		processor.decode(UpperCAmelCase_       , output_word_offsets=UpperCAmelCase_						)
											# check Wav2Vec2CTCTokenizerOutput keys for word
											self.assertEqual(len(outputs.keys()						)       , 4						)
											self.assertTrue('''text''' in outputs						)
											self.assertTrue('''word_offsets''' in outputs						)
											self.assertTrue(isinstance(UpperCAmelCase_       , UpperCAmelCase_						)						)

											self.assertEqual(''' '''.join(self.get_from_offsets(outputs['''word_offsets''']       , '''word'''						)						)       , outputs.text						)
											self.assertListEqual(self.get_from_offsets(outputs['''word_offsets''']       , '''word'''						)       , ['''<s>''', '''<s>''', '''</s>''']						)
											self.assertListEqual(self.get_from_offsets(outputs['''word_offsets''']       , '''start_offset'''						)       , [0, 2, 4]						)
											self.assertListEqual(self.get_from_offsets(outputs['''word_offsets''']       , '''end_offset'''						)       , [1, 3, 5]						)



				def       __snake_case		( self						):
											lowerCAmelCase   =		WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''						)
											lowerCAmelCase   =		self._get_dummy_logits()

											lowerCAmelCase   =		processor.batch_decode(UpperCAmelCase_       , output_word_offsets=UpperCAmelCase_						)

											# check Wav2Vec2CTCTokenizerOutput keys for word
											self.assertEqual(len(outputs.keys()						)       , 4						)
											self.assertTrue('''text''' in outputs						)
											self.assertTrue('''word_offsets''' in outputs						)
											self.assertTrue(isinstance(UpperCAmelCase_       , UpperCAmelCase_						)						)

											self.assertListEqual(
											    [''' '''.join(self.get_from_offsets(UpperCAmelCase_       , '''word'''						)						) for o in outputs['''word_offsets''']]       , outputs.text						)
											self.assertListEqual(self.get_from_offsets(outputs['''word_offsets'''][0]       , '''word'''						)       , ['''<s>''', '''<s>''', '''</s>''']						)
											self.assertListEqual(self.get_from_offsets(outputs['''word_offsets'''][0]       , '''start_offset'''						)       , [0, 2, 4]						)
											self.assertListEqual(self.get_from_offsets(outputs['''word_offsets'''][0]       , '''end_offset'''						)       , [1, 3, 5]						)






				@slow
				@require_torch
				@require_torchaudio
				def       __snake_case		( self						):
											import torch

											lowerCAmelCase   =		load_dataset('''common_voice'''       , '''en'''       , split='''train'''       , streaming=UpperCAmelCase_						)
											lowerCAmelCase   =		ds.cast_column('''audio'''       , datasets.Audio(sampling_rate=1_60_00						)						)
											lowerCAmelCase   =		iter(UpperCAmelCase_						)
											lowerCAmelCase   =		next(UpperCAmelCase_						)

											lowerCAmelCase   =		AutoProcessor.from_pretrained('''patrickvonplaten/wav2vec2-base-100h-with-lm'''						)
											lowerCAmelCase   =		WavaVecaForCTC.from_pretrained('''patrickvonplaten/wav2vec2-base-100h-with-lm'''						)

											# compare to filename `common_voice_en_100038.mp3` of dataset viewer on https://huggingface.co/datasets/common_voice/viewer/en/train
											lowerCAmelCase   =		processor(sample['''audio''']['''array''']       , return_tensors='''pt'''						).input_values

											with torch.no_grad():
																		lowerCAmelCase   =		model(UpperCAmelCase_						).logits.cpu().numpy()

											lowerCAmelCase   =		processor.decode(logits[0]       , output_word_offsets=UpperCAmelCase_						)

											lowerCAmelCase   =		model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
											lowerCAmelCase   =		[
											    {
											        '''start_time''': d['''start_offset'''] * time_offset,
											        '''end_time''': d['''end_offset'''] * time_offset,
											        '''word''': d['''word'''],
											    }
											    for d in output['''word_offsets''']
											]

											lowerCAmelCase   =		'''WHY DOES MILISANDRA LOOK LIKE SHE WANTS TO CONSUME JOHN SNOW ON THE RIVER AT THE WALL'''

											# output words
											self.assertEqual(''' '''.join(self.get_from_offsets(UpperCAmelCase_       , '''word'''						)						)       , UpperCAmelCase_						)
											self.assertEqual(''' '''.join(self.get_from_offsets(UpperCAmelCase_       , '''word'''						)						)       , output.text						)

											# output times
											lowerCAmelCase   =		torch.tensor(self.get_from_offsets(UpperCAmelCase_       , '''start_time'''						)						)
											lowerCAmelCase   =		torch.tensor(self.get_from_offsets(UpperCAmelCase_       , '''end_time'''						)						)

											# fmt: off
											lowerCAmelCase   =		torch.tensor([1.4199, 1.6599, 2.2599, 3.0, 3.24, 3.5999, 3.7999, 4.0999, 4.26, 4.94, 5.28, 5.6599, 5.78, 5.94, 6.32, 6.5399, 6.6599]						)
											lowerCAmelCase   =		torch.tensor([1.5399, 1.8999, 2.9, 3.16, 3.5399, 3.72, 4.0199, 4.1799, 4.76, 5.1599, 5.5599, 5.6999, 5.86, 6.1999, 6.38, 6.6199, 6.94]						)
											# fmt: on

											self.assertTrue(torch.allclose(UpperCAmelCase_       , UpperCAmelCase_       , atol=0.01						)						)
											self.assertTrue(torch.allclose(UpperCAmelCase_       , UpperCAmelCase_       , atol=0.01						)						)









import torch

from diffusers import StableDiffusionPipeline


UpperCAmelCase_						="""path-to-your-trained-model"""
UpperCAmelCase_						=StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.floataa).to("""cuda""")

UpperCAmelCase_						="""A photo of sks dog in a bucket"""
UpperCAmelCase_						=pipe(prompt, num_inference_steps=50, guidance_scale=7.5).images[0]

image.save("""dog-bucket.png""")



