app.py

# notes https://huggingface.co/spaces/Joeythemonster/Text-To-image-AllModels/blob/main/app.py
from diffusers import StableDiffusionPipeline
from diffusers import DiffusionPipeline
import torch
import time
import matplotlib.pyplot as plt
import tensorflow as tf
import os
import sys
import requests
from image_similarity_measures.evaluate import evaluation
from PIL import Image
from huggingface_hub import from_pretrained_keras
from math import sqrt, ceil
import numpy as np

modelieo=[
 'nathanReitinger/MNIST-diffusion',
 'nathanReitinger/MNIST-diffusion-oneImage',
 'nathanReitinger/MNIST-GAN',
 'nathanReitinger/MNIST-GAN-noDropout'
  ]

def get_sims(gen_filepath, gen_label, file_path, hunting_time_limit):
  (train_images, train_labels), (_, _) = tf.keras.datasets.mnist.load_data()
  train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')
  train_images = (train_images - 127.5) / 127.5	# Normalize the images to [-1, 1]

  print("how long to hunt", hunting_time_limit)
  if hunting_time_limit == None:
    hunting_time_limit = 2

  lowest_score = 10000
  lowest_image = None
  lowest_image_path = ''

  start = time.time()

  for i in range(len(train_labels)):
    # print(i)
    if train_labels[i] == gen_label:

        ###
        # get a real image (of correct number)
        ###

        # print(i)
        to_check = train_images[i]
        fig = plt.figure(figsize=(1, 1))
        plt.subplot(1, 1, 0+1)
        plt.imshow(to_check, cmap='gray')
        plt.axis('off')
        plt.savefig(file_path + 'real_deal.png')
        plt.close()

        # baseline = evaluation(org_img_path='results/real_deal.png', pred_img_path='results/real_deal.png', metrics=["rmse", "psnr"])
        # print("---")

        ###
        # check how close that real training data is to generated number
        ###
        results = evaluation(org_img_path=file_path + 'real_deal.png', pred_img_path=file_path+'generated_image.png', metrics=["rmse", "psnr"])
        if results['rmse'] < lowest_score:
          lowest_score = results['rmse']
          lowest_image = to_check

          to_save = train_images[i]
          fig = plt.figure(figsize=(1, 1))
          plt.subplot(1, 1, 0+1)
          plt.imshow(to_save, cmap='gray')
          plt.axis('off')
          plt.savefig(file_path + 'keeper.png')
          plt.close()
          lowest_image_path = file_path + 'keeper.png'

          print(lowest_score, str(round( ((i/len(train_labels)) * 100),2 )) + '%')
    now = time.time()
    if now-start > hunting_time_limit:
      print(str(now-start) +  "s")
      return lowest_image_path
                
  return lowest_image_path


def digit_recognition(filename):

  API_URL = "https://api-inference.huggingface.co/models/farleyknight/mnist-digit-classification-2022-09-04"
  special_string = '-h-f-_-RT-U-J-E-M-Pb-GC-c-i-v-sji-bMsQmxuh-x-h-C-W-B-F-W-z-Gv-'
  is_escaped = special_string.replace("-", '')
  bear = "Bearer " + is_escaped
  headers = {"Authorization": bear}
  # get a prediction on what number this is
  def query(filename):
    with open(filename, "rb") as f:
      data = f.read()
    response = requests.post(API_URL, headers=headers, data=data)
    return response.json()

  # use latest model to generate a new image, return path
  ret = False 
  output = None
  while ret == False:
    output = query(filename + 'generated_image.png')
    if 'error' in output:
      time.sleep(10)
      ret = False 
    else:
      ret = True
  print(output)

  low_score_log = ''
  this_label_for_this_image = int(output[0]['label'])
  return {'full': output, 'number': this_label_for_this_image}


def get_other(original_image, hunting_time_limit):
  RANDO = str(time.time())
  file_path = 'tester/' + 'generation' + "/" + RANDO + '/'
  os.makedirs(file_path)
  fig = plt.figure(figsize=(1, 1))
  plt.subplot(1, 1, 0+1)
  plt.imshow(original_image, cmap='gray')
  plt.axis('off')
  plt.savefig(file_path + 'generated_image.png')
  plt.close()
  print('[+] done saving generation')
  print("[-] what digit is this")
  ret = digit_recognition(file_path)
  print(ret['full'])
  print(ret['number'])
  print("[+]", ret['number'])
  print("[-] show some most similar numbers")
  if ret["full"][0]['score'] <= 0.90:
    print("[!] error in image digit recognition, likely to not find a similar score")
    sys.exit()
  gen_filepath = file_path + 'generated_image.png'
  gen_label = ret['number']
  ret_sims = get_sims(gen_filepath, gen_label, file_path, hunting_time_limit)
  print("[+] done sims")
  # get the file-Path
  return (file_path + 'generated_image.png', ret_sims)

def generate_and_save_images(model):
  noise_dim = 100
  num_examples_to_generate = 1
  seed = tf.random.normal([num_examples_to_generate, noise_dim])

  # print(seed)

  n_samples = 1
  # Notice `training` is set to False.
  # This is so all layers run in inference mode (batchnorm).
  examples = model(seed, training=False)
  examples = examples * 255.0
  size = ceil(sqrt(n_samples))
  digit_images = np.zeros((28*size, 28*size), dtype=float)
  n = 0
  for i in range(size):
      for j in range(size):
          if n == n_samples:
              break
          digit_images[i* 28 : (i+1)*28, j*28 : (j+1)*28] = examples[n, :, :, 0]
          n += 1
  digit_images = (digit_images/127.5) -1 
  return digit_images

def TextToImage(Prompt,inference_steps, model):
  model_id = model
  if 'GAN' in model_id:
    print("do something else")
    model = from_pretrained_keras(model)
    image = generate_and_save_images(model)
  else:
    pipe = DiffusionPipeline.from_pretrained(model_id)
    the_randomness = int(str(time.time())[-1])
    print('seed', the_randomness)
    image = pipe(generator= torch.manual_seed(the_randomness), num_inference_steps=inference_steps).images[0]

#   pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16)
#   pipe = pipe.to("cpu")

  prompt = Prompt
  print(prompt)
  hunting_time_limit = None
  if prompt.isnumeric():
    hunting_time_limit = abs(int(prompt))

  original_image, other_images = get_other(image, hunting_time_limit)
  ai_gen = Image.open(open(original_image, 'rb'))
  training_data = Image.open(open(other_images, 'rb'))
  return [ai_gen, training_data]


import gradio as gr
interface = gr.Interface(fn=TextToImage, 
                        inputs=[gr.Textbox(show_label=True, label='How many seconds to hunt for copies?',), gr.Slider(1, 1000, label='Inference Steps', value=100, step=1), gr.Dropdown(modelieo)],
                        outputs=gr.Gallery(label="Generated image", show_label=True, elem_id="gallery", columns=[2], rows=[1], object_fit="contain", height="auto"), 
                        # css="#output_image{width: 256px !important; height: 256px !important;}",
                        title='Unconditional Image Generation')

interface.launch()





# import tensorflow as tf
# from diffusers import DiffusionPipeline
# import spaces
# # import torch
# import PIL.Image
# from PIL import Image
# from torch.autograd import Variable
# import gradio as gr
# import gradio.components as grc
# import numpy as np
# from huggingface_hub import from_pretrained_keras
# from image_similarity_measures.evaluate import evaluation
# import keras
# import time
# import requests
# import matplotlib.pyplot as plt
# import os 
# from pytorch_msssim import ssim, ms_ssim, SSIM, MS_SSIM
# from gradio_imageslider import ImageSlider

# # os.environ['KMP_DUPLICATE_LIB_OK']='TRUE'

# # options = ['Placeholder A', 'Placeholder B', 'Placeholder C']


# # pipeline = DiffusionPipeline.from_pretrained("nathanReitinger/MNIST-diffusion-oneImage")
# # device = "cuda" if torch.cuda.is_available() else "cpu"
# # pipeline = pipeline.to(device=device)

# # @spaces.GPU
# # def predict(steps, seed):
# #		 print("HI")
# #		 generator = torch.manual_seed(seed)
# #		 for i in range(1,steps):
# #				 yield pipeline(generator=generator, num_inference_steps=i).images[0]

# # gr.Interface(
# #		 predict,
# #		 inputs=[
# #				 grc.Slider(0, 1000, label='Inference Steps', value=42, step=1),
# #				 grc.Slider(0, 2147483647, label='Seed', value=42, step=1),
# #		 ],
# #		 outputs=gr.Image(height=28, width=28, type="pil", elem_id="output_image"),
# #		 css="#output_image{width: 256px !important; height: 256px !important;}",
# #		 title="Model Problems: Infringing on MNIST!",
# #		 description="Opening the black box.",
# # ).queue().launch()


# from diffusers import StableDiffusionPipeline
# import torch


# modellist=['nathanReitinger/MNIST-diffusion-oneImage',
# 	'nathanReitinger/MNIST-diffusion',
# #	'nathanReitinger/MNIST-GAN', 
# #	'nathanReitinger/MNIST-GAN-noDropout'
#  ]

# # pipeline = DiffusionPipeline.from_pretrained("nathanReitinger/MNIST-diffusion-oneImage")
# # device = "cuda" if torch.cuda.is_available() else "cpu"
# # pipeline = pipeline.to(device=device)


# def getModel(model):
# 	model_id = model

# 	(train_images, train_labels), (_, _) = tf.keras.datasets.mnist.load_data()
# 	RANDO = str(time.time())
# 	file_path = 'tester/' + model_id.replace("/", "-") + "/" + RANDO + '/'
# 	os.makedirs(file_path)
# 	train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')
# 	train_images = (train_images - 127.5) / 127.5	# Normalize the images to [-1, 1]

# 	print(model_id)
# 	image = None
# 	if 'diffusion' in model_id:
# 		pipe = DiffusionPipeline.from_pretrained(model_id)
# 		pipe = pipe.to("cpu")
# 		image = pipe(generator= torch.manual_seed(42), num_inference_steps=1).images[0]
# 	else:
# 		pipe = DiffusionPipeline.from_pretrained('nathanReitinger/MNIST-diffusion')
# 		pipe = pipe.to("cpu")
# 		test = from_pretrained_keras('nathanReitinger/MNIST-GAN')
# 		image = pipe(generator= torch.manual_seed(42), num_inference_steps=40).images[0]

# 	########################################### let's save this image for comparison to others
# 	fig = plt.figure(figsize=(1, 1))
# 	plt.subplot(1, 1, 0+1)
# 	plt.imshow(image, cmap='gray')
# 	plt.axis('off')
# 	plt.savefig(file_path + 'generated_image.png')
# 	plt.close()

# 	API_URL = "https://api-inference.huggingface.co/models/farleyknight/mnist-digit-classification-2022-09-04"

# 	# get a prediction on what number this is
# 	def query(filename):
# 		with open(filename, "rb") as f:
# 			data = f.read()
# 		response = requests.post(API_URL, data=data)
# 		return response.json()

# 	# use latest model to generate a new image, return path
# 	ret = False 
# 	output = None
# 	while ret == False:
# 		output = query(file_path + 'generated_image.png')
# 		if 'error' in output:
# 			time.sleep(10)
# 			ret = False 
# 		else:
# 			ret = True
# 	print(output)

# 	low_score_log = ''
# 	this_label_for_this_image = int(output[0]['label'])
# 	low_score_log += "this image has been identified as a:" + str(this_label_for_this_image) + "\n" + str(output) + "\n"
# 	print("===================")

# 	lowest_score = 10000
# 	lowest_image = None

# 	for i in range(len(train_labels)):
# 		# print(i)
# 		if train_labels[i] == this_label_for_this_image:

# 				###
# 				# get a real image (of correct number)
# 				###

# 				# print(i)
# 				to_check = train_images[i]
# 				fig = plt.figure(figsize=(1, 1))
# 				plt.subplot(1, 1, 0+1)
# 				plt.imshow(to_check, cmap='gray')
# 				plt.axis('off')
# 				plt.savefig(file_path + 'real_deal.png')
# 				plt.close()

# 				# baseline = evaluation(org_img_path='results/real_deal.png', pred_img_path='results/real_deal.png', metrics=["rmse", "psnr"])
# 				# print("---")

# 				###
# 				# check how close that real training data is to generated number
# 				###
# 				results = evaluation(org_img_path=file_path + 'real_deal.png', pred_img_path=file_path+'generated_image.png', metrics=["rmse", "psnr"])
# 				if results['rmse'] < lowest_score:

# 					lowest_score = results['rmse']
# 					lowest_image = to_check

# 					# image1 = np.array(Image.open(file_path + 'real_deal.png'))
# 					# image2 = np.array(Image.open(file_path + 'generated_image.png'))
# 					# img1 = torch.from_numpy(image1).float().unsqueeze(0).unsqueeze(0)/255.0
# 					# img2 = torch.from_numpy(image2).float().unsqueeze(0).unsqueeze(0)/255.0
# 					# img1 = Variable( img1,	requires_grad=False)
# 					# img2 = Variable( img2,	requires_grad=True)
# 					# ssim_score = ssim(img1, img2).item()

# 					# # sys.exit()
# 					# # l2 = distance.euclidean(image1, image2)

# 					# low_score_log += 'rmse score:' + str(lowest_score) + "\n"
# 					# low_score_log += 'ssim score:' + str(ssim_score) + "\n"
# 					# low_score_log += 'found when:' + str(round( ((i/len(train_labels)) * 100),2 )) + '%' + "\n"

# 					# low_score_log += "---------\n"
					
# 					# print(lowest_score, ssim_score, str(round( ((i/len(train_labels)) * 100),2 )) + '%')

# 					# fig = plt.figure(figsize=(1, 1))
# 					# plt.subplot(1, 1, 0+1)
# 					# plt.imshow(to_check, cmap='gray')
# 					# plt.axis('off')
# 					# plt.savefig(file_path+str(i) + "--" + str(lowest_score) + '---most_close.png')
# 					# plt.close()

								
# 	# f = open(file_path + "score_log.txt", "w+")
# 	# f.write(low_score_log)
# 	# f.close()

# 	print("Done!")


# 	############################################ return image that you just generated
# 	return [image, lowest_image]


# import gradio as gr
# output = "image"
# interface = gr.Interface(fn=getModel, inputs=[gr.Dropdown(modellist)], css="#output_image{width: 256px !important; height: 256px !important;}", outputs=output,  title='Model Problems (infringement)') # outputs="image",
# interface.launch(debug=True)