test

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,13 @@
+---
+title: ModelProblems
+emoji: 🧠
+colorFrom: pink
+colorTo: indigo
+sdk: gradio
+sdk_version: 4.28.3
+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,400 @@
+# 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)

flagged/log.csv

@@ -0,0 +1,2 @@
+Inference Steps,Seed,output,flag,username,timestamp
+48,42,flagged/output/a7d3e3ed399e14f7629e/image.webp,,,2024-04-28 21:23:26.366305

requirements.txt

@@ -0,0 +1,16 @@
+# Automatically generated by https://github.com/damnever/pigar.
+
+diffusers==0.27.2
+gradio==4.28.3
+gradio_imageslider==0.0.20
+huggingface-hub==0.22.2
+image-similarity-measures==0.3.6
+keras==2.11.0
+matplotlib==3.8.4
+numpy==1.25.2
+pillow==10.3.0
+pytorch-msssim==1.0.0
+requests==2.31.0
+spaces==0.26.2
+tensorflow==2.11.0
+torch==2.2.2