testing

app.py

@@ -5,13 +5,19 @@ 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
 
 # os.environ['KMP_DUPLICATE_LIB_OK']='TRUE'
 
@@ -68,6 +74,7 @@ def getModel(model):
 	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")
@@ -78,6 +85,105 @@ def getModel(model):
 		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
+
+	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']
+
+					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
 
 

requirements.txt

@@ -3,9 +3,13 @@
 diffusers==0.27.2
 gradio==4.28.3
 huggingface-hub==0.22.2
+image-similarity-measures==0.3.6
 keras==2.11.0
-tensorflow==2.11.0
-numpy==1.23.4
+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