|
import argparse |
|
import binascii |
|
import glob |
|
import openai |
|
import os |
|
import os.path |
|
import numpy as np |
|
import matplotlib.pyplot as plt |
|
import random |
|
import sys |
|
import tempfile |
|
import time |
|
import torch |
|
from PIL import Image |
|
from IPython.display import Audio |
|
from diffusers import StableDiffusionPipeline |
|
from diffusers import DiffusionPipeline |
|
from transformers import pipeline |
|
from transformers import ViTFeatureExtractor, ViTForImageClassification |
|
from audiodiffusion import AudioDiffusion |
|
import requests |
|
|
|
notes = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"] |
|
|
|
def fake_gan(): |
|
images = [ |
|
(random.choice( |
|
[ |
|
"https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=387&q=80", |
|
"https://images.unsplash.com/photo-1554151228-14d9def656e4?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=386&q=80", |
|
"https://images.unsplash.com/photo-1542909168-82c3e7fdca5c?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxzZWFyY2h8MXx8aHVtYW4lMjBmYWNlfGVufDB8fDB8fA%3D%3D&w=1000&q=80", |
|
"https://images.unsplash.com/photo-1546456073-92b9f0a8d413?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=387&q=80", |
|
"https://images.unsplash.com/photo-1601412436009-d964bd02edbc?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=464&q=80", |
|
] |
|
), f"label {i}" if i != 0 else "label" * 50) |
|
for i in range(3) |
|
] |
|
return images |
|
|
|
def imageClassifier(inputImage): |
|
|
|
|
|
|
|
image = inputImage |
|
|
|
feature_extractor = ViTFeatureExtractor.from_pretrained('google/vit-base-patch16-224') |
|
model = ViTForImageClassification.from_pretrained('google/vit-base-patch16-224') |
|
|
|
inputs = feature_extractor(images=image, return_tensors="pt") |
|
outputs = model(**inputs) |
|
logits = outputs.logits |
|
|
|
predicted_class_idx = logits.argmax(-1).item() |
|
|
|
return "Predicted class:", model.config.id2label[predicted_class_idx] |
|
|
|
def audioGenerator(inputText): |
|
device = "cuda" if torch.cuda.is_available() else "cpu" |
|
dtype = torch.float16 if torch.cuda.is_available() else torch.float32 |
|
pipe = DiffusionPipeline.from_pretrained("teticio/audio-diffusion-256").to(device) |
|
output = pipe() |
|
from IPython.display import display |
|
display(output.images[0]) |
|
display(Audio(output.audios[0], rate=pipe.mel.get_sample_rate())) |
|
print("sample rate is ", pipe.mel.get_sample_rate()) |
|
|
|
sr=int(pipe.mel.get_sample_rate()) |
|
audio=Audio(output.audios[0]) |
|
|
|
return sr, audio |
|
|
|
def generate_spectrogram_audio_and_loop(model_id): |
|
audio_diffusion = AudioDiffusion(model_id=model_id) |
|
image, (sample_rate, |
|
audio) = audio_diffusion.generate_spectrogram_and_audio() |
|
loop = AudioDiffusion.loop_it(audio, sample_rate) |
|
if loop is None: |
|
loop = audio |
|
return image, (sample_rate, audio), (sample_rate, loop) |
|
|
|
def generate_tone(note, octave, duration): |
|
sr = 48000 |
|
a4_freq, tones_from_a4 = 440, 12 * (octave - 4) + (note - 9) |
|
frequency = a4_freq * 2 ** (tones_from_a4 / 12) |
|
duration = int(duration) |
|
audio = np.linspace(0, duration, duration * sr) |
|
audio = (20000 * np.sin(audio * (2 * np.pi * frequency))).astype(np.int16) |
|
return sr, audio |
|
|
|
def draw(inp, this_model, force_new): |
|
device = "cuda" if torch.cuda.is_available() else "cpu" |
|
dtype = torch.float16 if torch.cuda.is_available() else torch.float32 |
|
drawing = inp |
|
if this_model == "stable-diffusion-2": |
|
this_model_addr = "stabilityai/stable-diffusion-2" |
|
images_dir = 'images2/' |
|
elif this_model == "stable-diffusion-2-1": |
|
this_model_addr = "stabilityai/stable-diffusion-2-1" |
|
images_dir = 'images2-1/' |
|
elif this_model == "stable-diffusion-v1-5": |
|
this_model_addr = "runwayml/stable-diffusion-v1-5" |
|
images_dir = 'images/' |
|
else: |
|
raise gr.Error("Unknown Model!") |
|
mkdir_if_not_exist(images_dir) |
|
drawing_filename = images_dir + drawing.replace(' ', '_') + '.png' |
|
if os.path.exists(drawing_filename): |
|
if force_new: |
|
new_drawing_filename = images_dir + drawing.replace(' ', '_') + '.' + str(time.time()) + '.png' |
|
os.replace(drawing_filename, new_drawing_filename) |
|
else: |
|
print("found drawing ", drawing_filename) |
|
return Image.open(drawing_filename) |
|
print("generating drawing '", drawing, "'", drawing_filename) |
|
pipe = StableDiffusionPipeline.from_pretrained(this_model_addr, torch_dtype=dtype) |
|
pipe.enable_attention_slicing() |
|
pipe = pipe.to(device) |
|
image = pipe(drawing).images[0] |
|
image.seek(0) |
|
image.save(drawing_filename) |
|
return image |
|
|
|
def write_blog(inp, this_model, min_length, max_length, force_new): |
|
blog_post_name = inp |
|
if this_model == "gpt-neo-1.3B": |
|
this_model_addr = "EleutherAI/gpt-neo-1.3B" |
|
text_dir = 'text1.3/' |
|
elif this_model == "gpt-neo-2.7B": |
|
this_model_addr = "EleutherAI/gpt-neo-2.7B" |
|
text_dir = 'text2.7/' |
|
else: |
|
raise gr.Error("Unknown Model!") |
|
mkdir_if_not_exist(text_dir) |
|
target_filename = text_dir + blog_post_name.replace(' ', '_') + '.txt' |
|
if os.path.exists(target_filename): |
|
if force_new: |
|
new_target_filename = text_dir + blog_post_name.replace(' ', '_') + '.' + str(time.time()) + '.txt' |
|
os.replace(target_filename, new_target_filename) |
|
else: |
|
print("found drawing ", target_filename) |
|
with open(target_filename, 'r') as file: |
|
return file.read() |
|
print("generating blog '", blog_post_name, "'", target_filename) |
|
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") |
|
dtype = torch.float16 if torch.cuda.is_available() else torch.float32 |
|
|
|
|
|
|
|
generator = pipeline('text-generation', model=this_model_addr, device=device, torch_dtype=dtype) |
|
|
|
|
|
res = generator(blog_post_name, min_length=min_length, max_length=max_length, do_sample=True, temperature=0.7) |
|
blog_post_text = res[0]['generated_text'] |
|
with open(target_filename, 'w') as file: |
|
file.write(blog_post_text) |
|
return blog_post_text |
|
|
|
def nameMyPet(inp): |
|
animal = inp |
|
response = openai.Completion.create( |
|
model="text-davinci-003", |
|
prompt=generate_prompt(animal), |
|
temperature=0.6, |
|
) |
|
return response.choices[0].text |
|
|
|
def mkdir_if_not_exist(path): |
|
if os.path.exists(path): |
|
return 0 |
|
else: |
|
os.mkdir(path) |
|
|
|
def generate_prompt(animal): |
|
return """Suggest three names for an animal that is a superhero. |
|
|
|
Animal: Cat |
|
Names: Captain Sharpclaw, Agent Fluffball, The Incredible Feline |
|
Animal: Dog |
|
Names: Ruff the Protector, Wonder Canine, Sir Barks-a-Lot |
|
Animal: {} |
|
Names:""".format( |
|
animal.capitalize() |
|
) |
|
|
