def save_img(self, fig):
plt.imsave(os.path.join(self.dir_path, 'rank_list.jpg'), fig)
def format_image(note_image):
"""Format the Lilypond images uniformly.
:param str note_image: name of note png image to format
"""
im = mpimg.imread(note_image)
# find image boundaries
im_filter = np.where(im < 1)
x_min = np.min(im_filter[1])
x_max = np.max(im_filter[1])
y_clef_idx = np.median(np.where(im_filter[1] == x_min))
y_clef = im_filter[0][int(y_clef_idx)]
# crop image
x_pad = 15
vertical_total = 400
upper_pad = int(vertical_total / 2) - y_clef
row, col, rgb = im.shape
im = np.insert(im, 0, np.broadcast_to(im[0], (upper_pad, col, rgb)),
axis=0)
img_resize = im[:vertical_total, (x_min - x_pad):(x_max + x_pad)]
# set transparent background
row, col, rgb = img_resize.shape
img_transparent = np.append(img_resize, np.zeros((row, col, 1)),
axis=2)
mask = np.where(img_resize < 1)
img_transparent[mask[0], mask[1], -1] = 1
# save image
plt.imsave(note_image, img_transparent)
def test_imsave():
# The goal here is that the user can specify an output logical DPI
# for the image, but this will not actually add any extra pixels
# to the image, it will merely be used for metadata purposes.
# So we do the traditional case (dpi == 1), and the new case (dpi
# == 100) and read the resulting PNG files back in and make sure
# the data is 100% identical.
from numpy import random
random.seed(1)
data = random.rand(256, 128)
buff_dpi1 = io.BytesIO()
plt.imsave(buff_dpi1, data, dpi=1)
buff_dpi100 = io.BytesIO()
plt.imsave(buff_dpi100, data, dpi=100)
buff_dpi1.seek(0)
arr_dpi1 = plt.imread(buff_dpi1)
buff_dpi100.seek(0)
arr_dpi100 = plt.imread(buff_dpi100)
assert arr_dpi1.shape == (256, 128, 4)
assert arr_dpi100.shape == (256, 128, 4)
assert_array_equal(arr_dpi1, arr_dpi100)
def kmeans(iData, clustNumber, oPrefix, norm=False):
'''Perform k-means cluster analysis and return MAP of zones'''
print 'Run K-Means'
height, width = iData.shape[1:3]
#reshape 3D cube of data into 2D matrix and get indeces of valid pixels
iData, notNanDataI = cube2flat(iData)
if norm:
#center and norm
iDataMean = iData[:, notNanDataI].mean(axis=1)
iDataStd = iData[:, notNanDataI].std(axis=1)
iData = np.subtract(iData.T, iDataMean).T
iData = np.divide(iData.T, iDataStd).T
#perform kmeans on valid data and return codebook
codeBook = vq.kmeans(iData[:, notNanDataI].astype('f8').T, clustNumber)[0]
#perform vector quantization of input data uzing the codebook
#return vector of labels (for each valid pixel)
labelVec = vq.vq(iData[:, notNanDataI].astype('f8').T, codeBook)[0]+1
#create and fill MAP of zones
zoneMap = np.zeros(width*height) + np.nan
zoneMap[notNanDataI] = labelVec
zoneMap = zoneMap.reshape(height, width)
#visualize map of zones
plt.imsave(oPrefix + 'zones.png', zoneMap)
return zoneMap
def create_concentration_image(self, image_data):
cmap = cm.get_cmap()
cmap._init()
is_comparison_run = isinstance(self.scenario_run, models.ComparisonScenarioRun)
if not is_comparison_run or self.scenario_run.comparison_mode == "Absolute":
alphas = np.abs([min(n, 1.0) for n in np.linspace(0, 2, cmap.N)])
vmax = np.max(image_data)
vmin = np.min(image_data)
else:
results_max = np.max(image_data)
results_min = np.min(image_data)
if np.abs(results_max) > np.abs(results_min):
vmax = results_max
vmin = -results_max
else:
vmax = -results_min
vmin = results_min
results_range = vmax - vmin
value_array = np.linspace(vmin, vmax, cmap.N)
alphas = np.array([min(np.abs(v) / results_range * 2, 1.0) for v in value_array])
cmap._lut[:-3, -1] = alphas
if is_comparison_run:
output_directory = self.scenario_run.output_directory_1
else:
output_directory = self.scenario_run.output_directory
plt.imsave(fname=os.path.join(output_directory, "concentrations.png"),
arr=image_data, format='png', vmax=vmax, vmin=vmin)
def plot_brights(ax, path, star, regionList, goal=False):
'''
Components of this routine:
Projected brightness map
Please note that this has been modified for use in diagnostic plots,
there should really be a way to specify a windowNumber for real data
'''
currentWindow = 0
###########################
# Make the brightness map #
###########################
img = make_bright_image(star, regionList, currentWindow, goal=goal)
plt.imsave(path + "temp.jpg", img, cmap='hot', vmin=0.85, vmax=1.15)
plt.imshow(img, cmap='hot')
#Create the plot
bmap = Basemap(projection='moll', lon_0 = 0, ax=ax)
bmap.warpimage(path + "temp.jpg", ax=ax)
if goal:
ax.set_title("Desired Map")
else:
ax.set_title("Average Map")
def arrayToImg(mat, filename, format="png"):
"""
Write a 2D numpy array to a grayscale image.
If mat is 3D, will separately write each image along the 3rd dimension.
Parameters
----------
mat : array (2D or 3D), dtype must be uint8
Pixel values for image or set of images to write
filename : str
Base filename for writing
format : str, optional, default = "png"
Image format to write (see matplotlib's imsave for options)
"""
from matplotlib.pyplot import imsave
from matplotlib import cm
dims = shape(mat)
if len(dims) > 2:
for z in range(0, dims[2]):
cdata = mat[:, :, z]
imsave(filename+"-"+str(z)+"."+format, cdata, cmap=cm.gray)
elif len(dims) == 2:
imsave(filename+"."+format, mat, cmap=cm.gray)
else:
raise NotImplementedError('array must be 2 or 3 dimensions for image writing')
def input_image_setup(img_name, img2_name):
''' Nimmt ein Bild als input, erstellt eine "Regel-Karte". Bei der Bild-
erstellung bedenken: Rot = Gitter, Gruen = Verzweigt, Blau = Radial, wobei ein schwarzer
Pixel ein Zentrum definiert. '''
#TODO: Document
import matplotlib.image as mpimg
import matplotlib.pyplot as plt
import procedural_city_generation
import os
#TODO:translate
img = mpimg.imread(img_name)
img2 = mpimg.imread(img2_name)
import matplotlib.pyplot as plt
path=os.path.dirname(procedural_city_generation.__file__)
print path
plt.imsave(path+"/temp/diffused.png",img2,cmap='gray')
with open(path+"/temp/isdiffused.txt",'w') as f:
f.write("False")
img*=255
img2*=255
return img, img2
def save_imgs(path, name, data):
if not os.path.exists(path):
os.makedirs(path)
for _i, _f in enumerate(data):
fname = name + '_' + str(_i) + '.png'
fpath = os.path.join(path, fname)
plt.imsave(fpath, _f)
def toFilenameAndTiff(outputDirPath, kv):
key, image=kv
fname = outputDirPath+'/w_'+str(key)+'.tif'
if(len(image.shape)==3):
image=image.T
image=np.swapaxes(image,1,2)
imsave(fname, image)
def plot_linear_stretch(M, path, R, G, B, suffix=None):
"""
Plot a linear stretched RGB image.
Parameters:
M: `numpy array`
A HSI cube (m x n x p).
path: `string`
The path where to put the plot.
R: `int`
A band number that will render the red color.
G: `int`
A band number that will render the green color.
B: `int`
A band number that will render the blue color.
suffix: `string [default None]`
Add a suffix to the file name.
"""
img = _linear_stretch(M, R, G, B)
plt.ioff()
if suffix == None:
fout = osp.join(path, 'linear_stretch.png')
else:
fout = osp.join(path, 'linear_stretch_{0}.png'.format(suffix))
plt.imsave(fout, img)
def main():
"""
Args: save_path output_dir
"""
args = sys.argv
save_dir = args[1]
output_dir = args[2]
layer_list = [
'conv1/Conv/Conv2D',
'conv2/Conv/Conv2D',
'conv3/Conv/Conv2D',
'conv4/Conv/Conv2D',
'conv5/Conv/Conv2D',
'conv5/Conv_1/Conv2D',
'conv6/Conv/Conv2D'
]
channels = [16, 32, 64, 64, 128, 256, 2]
sess = tf.Session()
with sess.as_default():
maximize_output_multi = layers.prepare_graph(movie.build_net, save_dir)
for i, layer in enumerate(layer_list):
folder_name = layer.replace('/', '_')
directory = os.path.join(output_dir, folder_name)
create_dir(directory)
for channel in range(channels[i]):
result = maximize_output_multi(layer, channel, octave_n=4, iter_n=100, step=5.0, seed=123)
plt.imsave(os.path.join(directory, str(channel) + '.png'), result)
def draw_homotopy(metadata, config, target_path, idx1, idx2):
if not os.path.isfile(target_path + 'mu.npy'):
encode(metadata, config, target_path)
mu = np.load(target_path + 'mu.npy')
x1, y1 = config.x_train[idx1, :], config.y_train[idx1]
x2, y2 = config.x_train[idx2, :], config.y_train[idx2]
mu1, mu2 = mu[idx1, :], mu[idx2, :]
decoder = config.build_decoder()
decoder_layers = nn.layers.get_all_layers(decoder.l_out)
nparams = len(nn.layers.get_all_params(decoder.l_out))
nn.layers.set_all_param_values(decoder.l_out, metadata['param_values'][-nparams:])
print ' Decoder'
for layer in decoder_layers:
name = layer.__class__.__name__
print " %s %s" % (string.ljust(name, 32), nn.layers.get_output_shape(layer))
decode = theano.function([decoder.l_z.input_var], nn.layers.get_output(decoder.l_out))
p_range = np.arange(1, 0, -0.05)
tile = np.reshape(x1, (28, 28))
for p in p_range:
zp = p * mu1 + (1 - p) * mu2
zp = zp[np.newaxis, :]
xp_hat = decode(zp)
xp_hat = np.reshape(xp_hat, (28, 28))
tile = np.hstack((tile, xp_hat))
tile = np.hstack((tile, np.reshape(x2, (28, 28))))
plt.imsave(target_path + 'homotopy_%s-%s.png' % (str(y1), str(y2)), tile, cmap=matplotlib.cm.Greys)
def segment(sourceImage, DstImage):
import sys
sys.path.insert(0,'/home/joe/github/caffe-with_crop/python')
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
import caffe
# caffe.set_mode_gpu()
# caffe.set_device(0)
# load image, switch to BGR, subtract mean, and make dims C x H x W for Caffe
im = Image.open(sourceImage)
in_ = np.array(im, dtype=np.float32)
in_ = in_[:,:,::-1]
in_ -= np.array((104.00698793,116.66876762,122.67891434))
in_ = in_.transpose((2,0,1))
# load net
net = caffe.Net('/home/joe/github/caffe-with_crop/examples/fcn-32s-pascal-context/deploy.prototxt', '/home/joe/github/caffe-with_crop/examples/fcn-32s-pascal-context/fcn-32s-pascalcontext.caffemodel', caffe.TEST)
# shape for input (data blob is N x C x H x W), set data
net.blobs['data'].reshape(1, *in_.shape)
net.blobs['data'].data[...] = in_
# run net and take argmax for prediction
net.forward()
out = net.blobs['score'].data[0].argmax(axis=0)
# plt.imshow(out)
plt.imsave(DstImage, out)
def post_image(self, im, folder, filename='sources'):
"""
Post an image to S3 for this pull request
Parameters
----------
im : array
The image as a 2D array (grayscale) or 3D array (RGB)
name : str
The folder name to put file in
"""
from matplotlib.pyplot import imsave, cm
im = asarray(im)
imfile = io.BytesIO()
if im.ndim == 3:
imsave(imfile, im, format="png")
else:
imsave(imfile, im, format="png", cmap=cm.gray)
k = Key(self.bucket)
k.key = 'neurofinder/images/' + str(
self.id) + '/' + folder + '/' + filename + '.png'
k.set_contents_from_string(imfile.getvalue())
def draw_tile(metadata, config, target_path):
decoder = config.build_decoder()
decoder_layers = nn.layers.get_all_layers(decoder.l_out)
print " decoder layer output shapes:"
nparams = len(nn.layers.get_all_params(decoder.l_out))
nn.layers.set_all_param_values(decoder.l_out, metadata['param_values'][-nparams:])
for layer in decoder_layers:
name = layer.__class__.__name__
print " %s %s" % (string.ljust(name, 32), nn.layers.get_output_shape(layer))
mesh = np.linspace(0.001, 0.999, 20)
z = np.zeros((400, 2), dtype='float32')
for i in xrange(20):
for j in xrange(20):
z[20 * i + j, :] = np.array([norm.ppf(mesh[i]), norm.ppf(mesh[j])])
sample = theano.function([decoder.l_z.input_var], nn.layers.get_output(decoder_layers[-1]))
digits = sample(z)
tile = np.zeros((20 * 28, 20 * 28), dtype='float32')
for i in xrange(20):
for j in xrange(20):
d = np.reshape(digits[20 * i + j, :], (28, 28))
tile[i * 28:(i + 1) * 28, j * 28:(j + 1) * 28] = d
plt.imsave(target_path + 'tile.png', tile, cmap=matplotlib.cm.Greys)
def xest_create_segmentation_from_seeds(self):
"test whether we can create a segmentation from given seeds."
first_image = plt.imread(path.join(dirname(__file__),
'data/ilastik_data/CropStack20001_Simple Segmentation.tif'))
seed_image = mesh.create_seeds_from_image( first_image )
actual_image = plt.imread(path.join(dirname(__file__),
'data/image_data/CropStack20001.tif'))
segmented_image = mesh.create_segmentation_from_seeds( actual_image, seed_image )
self.assertEqual( segmented_image.dtype, np.dtype('uint16') )
plt.imsave( path.join(dirname(__file__),
'output/testsegmentation.tif'), segmented_image )
cv2.imwrite( path.join(dirname(__file__),
'output/testsegmentationwithcv2.tif'), segmented_image )
reloaded_image = cv2.imread( path.join(dirname(__file__),
'output/testsegmentationwithcv2.tif'), flags = -1 )
np.testing.assert_equal( segmented_image, reloaded_image )
def prep_image(url,idx,dataset,datadir,width=224,filetype='jpg',verbose=False):
'''
Check to see image file has been downloaded at current size. If it has not,
download and resize image. Saves file to datadir/images/[dataset]_[idx]_w[width].[filetype]
e.g. datadir/images/train_10001_w256.bmp
args:
url: url of image source
idx: image row index
dataset: string 'train' or 'test' or other identifier
datadir: data directory
width: desired width of image. Will be resized to width squared
returns:
rawim: scaled and cropped image
'''
outpath = datadir + 'images/' + dataset + '_' + str(idx) + '_w' + str(width) + '.' + filetype
if not os.path.isfile(outpath):
if verbose:
print "downloading image #%s..." %str(idx)
try:
rawim = download_and_resize(url,width)
plt.imsave(outpath,rawim)
return rawim
except:
print "unable to download image #%i from url %s..." %(idx,url)
return None
else:
if verbose:
print "Image %i already downloaded. Loading from file..." % idx
rawim = plt.imread(outpath)
return rawim
def generate_cross_dissolve(im1,im2,file_path):
step_size = 0.1
step_array = np.arange(0,1 + step_size,step_size)
for t in step_array:
cd_im = np.add(t*im1, (1.-t) * im2)
file_path_t = file_path+'_'+str(t)+'_r.jpg'
plt.imsave(file_path_t, cd_im)
def forward(self, bottom, top):
"""Forward data in the architecture to the following layer."""
input_heatMaps = bottom[0].data[...]
heatMaps = np.zeros((self.batch_size, self.num_channels, self.input_size, self.input_size))
metadata = bottom[1].data[...]
# consider each image in the batch individually
for b in range(self.batch_size):
(_, camera, _, _) = self.extractMetadata(metadata[b])
# get new points
(points, cov_matrices) = self.manifoldDataConversion(input_heatMaps[b], camera)
# heatMaps[b] = self.sumHeatMaps(input_heatMaps[b], self.generateHeatMaps(points, cov_matrices))
heatMaps[b] = self.generateHeatMaps(points, cov_matrices)
if (self.debug_mode):
for j in range(self.num_channels):
name = '%s/tmp/batch_%d_beforeafter_%d.png' % (os.environ['HOME'], b, j)
if (np.max(input_heatMaps[b,j,:,:]) > 0):
rescaled_input = np.divide(input_heatMaps[b,j],np.max(input_heatMaps[b,j]))
else:
rescaled_input = input_heatMaps[b,j]
vis = np.concatenate((rescaled_input, heatMaps[b,j]), axis=1)
plt.imsave(name,vis)
if (np.max(input_heatMaps[b,j]) == 0):
name = '%s/tmp/exception_zero_%d_%d.png' % (os.environ['HOME'], b, j)
plt.imsave(name,vis)
top[0].data[...] = heatMaps
def test_imsave(fmt):
if fmt in ["jpg", "jpeg", "tiff"]:
pytest.importorskip("PIL")
has_alpha = fmt not in ["jpg", "jpeg"]
# The goal here is that the user can specify an output logical DPI
# for the image, but this will not actually add any extra pixels
# to the image, it will merely be used for metadata purposes.
# So we do the traditional case (dpi == 1), and the new case (dpi
# == 100) and read the resulting PNG files back in and make sure
# the data is 100% identical.
np.random.seed(1)
# The height of 1856 pixels was selected because going through creating an
# actual dpi=100 figure to save the image to a Pillow-provided format would
# cause a rounding error resulting in a final image of shape 1855.
data = np.random.rand(1856, 2)
buff_dpi1 = io.BytesIO()
plt.imsave(buff_dpi1, data, format=fmt, dpi=1)
buff_dpi100 = io.BytesIO()
plt.imsave(buff_dpi100, data, format=fmt, dpi=100)
buff_dpi1.seek(0)
arr_dpi1 = plt.imread(buff_dpi1, format=fmt)
buff_dpi100.seek(0)
arr_dpi100 = plt.imread(buff_dpi100, format=fmt)
assert arr_dpi1.shape == (1856, 2, 3 + has_alpha)
assert arr_dpi100.shape == (1856, 2, 3 + has_alpha)
assert_array_equal(arr_dpi1, arr_dpi100)
def __init__(self, global_counter, path_to_mha=None, how_many_from_one=1, saving_path='./test_data/'):
if path_to_mha is None:
raise NameError(' missing .mha path ')
self.images = []
for i in range(0, len(path_to_mha)):
self.images.append(np.array(sitk.GetArrayFromImage(sitk.ReadImage(path_to_mha[i]))))
mkdir_p(saving_path)
plt.set_cmap('gray')
while how_many_from_one > 0:
image_to_save = np.zeros((5,
216,
160))
rand_value = rnd.randint(30, len(self.images[0]) - 30)
for i in range(0, len(path_to_mha)):
try:
image_to_save[i] = self.images[i][rand_value]
except:
print('ahi')
print(self.images[i][rand_value].shape)
print(type(self.images))
print(type(self.images))
print('*')
continue
print(image_to_save.shape)
image_to_save = image_to_save.reshape((216 * 5, 160))
print(image_to_save.shape)
# image_to_save = resize(image_to_save, (5*216, 160), mode='constant')
# image_to_save = image_to_save.resize(5*216, 160)
plt.imsave(saving_path + str(global_counter) + '.png',
image_to_save)
global_counter += 1
how_many_from_one -= 1
def _post_step(self, t):
file_name = os.path.join(self._dir_name, self._file_fmt.format(t))
spins = np.array([[self._ising.s(i, j)
for j in range(self._ising.N())]
for i in range(self._ising.N())])
plt.imsave(file_name, spins)
return True
def detect():
try:
image = request.files.get('file')
recog_face = bool(int(request.files.get('face').file.read()))
files = {'file': StringIO(image.file.read())}
objs = requests.post('http://{}/object'.format(OBJ_SERVER),
files=files)
objs = json.loads(objs.text)
print recog_face
if recog_face:
img = None
for bb in objs:
if bb['label'] == 'person':
if img is None:
image.file.seek(0)
img = io.imread(StringIO(image.file.read()))
x1, y1, x2, y2 = bb['bbox']
person_img = img[y1:y2, x1:x2]
# detect face
s = StringIO()
plt.imsave(s, person_img)
s.seek(0)
faces = requests.post('http://{}/face'.format(FACE_SERVER),
files={'file': s})
bb['face'] = json.loads(faces.text)
return json.dumps(objs)
except Exception as e:
print str(type(e)), e
def showEigFace(self, idx=0):
eigface = np.float32(self.eigenfaces[idx])
print 'Eigface', eigface
print 'SHAPE:', eigface.shape
im = np.reshape(eigface, self.imsize)
picName = 'eigFaceImage' + str(idx) + '.png'
plt.imsave(picName, im, cmap=pylab.gray())
def save_results(true_labels, predicted_labels, clf_name, classification_dir):
cm_int = confusion_matrix (true_labels, predicted_labels);
cm_float = cm_int/np.apply_along_axis(np.sum, 1, cm_int).astype('float');
report = classification_report(true_labels, predicted_labels, np.arange(0,len(class_names)), class_names);
# Save results
plt.imsave(classification_dir + '/' + clf_name + "_cm.png", cm_float , cmap=cmt.gray)
float_cm_file = classification_dir +'/' + clf_name + "_float_cm.txt"
fos = open(float_cm_file, 'w');
np.savetxt(fos,cm_float);
fos.close();
int_cm_file = classification_dir +'/' + clf_name + "_int_cm.txt"
fos = open(int_cm_file, 'w');
np.savetxt(fos,cm_int);
fos.close();
report_file = classification_dir +'/' + clf_name + "_report.txt"
fos = open(report_file, 'w');
fos.write(report);
fos.close();
labels_file = classification_dir +'/' + clf_name + "_labels.txt"
fos = open(labels_file, 'w');
np.savetxt(fos,np.column_stack((true_labels,predicted_labels)));
fos.close();
p, r, f1, s = precision_recall_fscore_support(true_labels, predicted_labels,labels=np.arange(0,len(class_names)))
prf1s_file = classification_dir +'/' + clf_name + "_prf1s.txt"
fos = open(prf1s_file, 'w');
np.savetxt(fos,np.column_stack((p, r, f1, s)));
fos.close();
def save(self, face_img, face_id, pose, landmark, name): # save the face image pose_bin_id = self.get_pose_bin_id(pose.yaw, pose.pitch) #print "Yaw=%d Pitch=%d Bin Name=%d" % (int(pose.yaw), int(pose.pitch), pose_bin_id) save_path = self.bin2path(pose_bin_id) + '/' + name + '.png' #print "saving image to path:", save_path plt.imsave(save_path, face_img) # save the data file # this data file could be optimized, by sorting the face_id print "saving image data file to path:", self.data_file_path() # here will change what we want to store # basically, we need the following data for ranking # 1. yaw, pitch and roll: yaw and pitch should match first, # and then roll. # 2. distance between eyes: to estimate the resolution # 3. and also I think I need the name, but this could be provided by # using the image file name data_file_handler = open(self.data_file_path(), 'a') print >>data_file_handler, "%d"%pose_bin_id, print >>data_file_handler, "%s"%name, print >>data_file_handler, "%d %d %d"%(pose.yaw, pose.pitch, pose.roll), for point in landmark.all_points: print >>data_file_handler, point, print >>data_file_handler, "" return save_path
def main():
parser = argparse.ArgumentParser(
description="Photometric Stereo",
)
parser.add_argument(
"--lightning",
nargs="?",
help="Filename of JSON file containing lightning information",
)
parser.add_argument(
"--mask",
nargs="?",
help="Filename of an image containing a mask of the object",
)
parser.add_argument(
"image",
nargs="*",
help="Images filenames",
)
parser.add_argument(
"--generate-map",
action='store_true',
help="Generate a map.png file which represends the colors of the "
"normal mapping.",
)
args = parser.parse_args()
if args.generate_map:
normals = generateNormalMap()
plt.imsave('map.png', normals)
return
if not len(args.image) >= 3:
print("Please specify 3+ image files.")
return
if args.lightning:
normals = photometricStereo(args.lightning, args.image)
if False:
try:
with open('data.pkl', 'rb') as fhdl:
normals = pickle.load(fhdl)
except:
with open('data.pkl', 'wb') as fhdl:
pickle.dump(normals, fhdl)
else:
normals = photometricStereoWithoutLightning(args.image)
if args.mask:
mask = getImage(args.mask)
mask = mask.T
print(normals.shape, mask.shape)
normals[mask<(mask.max() - mask.min())/2.] = np.nan
color = colorizeNormals(normals)
plt.imsave('out.png', color)
mesh.write3dNormals(normals, 'out-3dn.stl')
surface = mesh.surfaceFromNormals(normals)
mesh.writeMesh(surface, normals, 'out-mesh.stl')
def plot2(fn,p,wa,vmin,vmax,ups):
# Check matrix dimensions are the same
(m,n)=p.shape
if (m,n)!=wa.shape:
print "Matrix dimension mismatch"
# Set up output array and scaling constant
o=np.zeros((m*ups,n*ups,3))
vsca=1.0/(vmax-vmin)
# Assemble the output array
for i in range(m):
iu=i*ups
for j in range(n):
ju=j*ups
if wa[i,j]==1:
o[iu:iu+ups,ju:ju+ups,0]=1
o[iu:iu+ups,ju:ju+ups,1]=1
o[iu:iu+ups,ju:ju+ups,2]=1
else:
(re,gr,bl)=palette2(fscale(p[i,j],vmin,vsca))
o[iu:iu+ups,ju:ju+ups,0]=re
o[iu:iu+ups,ju:ju+ups,1]=gr
o[iu:iu+ups,ju:ju+ups,2]=bl
# Save the image
plt.imsave(fn,o)
def get_top_nearest_neigbors(num_generated, nearneig, real_features_hdf5, gen_features_hdf5, maximum=False, random_select=False, save_path=None):
real_img_hdf5 = real_features_hdf5.replace('_features_', '_images_')
gen_img_hdf5 = gen_features_hdf5.replace('_features_', '_images_')
real_features_file = h5py.File(real_features_hdf5, 'r')
gen_features_file = h5py.File(gen_features_hdf5, 'r')
real_img_file = h5py.File(real_img_hdf5, 'r')
gen_img_file = h5py.File(gen_img_hdf5, 'r')
real_features = real_features_file['features']
gen_features = gen_features_file['features']
real_img = real_img_file['images']
gen_img = gen_img_file['images']
with tf.Session() as sess:
real_features = tf.constant(np.array(real_features), dtype=tf.float32)
gen_features = tf.constant(np.array(gen_features), dtype=tf.float32)
# Get Nearest Neighbors for all generated images.
gen_real_distances = tf.sqrt(tf.abs(euclidean_distance(gen_features, real_features)))
neg = tf.negative(gen_real_distances)
neg_s_distances, s_indices = tf.math.top_k(input=neg, k=nearneig, sorted=True)
s_distances = tf.negative(neg_s_distances)
# Getting the top smallest distances between Generated and Real images.
neg_s_distances1, s_indices1 = tf.math.top_k(input=neg, k=1, sorted=True)
neg_s_distances1 = tf.transpose(neg_s_distances1)
if not random_select:
if maximum:
neg_s_distances1 = tf.negative(neg_s_distances1)
neg_s_distances1, s_indices1 = tf.math.top_k(input=neg_s_distances1, k=num_generated, sorted=True)
s_indices1 = tf.transpose(s_indices1)
s_indices1 = s_indices1.eval()
else:
lin = list(range(int(gen_real_distances.shape[0])))
random.shuffle(lin)
s_indices1 = np.zeros((num_generated,1), dtype=np.int8)
s_indices1[:, 0] = lin[:num_generated]
s_indices = s_indices.eval()
s_distances = s_distances.eval()
# For the images with top smallest distances, show nearest neighbors.
height, width, channels = real_img.shape[1:]
neighbors = dict()
grid = np.zeros((num_generated*height, (nearneig+1)*width, channels))
for i, ind in enumerate(s_indices1):
ind = ind[0]
total = gen_img[ind]
neighbors[ind] = list()
for j in range(nearneig):
neighbors[ind].append((s_indices[ind,j], s_distances[ind,j]))
real = real_img[s_indices[ind,j]]/255.
total = np.concatenate([total, real], axis=1)
grid[i*height:(i+1)*height, :, :] = total
plt.imshow(grid)
if save_path is not None:
plt.imsave(save_path, grid)
return neighbors
def main():
logging.basicConfig(level=logging.INFO)
imagename = "1_27_s.bmp"
unaryfilename = "1_27_s.c_unary.txt"
logging.info("Read image.")
img = utility.readimg(imagename)
logging.info("Load unaries.")
unaries = utility.loadunaryfile(os.path.join("data", unaryfilename))
# Calculate energy
unaries = -np.log(unaries)
numlabels = unaries.shape[2]
w = 100000
l = 0.5
pd1 = PD1(img, unaries, numlabels, w, l)
pd1.segment()
img = pd1.get_labeled_image()
logging.info("Save image.")
plt.imsave("img_out", img)
plt.imshow(img)
plt.show()
json_gt = [json.loads(line) for line in open(str(jsonFiles[fileCounter]))]
# Looping over the single file from upper loop line by line
for cnt in range(len(json_gt)): #range(1,10):
gt = json_gt[cnt]
gt_lanes = gt['lanes']
y_samples = gt['h_samples']
raw_file = gt['raw_file']
#print(raw_file)
#img_test = plt.imread("10.jpg")
######## Saving Original Image File ##########
path_image_updated = path_image + str(file_name_counter) + ext
img = plt.imread(raw_file)
plt.imsave(path_image_updated, img)
print(img.shape)
#plt.imshow(img)
#plt.show()
'''
'raw_file': str. Clip file path.
'lanes': list. A list of lanes. For each list of one lane, the elements are width values on image.
'h_samples': list. A list of height values corresponding to the 'lanes', which means len(h_samples) == len(lanes[i])
'''
# Here For each lanes loop fetched its x from lanes[i] and
# y from h_samples which is same for all lane for that particular JSON ROW
#gt_lanes_vis = [[(x, y) for (x, y) in zip(lane, y_samples) if x >= 0] for lane in gt_lanes]
#List of Lanes are samerated from the JSON file
# that can be passed to the polylines for plotting
lane_list = []
def partTransport(direction, particles, eruption, origin, loss, diff_loss):
''' calculates transport of particles trough wind'''
q = 0
rows = int(np.shape(particles)[0])
cols = int(np.shape(particles)[1])
print("Modeling process initiated, goint through {} iterations".format(max(iterations)+1))
#for-loop to go through specified amount of timesteps
for n in iterations:
#create temporary array to save calculated time step
temp_arr = np.zeros((rows, cols))
#dynamic particle generation at volcano
particles[origin[0], origin[1]] = eruption[q]
particles[origin2[0],origin2[1]] = eruption[q]
particles[origin3[0], origin3[1]] = eruption[q]
particles[origin4[0], origin4[1]] = eruption[q]
print("..." * 10)
print("..." * 10)
print("timestep {}, erupting {}ppm".format(q+1, eruption[q]))
#go through every pixel and evaluate its next time step, then save to temp_arr
i = 0
while i < rows:
j = 0
while j < cols:
#to check if it works correctly:
#print("going trough pixel at {},{}".format(i, j))
try:
# this calculates the following per timestep:
# new location of particles [depending on wind] = sum((old location[s] of particles) * loss)
if direction[i, j] == 0:
# top left
temp_arr[i-1, j-1] += particles[i,j] * loss * (1-diff_loss)
#save indices to make further steps look more simple on paper
z = i-1
u = j-1
#assign each surrounding pixel of end-of-timestep-target pixel the diffusion value
temp_arr[z-1, u-1] += particles[i,j] * loss * diff_loss
temp_arr[z-1, u] += particles[i,j] * loss * diff_loss
temp_arr[z-1, u+1] += particles[i,j] * loss * diff_loss
temp_arr[z, u+1] += particles[i,j] * loss * diff_loss
temp_arr[z+1, u+1] += particles[i,j] * loss * diff_loss
temp_arr[z+1, u] += particles[i,j] * loss * diff_loss
temp_arr[z+1, u-1] += particles[i,j] * loss * diff_loss
temp_arr[z, u-1] += particles[i,j] * loss * diff_loss
elif direction[i, j] == 1:
# top middle
temp_arr[i - 1, j] += particles[i,j] * loss * (1-diff_loss)
# save indices to make further steps look more simple on paper
z = i - 1
u = j
# assign each surrounding pixel of end-of-timestep-target pixel the diffusion value
temp_arr[z - 1, u - 1] += particles[i, j] * loss * diff_loss
temp_arr[z - 1, u] += particles[i, j] * loss * diff_loss
temp_arr[z - 1, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u - 1] += particles[i, j] * loss * diff_loss
temp_arr[z, u - 1] += particles[i, j] * loss * diff_loss
elif direction[i, j] == 2:
# top right
temp_arr[i - 1, j + 1] += particles[i,j] * loss * (1-diff_loss)
# save indices to make further steps look more simple on paper
z = i - 1
u = j + 1
# assign each surrounding pixel of end-of-timestep-target pixel the diffusion value
temp_arr[z - 1, u - 1] += particles[i, j] * loss * diff_loss
temp_arr[z - 1, u] += particles[i, j] * loss * diff_loss
temp_arr[z - 1, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u - 1] += particles[i, j] * loss * diff_loss
temp_arr[z, u - 1] += particles[i, j] * loss * diff_loss
elif direction[i, j] == 3:
# middle right
temp_arr[i, j + 1] += particles[i,j] * loss * (1-diff_loss)
# save indices to make further steps look more simple on paper
z = i
u = j + 1
# assign each surrounding pixel of end-of-timestep-target pixel the diffusion value
temp_arr[z - 1, u - 1] += particles[i, j] * loss * diff_loss
temp_arr[z - 1, u] += particles[i, j] * loss * diff_loss
temp_arr[z - 1, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u - 1] += particles[i, j] * loss * diff_loss
temp_arr[z, u - 1] += particles[i, j] * loss * diff_loss
elif direction[i, j] == 4:
# bottom right
temp_arr[i + 1, j + 1] += particles[i,j] * loss * (1-diff_loss)
# save indices to make further steps look more simple on paper
z = i + 1
u = j + 1
# assign each surrounding pixel of end-of-timestep-target pixel the diffusion value
temp_arr[z - 1, u - 1] += particles[i, j] * loss * diff_loss
temp_arr[z - 1, u] += particles[i, j] * loss * diff_loss
temp_arr[z - 1, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u - 1] += particles[i, j] * loss * diff_loss
temp_arr[z, u - 1] += particles[i, j] * loss * diff_loss
elif direction[i, j] == 5:
# bottom middle
temp_arr[i + 1, j] += particles[i,j] * loss * (1-diff_loss)
# save indices to make further steps look more simple on paper
z = i + 1
u = j
# assign each surrounding pixel of end-of-timestep-target pixel the diffusion value
temp_arr[z - 1, u - 1] += particles[i, j] * loss * diff_loss
temp_arr[z - 1, u] += particles[i, j] * loss * diff_loss
temp_arr[z - 1, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u - 1] += particles[i, j] * loss * diff_loss
temp_arr[z, u - 1] += particles[i, j] * loss * diff_loss
elif direction[i, j] == 6:
# bottom left
temp_arr[i + 1, j - 1] += particles[i,j] * loss * (1-diff_loss)
# save indices to make further steps look more simple on paper
z = i + 1
u = j - 1
# assign each surrounding pixel of end-of-timestep-target pixel the diffusion value
temp_arr[z - 1, u - 1] += particles[i, j] * loss * diff_loss
temp_arr[z - 1, u] += particles[i, j] * loss * diff_loss
temp_arr[z - 1, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u - 1] += particles[i, j] * loss * diff_loss
temp_arr[z, u - 1] += particles[i, j] * loss * diff_loss
elif direction[i, j] == 7:
# middle left
temp_arr[i, j - 1] += particles[i,j] * loss * (1-diff_loss)
# save indices to make further steps look more simple on paper
z = i
u = j - 1
# assign each surrounding pixel of end-of-timestep-target pixel the diffusion value
temp_arr[z - 1, u - 1] += particles[i, j] * loss * diff_loss
temp_arr[z - 1, u] += particles[i, j] * loss * diff_loss
temp_arr[z - 1, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u + 1] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u] += particles[i, j] * loss * diff_loss
temp_arr[z + 1, u - 1] += particles[i, j] * loss * diff_loss
temp_arr[z, u - 1] += particles[i, j] * loss * diff_loss
except IndexError:
pass
j +=1
i += 1
# enabling iteration for the for loop
q += 1
# saving temp_arr as the new particles for the next time-step
particles = temp_arr
plt.imsave("Ash_Plumes\Ash_Plume{}".format(q), particles)
print("{}{} RESULTS {}{}".format("\n","---"*10,"---"*10, "\n"))
print("Model ran {} timesteps with volcanic output of \n{}\n".format(iterate,eruption))
print("Wind direction Raster: \n", w_direction, "\n")
print("Model output: \n", np.rint(particles))
#plt.imshow(w_direction, cmap='gray')
#plt.imshow(particles, cmap='gray')
plt.imsave("Wind_Direction\Wind_Direction", w_direction)
return np.rint(particles)
import cv2
import numpy as np
import matplotlib.pyplot as plt
# 画像読み込み
image = cv2.imread('./capture.jpg', cv2.IMREAD_COLOR)
# 縦横の長さの取得
height, width = image.shape[:2]
# 画像を４つに分ける
kirinuki1 = image[0:height / 2, 0:width / 2]
kirinuki2 = image[0:height / 2, width / 2:width]
kirinuki3 = image[height / 2:height, 0:width / 2]
kirinuki4 = image[height / 2:height, width / 2:width]
# 画像反転( = 0:上下反転, > 0:左右反転, < 0:上下左右反転)
kirinuki1 = cv2.flip(kirinuki1, -1)
kirinuki2 = cv2.flip(kirinuki2, -1)
kirinuki3 = cv2.flip(kirinuki3, -1)
kirinuki4 = cv2.flip(kirinuki4, -1)
# 反転後の画像を適用
image[0:height / 2, 0:width / 2] = kirinuki1
image[0:height / 2, width / 2:width] = kirinuki2
image[height / 2:height, 0:width / 2] = kirinuki3
image[height / 2:height, width / 2:width] = kirinuki4
# 色の補正
image = image[:, :, [2, 1, 0]]
# 画像の表示
plt.imshow(image)
plt.show()
# 画像の保存
plt.imsave('reverse.png', image)
def main(args):
log_dir = args.log_path if (
args.log_path is not None
) else "/tmp/stable_baselines_" + time.strftime('%Y-%m-%d-%H-%M-%S')
if MPI is None or MPI.COMM_WORLD.Get_rank() == 0:
rank = 0
configure_logger(log_dir)
else:
rank = MPI.COMM_WORLD.Get_rank()
configure_logger(log_dir, format_strs=[])
set_global_seeds(args.seed)
model_class = SAC_parallel
n_workers = args.num_workers if not args.play else 1
env_kwargs = get_env_kwargs(args.env,
random_ratio=args.random_ratio,
sequential=args.sequential,
reward_type=args.reward_type,
n_object=args.n_object)
def make_thunk(rank):
return lambda: make_env(
env_id=args.env, rank=rank, log_dir=log_dir, kwargs=env_kwargs)
env = ParallelSubprocVecEnv([make_thunk(i) for i in range(n_workers)],
reset_when_done=True)
if os.path.exists(os.path.join(logger.get_dir(), 'eval.csv')):
os.remove(os.path.join(logger.get_dir(), 'eval.csv'))
print('Remove existing eval.csv')
eval_env_kwargs = env_kwargs.copy()
eval_env_kwargs['random_ratio'] = 0.0
eval_env = make_env(env_id=args.env, rank=0, kwargs=eval_env_kwargs)
eval_env = FlattenDictWrapper(
eval_env, ['observation', 'achieved_goal', 'desired_goal'])
if not args.play:
os.makedirs(log_dir, exist_ok=True)
# Available strategies (cf paper): future, final, episode, random
goal_selection_strategy = 'future' # equivalent to GoalSelectionStrategy.FUTURE
if not args.play:
from stable_baselines.ddpg.noise import NormalActionNoise
noise_type = args.action_noise.split('_')[0]
if noise_type == 'none':
parsed_action_noise = None
elif noise_type == 'normal':
sigma = float(args.action_noise.split('_')[1])
parsed_action_noise = NormalActionNoise(
mean=np.zeros(env.action_space.shape),
sigma=sigma * np.ones(env.action_space.shape))
else:
raise NotImplementedError
train_kwargs = get_train_kwargs("sac", args, parsed_action_noise,
eval_env)
def callback(_locals, _globals):
if _locals['step'] % int(1e3) == 0:
if 'FetchStack' in args.env:
mean_eval_reward = stack_eval_model(
eval_env,
_locals["self"],
init_on_table=(args.env == 'FetchStack-v2'))
elif 'MasspointPushDoubleObstacle-v2' in args.env:
mean_eval_reward = egonav_eval_model(
eval_env,
_locals["self"],
env_kwargs["random_ratio"],
fixed_goal=np.array([4., 4., 0.15, 0., 0., 0., 1.]))
mean_eval_reward2 = egonav_eval_model(
eval_env,
_locals["self"],
env_kwargs["random_ratio"],
goal_idx=0,
fixed_goal=np.array([4., 4., 0.15, 1., 0., 0., 0.]))
log_eval(_locals['self'].num_timesteps,
mean_eval_reward2,
file_name="eval_box.csv")
else:
mean_eval_reward = eval_model(eval_env, _locals["self"])
log_eval(_locals['self'].num_timesteps, mean_eval_reward)
if _locals['step'] % int(2e4) == 0:
model_path = os.path.join(
log_dir, 'model_' + str(_locals['step'] // int(2e4)))
model.save(model_path)
print('model saved to', model_path)
return True
class CustomSACPolicy(SACPolicy):
def __init__(self, *model_args, **model_kwargs):
super(CustomSACPolicy, self).__init__(
*model_args,
**model_kwargs,
layers=[256, 256] if 'MasspointPushDoubleObstacle'
in args.env else [256, 256, 256, 256],
feature_extraction="mlp")
register_policy('CustomSACPolicy', CustomSACPolicy)
from utils.sac_attention_policy import AttentionPolicy
register_policy('AttentionPolicy', AttentionPolicy)
policy_kwargs = get_policy_kwargs("sac", args)
if rank == 0:
print('train_kwargs', train_kwargs)
print('policy_kwargs', policy_kwargs)
# Wrap the model
model = HER2(args.policy,
env,
model_class,
n_sampled_goal=4,
goal_selection_strategy=goal_selection_strategy,
num_workers=args.num_workers,
policy_kwargs=policy_kwargs,
verbose=1,
**train_kwargs)
print(model.get_parameter_list())
# Train the model
model.learn(
int(args.num_timesteps),
seed=args.seed,
callback=callback,
log_interval=100 if not ('MasspointMaze-v3' in args.env) else 10)
if rank == 0:
model.save(os.path.join(log_dir, 'final'))
# WARNING: you must pass an env
# or wrap your environment with HERGoalEnvWrapper to use the predict method
if args.play and rank == 0:
assert args.load_path is not None
model = HER2.load(args.load_path, env=env)
fig, ax = plt.subplots(1, 1, figsize=(8, 8))
obs = env.reset()
if 'FetchStack' in args.env:
env.env_method('set_task_array',
[[(env.get_attr('n_object')[0], 0)]])
obs = env.reset()
while env.get_attr('current_nobject')[0] != env.get_attr(
'n_object')[0] or env.get_attr('task_mode')[0] != 1:
obs = env.reset()
elif 'FetchPushWallObstacle' in args.env:
while not (obs['observation'][0][4] > 0.7
and obs['observation'][0][4] < 0.8):
obs = env.reset()
env.env_method('set_goal', [np.array([1.18, 0.8, 0.425, 1, 0])])
obs = env.env_method('get_obs')
obs = {
'observation': obs[0]['observation'][None],
'achieved_goal': obs[0]['achieved_goal'][None],
'desired_goal': obs[0]['desired_goal'][None]
}
# obs[0] = np.concatenate([obs[0][key] for key in ['observation', 'achieved_goal', 'desired_goal']])
elif 'MasspointPushDoubleObstacle' in args.env or 'FetchPushWallObstacle' in args.env:
while np.argmax(obs['desired_goal'][0][3:]) != 0:
obs = env.reset()
elif 'MasspointMaze-v2' in args.env:
while obs['observation'][0][0] < 3 or obs['observation'][0][1] < 3:
obs = env.reset()
env.env_method('set_goal', [np.array([1., 1., 0.15])])
obs = env.env_method('get_obs')
obs = {
'observation': obs[0]['observation'][None],
'achieved_goal': obs[0]['achieved_goal'][None],
'desired_goal': obs[0]['desired_goal'][None]
}
print('goal', obs['desired_goal'][0], 'obs', obs['observation'][0])
episode_reward = 0.0
images = []
frame_idx = 0
num_episode = 0
for i in range(env_kwargs['max_episode_steps'] * 10):
img = env.render(mode='rgb_array')
ax.cla()
ax.imshow(img)
tasks = ['pick and place', 'stack']
ax.set_title('episode ' + str(num_episode) + ', frame ' +
str(frame_idx) + ', task: ' +
tasks[np.argmax(obs['observation'][0][-2:])])
images.append(img)
action, _ = model.predict(obs, deterministic=True)
obs, reward, done, _ = env.step(action)
episode_reward += reward
frame_idx += 1
if args.export_gif:
plt.imsave(
os.path.join(os.path.dirname(args.load_path),
'tempimg%d.png' % i), img)
else:
plt.pause(0.02)
if done:
print('episode_reward', episode_reward)
obs = env.reset()
if 'FetchStack' in args.env:
while env.get_attr('current_nobject')[0] != env.get_attr('n_object')[0] or \
env.get_attr('task_mode')[0] != 1:
obs = env.reset()
elif 'MasspointPushDoubleObstacle' in args.env or 'FetchPushWallObstacle' in args.env:
while np.argmax(obs['desired_goal'][0][3:]) != 0:
obs = env.reset()
print('goal', obs['desired_goal'][0])
episode_reward = 0.0
frame_idx = 0
num_episode += 1
if num_episode >= 1:
break
exit()
if args.export_gif:
os.system('ffmpeg -r 5 -start_number 0 -i ' +
os.path.dirname(args.load_path) +
'/tempimg%d.png -c:v libx264 -pix_fmt yuv420p ' +
os.path.join(os.path.dirname(args.load_path), args.env +
'.mp4'))
for i in range(env_kwargs['max_episode_steps'] * 10):
# images.append(plt.imread('tempimg' + str(i) + '.png'))
try:
os.remove(
os.path.join(os.path.dirname(args.load_path),
'tempimg' + str(i) + '.png'))
except:
pass
discriminator.trainable = True
# Train the discriminator on this batch
discriminator.train_on_batch(X_fake_vs_real, y1)
#####################################
## TRAINING THE GENERATOR ######
###################################
# Create some noise
noise = tf.random.normal(shape=[batch_size, codings_size])
# We want discriminator to belive that fake images are real
y2 = tf.constant([[1.]] * batch_size)
# Avois a warning
discriminator.trainable = False
GAN.train_on_batch(noise, y2)
print("TRAINING COMPLETE")
# Most likely your generator will only learn to create one type of noisey zero
# Regardless of what noise is passed in.
noise = tf.random.normal(shape=[10, codings_size])
image = generator(noise)
plt.imsave(FLAGS.path, image)
from sklearn.metrics import confusion_matrix
conf_mx = confusion_matrix(y_test, final_predictions)
print(accuracy_score(y_test, final_predictions))
print(conf_mx)
np.savetxt("accuracy_score.txt", [accuracy_score(y_test, final_predictions)],
delimiter=",",
fmt='%10.5f')
np.savetxt("conf_mat.csv", conf_mx, delimiter=",", fmt='%10.0f')
data = conf_mx
image_product = 70
new_data = np.zeros(np.array(data.shape) * image_product)
for j in range(data.shape[0]):
for k in range(data.shape[1]):
new_data[j * image_product:(j + 1) * image_product,
k * image_product:(k + 1) * image_product] = data[j, k]
# plt.imshow(new_data, cmap=plt.cm.gray)
# plt.show()
plt.imsave("confusion_mat.jpg", new_data, dpi=1000, cmap=plt.cm.gray)
# In[ ]:
# from sklearn.model_selection import cross_val_predict,cross_val_score
# clf = KNeighborsClassifier(n_jobs=-1)
# y_train_pred = cross_val_score(clf, X_train, y_train, cv=10)
# print(y_train_pred)
# y_train_pred = cross_val_predict(clf, X_train, y_train, cv=10)
# print(y_train_pred)
# Storing the styles
styles = []
for style_path in style_files:
style = style_tf(Image.open(str(style_path)))
if args.preserve_color:
style = coral(style, content)
style = style.to(device).unsqueeze(0)
styles.append(style)
# Generating and saving stylized images
for img_path in txt_files:
print(img_path)
cls_id = str(img_path.split('_')[0])
content_path = (args.content_dir / img_path).with_suffix(".jpg")
img_name = str(content_path).split('/')[-1][-15:]
path = str(content_path).split('JPEGImages/')[0] + 'JPEGImages/' + img_name
content = content_tf(Image.open(str(path))).squeeze()
content = content.to(device).unsqueeze(0)
for i, style in enumerate(styles):
with torch.no_grad():
output = style_transfer(vgg, decoder, content, style, args.alpha)
output = output.squeeze().permute(1, 2, 0).cpu().numpy()
output = (output * 255).astype(np.uint8)
out_path = output_dir / (str(i) + "_" + str(content_path.name))
plt.imsave(str(out_path), output)
def imgshow(file_name, img):
npimg = np.transpose(img.numpy(), (1, 2, 0))
f = "./%s.png" % file_name
Wmin = img.min
Wmax = img.max
plt.imsave(f, npimg, vmin=Wmin, vmax=Wmax)
print('test start!')
for x_, _ in test_loader:
if opt.inverse_order:
y_ = x_[:, :, :, :x_.size()[2]]
x_ = x_[:, :, :, x_.size()[2]:]
else:
y_ = x_[:, :, :, x_.size()[2]:]
x_ = x_[:, :, :, :x_.size()[2]]
if x_.size()[2] != opt.input_size:
x_ = util.imgs_resize(x_, opt.input_size)
y_ = util.imgs_resize(y_, opt.input_size)
x_ = Variable(x_.cuda(), volatile=True)
test_image = G(x_)
s = test_loader.dataset.imgs[n][0][::-1]
s_ind = len(s) - s.find('/')
e_ind = len(s) - s.find('.')
ind = test_loader.dataset.imgs[n][0][s_ind:e_ind - 1]
path = opt.dataset + '_results/test_results/' + ind + '_input.png'
plt.imsave(path, (x_[0].cpu().data.numpy().transpose(1, 2, 0) + 1) / 2)
path = opt.dataset + '_results/test_results/' + ind + '_output.png'
plt.imsave(path,
(test_image[0].cpu().data.numpy().transpose(1, 2, 0) + 1) / 2)
path = opt.dataset + '_results/test_results/' + ind + '_target.png'
plt.imsave(path, (y_[0].numpy().transpose(1, 2, 0) + 1) / 2)
n += 1
print('%d images generation complete!' % n)
image_dir = ""
dst_dir = ""
for fff in os.listdir(image_dir):
if fff.endswith(".jpg"):
image_path = os.path.join(image_dir, fff)
dst_path = os.path.join(dst_dir, fff)
image_np = load_image_into_numpy_array(image_path)
input_tensor = tf.convert_to_tensor(np.expand_dims(image_np, 0),
dtype=tf.float32)
detections, predictions_dict, shapes = detect_fn(input_tensor)
label_id_offset = 1
image_np_with_detections = image_np.copy()
viz_utils.visualize_boxes_and_labels_on_image_array(
image_np_with_detections,
detections['detection_boxes'][0].numpy(),
(detections['detection_classes'][0].numpy() +
label_id_offset).astype(int),
detections['detection_scores'][0].numpy(),
category_index,
use_normalized_coordinates=True,
max_boxes_to_draw=10,
min_score_thresh=.30,
agnostic_mode=False)
plt.figure(figsize=(12, 16))
plt.imsave(dst_path, image_np_with_detections)
def test_rbm():
''' Demonstrate how to train and afterwards sample from
:param leaning_rate:
:param training_ecpochs
:param dataset
:param barch_size
:param n_chains
:param n_samples
'''
#import dataset
mnist = input_data.read_data_sets("MNIST_data", one_hot=True)
# parameters
leaning_rate = 0.01
training_epochs = 1
batch_size = 50
display_step = 1
#define input
x = tf.placeholder(tf.float32, [None, 784])
#network parameters
n_visible = 784
n_hidden = 500
grbm = GRBM(x, n_visible=n_visible, n_hidden=n_hidden)
cost = grbm.get_reconstruct_cost()
#create the persistent variable
#persistent_chain = tf.Variable(tf.zeros([batch_size, n_hidden]), dtype = tf.float32)
persistent_chain = None
train = grbm.train_ops(lr=leaning_rate, persistent=persistent_chain, k=1)
#initializing the variables
init = tf.global_variables_initializer()
#################
# training RBM
#################
with tf.Session() as sess:
start_time = timeit.default_timer()
sess.run(init)
total_batch = int(mnist.train.num_examples / batch_size)
for epoch in range(training_epochs):
c = 0.0
#print(sess.run(grbm.W))
# loop over all batches
for i in range(total_batch):
batch_xs, batch_ys = mnist.train.next_batch(batch_size)
# run optimization op (batchprop) and cost op
_ = sess.run(train, feed_dict={x: batch_xs})
c += sess.run(cost, feed_dict={x: batch_xs}) / total_batch
#display logs per epoch step
if epoch % display_step == 0:
print("epoch", '%04d' % (epoch + 1), "cost",
"{:.4f}".format(c))
#print(sess.run(grbm.W))
#construct image from the weight matrix
plt.imsave("new_filters_at_{0}.png".format(epoch),
tile_raster_images(X=sess.run(tf.transpose(grbm.W)),
img_shape=(28, 28),
tile_shape=(10, 10),
tile_spacing=(1, 1)),
cmap='gray')
plt.show()
end_time = timeit.default_timer()
training_time = end_time - start_time
print("TIME:{0} minutes".format(training_time / 60, ))
"""
#################################
# Sampling from the RBM #
#################################
# Reconstruct the image by sampling
print("...Sampling from the RBM")
n_chains = 20
n_batch = 10
n_samples = n_batch *2
number_test_examples = mnist.test.num_examples
#randomly select the n_chains examples
test_indexs = np.random.randint(number_test_examples - n_chains * n_batch)
test_samples = mnist.test.images[test_indexs:test_indexs + n_chains * n_batch]
#create the persistent variable saving the visiable state
#persistent_v_chain = tf.Variable(tf.to_float(test_samples), dtype = tf.float32)
# the step of gibbs
#step_every = 1000
'''
# implement the gibbs sampling
cond = lambda j, h_mean, h_sample, v_mean, v_sample: j < step_every
body = lambda j, h_mean, h_sample, v_mean, v_sample: (j+1, ) + grbm.gibbs_vhv(v_sample)
j, h_mean, h_sample, v_mean, v_sample = tf.while_loop(cond, body, loop_vars=[tf.constant(0), tf.zeros([n_chains, n_hidden]),
tf.zeros([n_chains, n_hidden]), tf.zeros(tf.shape(persistent_v_chain)), persistent_v_chain])
'''
# Update the persistent_v_chain
#new_persistent_v_chain = tf.assign(persistent_v_chain, v_sample)
# Store the image by sampling
image_data = np.zeros((29*(n_samples+1)+1, 29*(n_chains)-1),
dtype="uint8")
# Initialize the variable
#sess.run(tf.variables_initializer(var_list=[persistent_v_chain]))
# Do successive sampling
for idx in range(n_batch):
#sample = sess.run(v_mean)
#sess.run(new_persistent_v_chain)
# Add the original images
'''
image_data[2*idx*29 : 2*idx *29 + 28,:] = tile_raster_images(X=test_samples[idx*n_batch, (idx+1)*n_chains],
img_shape=(28, 28),
tile_shape=(1, n_chains),
tile_spacing=(1, 1))
'''
sample = sess.run(grbm.reconstruction, feed_dict = {x : test_samples[idx*n_batch, (idx+1)*n_chains]})
print("...plotting sample", idx)
image_data[(2*idx +1)*29:(2 * idx +1)*29+28,:] = tile_raster_images(X=sample,
img_shape=(28, 28),
tile_shape=(1, n_chains),
tile_spacing=(1, 1))
#image = plt.imshow(image_data)
plt.imsave("new_original_and_{0}samples.png".format(n_samples), image_data, cmap = 'gray')
plt.show()
"""
# Randomly select the 'n_chains' examples
n_chains = 20
n_batch = 10
n_samples = n_batch * 2
number_test_examples = mnist.test.num_examples
test_indexs = np.random.randint(number_test_examples -
n_chains * n_batch)
test_samples = mnist.test.images[test_indexs:test_indexs +
n_chains * n_batch]
image_data = np.zeros((29 * (n_samples + 1) + 1, 29 * (n_chains) - 1),
dtype="uint8")
# Add the original images
for i in range(n_batch):
image_data[2 * i * 29:2 * i * 29 + 28, :] = tile_raster_images(
X=test_samples[i * n_batch:(i + 1) * n_chains],
img_shape=(28, 28),
tile_shape=(1, n_chains),
tile_spacing=(1, 1))
samples = sess.run(
grbm.reconstruction(x),
feed_dict={x: test_samples[i * n_batch:(i + 1) * n_chains]})
image_data[(2 * i + 1) * 29:(2 * i + 1) * 29 +
28, :] = tile_raster_images(X=samples,
img_shape=(28, 28),
tile_shape=(1, n_chains),
tile_spacing=(1, 1))
image = plt.imsave("original_and_reconstruct.png",
image_data,
cmap='gray')
plt.show()
def train_epoch(self, netG, netD, optimizerG, optimizerD, real, style,
m_noise, m_image, epoch, z_opt, z_prev, opt):
"""
Trains network for one epoch.
Arguments:
epoch (int) : Current epoch.
z_prev () : Can be None on the first epoch.
opt (argparse.ArgumentParser) : Command line arguments.
Returns:
errG (torch.cuda.FloatTensor) : Error of generator
errD (torch.cuda.FloatTensor) : Error of discriminator
D_x (torch.cuda.FloatTensor) : Error of discriminator on original image
D_G_z (torch.cuda.FloatTensor) : Error of discriminator on fake image
rec_loss (torch.cuda.FloatTensor) : Reconstruction loss
"""
# Scale 0
if (self.Gs == []):
# Generate optimal noise that will be kept fixed during training
z_opt = generate_noise([1, opt.nzx, opt.nzy], device=opt.device)
z_opt = m_noise(z_opt.expand(1, 3, opt.nzx, opt.nzy))
noise_ = generate_noise([1, opt.nzx, opt.nzy], device=opt.device)
noise_ = m_noise(noise_.expand(1, 3, opt.nzx, opt.nzy))
else:
noise_ = generate_noise([opt.nc_z, opt.nzx, opt.nzy],
device=opt.device)
noise_ = m_noise(noise_)
m_real = m_image(real)
m_style = m_image(style)
############################
# (1) Update D network: maximize D(x) + D(G(z))
###########################
# Multiple steps for D
for j in range(opt.Dsteps):
# TRAIN WITH REAL IMAGE
netD.zero_grad()
output = netD(real).to(opt.device)
D_real_map = output.detach()
errD_real = -output.mean() #-a
errD_real.backward(retain_graph=True)
D_x = -errD_real.item()
# TRAIN WITH FAKE IMAGE
# Only in the very first step of the very first epoch for a layer
if (j == 0) and (epoch == 0):
# Scale 0
if (self.Gs == []):
# Define image and noise from previous scales (Nothing for Scale 0)
prev = torch.full([1, opt.nc_z, opt.nzx, opt.nzy],
0,
device=opt.device)
self.in_s = prev
prev = m_image(prev)
z_prev = torch.full([1, opt.nc_z, opt.nzx, opt.nzy],
0,
device=opt.device)
z_prev = m_noise(z_prev)
opt.noise_amp = 1
# Remaining scales other than 0
else:
# Calculate image and noise from previous scales with draw_concat function
prev = draw_concat(
self.Gs, self.Zs, self.reals, self.styles,
self.NoiseAmp, self.in_s, 'rand', m_noise, m_image,
opt) # Randomly generate image using previous scales
prev = m_image(prev)
z_prev = draw_concat(
self.Gs, self.Zs, self.reals, self.styles,
self.NoiseAmp, self.in_s, 'rec', m_noise, m_image, opt
) # Generate image with optimal noise using previous scales
criterion = nn.MSELoss()
RMSE = torch.sqrt(
criterion(real, z_prev)
) # noise amplitude for a certain layer is decided according to the performance of previous layers
opt.noise_amp = opt.noise_amp_init * RMSE
z_prev = m_image(z_prev)
# If not very first epoch, just generate previous image
else:
prev = draw_concat(self.Gs, self.Zs, self.reals, self.styles,
self.NoiseAmp, self.in_s, 'rand', m_noise,
m_image, opt)
prev = m_image(prev)
# Scale 0
if (self.Gs == []):
noise = noise_
# Other scales
else:
noise = opt.noise_amp * noise_ + prev
# Generate image with G and calculate loss from fake image
fake = netG(noise.detach(), prev, m_real)
output = netD(fake.detach())
errD_fake = output.mean()
errD_fake.backward(retain_graph=True)
D_G_z = output.mean().item()
# WGAN Loss with gradient penalty
gradient_penalty = calc_gradient_penalty(netD, real, fake,
opt.lambda_grad,
opt.device)
gradient_penalty.backward()
errD = errD_real + errD_fake + gradient_penalty
optimizerD.step()
############################
# (2) Update G network: maximize D(G(z))
###########################
# Multiple steps for G
for j in range(opt.Gsteps):
netG.zero_grad()
### Calculate Discriminator Loss
# Only in the very first step of the very first epoch for a layer
if (j == 0) and (epoch == 0):
# Scale 0
if (self.Gs == []):
# Define image and noise from previous scales (Nothing for Scale 0)
prev = torch.full([1, opt.nc_z, opt.nzx, opt.nzy],
0,
device=opt.device)
self.in_s = prev
prev = m_image(prev)
z_prev = torch.full([1, opt.nc_z, opt.nzx, opt.nzy],
0,
device=opt.device)
z_prev = m_noise(z_prev)
opt.noise_amp = 1
# Remaining scales other than 0
else:
# Calculate image and noise from previous scales with draw_concat function
prev = draw_concat(
self.Gs, self.Zs, self.reals, self.styles,
self.NoiseAmp, self.in_s, 'rand', m_noise, m_image,
opt) # Randomly generate image using previous scales
prev = m_image(prev)
z_prev = draw_concat(
self.Gs, self.Zs, self.reals, self.styles,
self.NoiseAmp, self.in_s, 'rec', m_noise, m_image, opt
) # Generate image with optimal noise using previous scales
criterion = nn.MSELoss()
RMSE = torch.sqrt(
criterion(real, z_prev)
) # noise amplitude for a certain layer is decided according to the performance of previous layers
opt.noise_amp = opt.noise_amp_init * RMSE
z_prev = m_image(z_prev)
# If not very first epoch, just generate previous image
else:
prev = draw_concat(self.Gs, self.Zs, self.reals, self.styles,
self.NoiseAmp, self.in_s, 'rand', m_noise,
m_image, opt)
prev = m_image(prev)
# Scale 0
if (self.Gs == []):
noise = noise_
# Other scales
else:
noise = opt.noise_amp * noise_ + prev
# Generate image with G and calculate loss from fake image
fake = netG(noise.detach(), prev, m_real)
output = netD(fake)
D_fake_map = output.detach()
errG = -output.mean()
errG.backward(retain_graph=True)
scale_weight = [1.0, 0.95, 0.9, 0.8, 0.5, 0.1, 0.01, 0.0005]
### Reconstruction Loss
if opt.rec_weight != 0:
loss = nn.L1Loss()
Z_opt = opt.noise_amp * z_opt + z_prev
rec_loss = opt.rec_weight * scale_weight[len(self.Gs)] * loss(
netG(noise.detach(), prev, m_real), real)
rec_loss.backward(retain_graph=True)
rec_loss = rec_loss.detach()
else:
Z_opt = z_opt
rec_loss = 0
# Generate image with G and calculate loss from fake image
fake_style = netG(noise.detach(), prev, m_style.detach())
### Style loss, layers from AdaIN
style_loss = opt.alpha * (
1 - scale_weight[len(self.Gs)]) * adain_style_loss(
style, fake_style, self.vgg, opt.style_layers)
style_loss.backward()
optimizerG.step()
if epoch % opt.niter_update == 0 or epoch == (opt.niter - 1):
plt.imsave('%s/fake_style_sample.png' % (opt.outf),
convert_image_np(fake_style.detach()),
vmin=0,
vmax=1)
plt.imsave('%s/fake_real_sample.png' % (opt.outf),
convert_image_np(fake.detach()),
vmin=0,
vmax=1)
plt.imsave('%s/G(z_opt).png' % (opt.outf),
convert_image_np(
netG(Z_opt.detach(), z_prev, m_real).detach()),
vmin=0,
vmax=1)
plt.imsave('%s/D_fake.png' % (opt.outf),
convert_image_np(D_fake_map))
plt.imsave('%s/D_real.png' % (opt.outf),
convert_image_np(D_real_map))
if (opt.vis != False):
opt.vis.image(
convert_image_np(netG(Z_opt.detach(),
z_prev).detach()).transpose(2, 0, 1),
win=opt.viswindows[-1],
opts=dict(title='G(z_opt) on scale %d' % len(self.Gs),
width=self.max_width,
height=self.max_height))
# Temporarily plot errG in total loss plot
return rec_loss.item(), style_loss.item(), errG.detach(), z_opt, z_prev
for i in range(1, 399):
for j in range(1, 399):
arround = np.array(
[[s[i - 1, j - 1], s[i - 1, j], s[i - 1, j + 1]],
[s[i, j - 1], 0, s[i, j + 1]],
[s[i + 1, j - 1], s[i + 1, j], s[i + 1, j + 1]]])
if arround.sum() == 3: s2[i, j] = 1
elif s[i, j] == 0 and arround.sum() == 2: s2[i, j] = 0
elif s[i, j] == 1 and arround.sum() == 2: s2[i, j] = 1
else: s2[i, j] = 0
return s2
while True:
fclock.tick(fps)
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE: exit()
else: pass
s = gen_next(s)
body = pygame.surfarray.make_surface(s * 255)
screem.fill((0, 0, 0))
screem.blit(body, (0, 0))
pygame.display.update()
generator_times += 1
if generator_times % 10 == 0: print('第 %s 代...' % generator_times)
screem_array = pygame.surfarray.array2d(screem)[200 - 40:200 + 40,
200 - 40:200 + 40]
plt.imsave('%s.jpg' % generator_times, screem_array)
if not os.path.exists('captures'):
os.makedirs('captures')
camera = PiCamera()
camera.resolution = tuple(camera_resolution)
camera.framerate = camera_framerate
rawCapture = PiRGBArray(camera, size=tuple(camera_resolution))
time.sleep(0.5)
frame_counter = 0
start_time = time.time()
for frame in camera.capture_continuous(rawCapture, format="rgb", use_video_port=True):
image = frame.array
# Comment this out if your camera is mounted on the top
image = cv2.flip(image, -1)
image = fisheye_correction.undistort(image)
plt.imsave("captures/img" + str(frame_counter) + ".jpg", image)
frame_counter += 1
rawCapture.truncate(0)
if time.time() - start_time > record_time:
break
def style_transfer(cnn,
content_image,
style_image,
image_size,
style_size,
content_layer,
content_weight,
style_layers,
style_weights,
tv_weight,
init_random=False):
"""
Run style transfer!
Inputs:
- cnn: CNN model to extracf features
- content_image: filename of content image
- style_image: filename of style image
- image_size: size of smallest image dimension (used for content loss and generated image)
- style_size: size of smallest style image dimension
- content_layer: layer to use for content loss
- content_weight: weighting on content loss
- style_layers: list of layers to use for style loss
- style_weights: list of weights to use for each layer in style_layers
- tv_weight: weight of total variation regularization term
- init_random: initialize the starting image to uniform random noise
"""
# Extract features for the content image
pil_img = PIL.Image.open(content_image)
# Some png files have alpha channel, esp. screenshots. Convert them to rgb
if pil_img.mode == 'RGBA':
pil_img = color.rgba2rgb(pil_img)
pil_img = PIL.Image.fromarray(pil_img.astype('uint8'))
content_img = preprocess(pil_img, size=image_size)
feats = extract_features(content_img, cnn)
content_target = feats[content_layer].clone()
# Extract features for the style image
pil_img = PIL.Image.open(style_image)
if pil_img.mode == 'RGBA':
pil_img = color.rgba2rgb(pil_img)
pil_img = PIL.Image.fromarray(pil_img.astype('uint8'))
style_img = preprocess(pil_img, size=style_size)
feats = extract_features(style_img, cnn)
style_targets = []
for idx in style_layers:
style_targets.append(gram_matrix(feats[idx].clone()))
dtype = torch.cuda.FloatTensor if torch.cuda.is_available(
) else torch.FloatTensor
# Initialize output image to content image or nois
if init_random:
img = torch.Tensor(content_img.size()).uniform_(0, 1).type(dtype)
else:
img = content_img.clone().type(dtype)
# We do want the gradient computed on our image!
img.requires_grad_()
if torch.cuda.is_available():
img = img.cuda()
# Set up optimization hyperparameters
initial_lr = 3.0
decayed_lr = 0.1
decay_lr_at = 180
# Note that we are optimizing the pixel values of the image by passing
# in the img Torch tensor, whose requires_grad flag is set to True
optimizer = torch.optim.Adam([img], lr=initial_lr)
# f, axarr = plt.subplots(1,2)
# axarr[0].axis('off')
# axarr[1].axis('off')
# axarr[0].set_title('Content Source Img.')
# axarr[1].set_title('Style Source Img.')
# axarr[0].imshow(deprocess(content_img.cpu()))
# axarr[1].imshow(deprocess(style_img.cpu()))
# plt.show()
# plt.figure()
for t in range(250):
if t < 190:
img.data.clamp_(-1.5, 1.5)
optimizer.zero_grad()
feats = extract_features(img, cnn)
# Compute loss
c_loss = content_loss(content_weight, feats[content_layer],
content_target)
s_loss = style_loss(feats, style_layers, style_targets, style_weights)
t_loss = tv_loss(img, tv_weight)
loss = c_loss + s_loss + t_loss
loss.backward()
# Perform gradient descents on our image values
if t == decay_lr_at:
optimizer = torch.optim.Adam([img], lr=decayed_lr)
optimizer.step()
# if t % 100 == 0:
# print('Iteration {}'.format(t))
# plt.axis('off')
# plt.imshow(deprocess(img.data.cpu()))
# plt.show()
#print('Iteration {}'.format(t))
#plt.axis('off')
#plt.imshow(deprocess(img.data.cpu()))
unique_name = str(uuid.uuid4()) + ".png"
result_path = "static/images/" + unique_name
plt.imsave(result_path, im_convert(img))
return unique_name
def save_instance(image,
boxes,
masks,
class_ids,
class_names,
scores=None,
title="",
figsize=(16, 16),
ax=None,
show_mask=True,
show_bbox=True,
colors=None,
captions=None,
save_path=None):
# Number of instances
N = boxes.shape[0]
if not N:
print("\n*** No instances to display *** \n")
else:
assert boxes.shape[0] == masks.shape[-1] == class_ids.shape[0]
if not ax:
_, ax = plt.subplots(1, figsize=figsize)
# Generate random colors
colors = colors or random_colors(N)
# Show area outside image boundaries.
height, width = image.shape[:2]
ax.set_ylim(height + 10, -10)
ax.set_xlim(-10, width + 10)
ax.axis('off')
ax.set_title(title)
masked_image = image.astype(np.uint32).copy()
for i in range(N):
color = colors[i]
# Bounding box
if not np.any(boxes[i]):
# Skip this instance. Has no bbox. Likely lost in image cropping.
continue
y1, x1, y2, x2 = boxes[i]
if show_bbox:
p = patches.Rectangle((x1, y1),
x2 - x1,
y2 - y1,
linewidth=2,
alpha=0.7,
linestyle="dashed",
edgecolor=color,
facecolor='none')
ax.add_patch(p)
# Mask
mask = masks[:, :, i]
if show_mask:
masked_image = apply_mask(masked_image, mask, color)
# Mask Polygon
# Pad to ensure proper polygons for masks that touch image edges.
padded_mask = np.zeros((mask.shape[0] + 2, mask.shape[1] + 2),
dtype=np.uint8)
padded_mask[1:-1, 1:-1] = mask
contours = find_contours(padded_mask, 0.5)
for verts in contours:
# Subtract the padding and flip (y, x) to (x, y)
verts = np.fliplr(verts) - 1
p = Polygon(verts, facecolor="none", edgecolor=color)
ax.add_patch(p)
plt.imsave(save_path, masked_image.astype(np.uint8))
def train(self):
"""
Trains GAN for niter epochs over stop_scale number of scales. Main training loop that calls train_scale.
Controls transition between layers. After training is done for a certain layer, freezes weights of the trained scale, and arranges computational graph by changing requires_grad parameters.
"""
scale_num = 0
nfc_prev = 0
### Visualization
# For visualization, let's just for now do maximal image dimensions
self.opt.viswindows = [
] # Windows in visdom that is updated during training G(z_opt)
self.max_width = convert_image_np(self.real).shape[0]
self.max_height = convert_image_np(self.real).shape[1]
### Load the VGG network
vgg = VGG()
vgg.load_state_dict(
torch.load(self.opt.pretrained_VGG, map_location=self.opt.device))
self.vgg = vgg.to(self.opt.device)
# Make sure this network is frozen
for parameter in self.vgg.parameters():
parameter.requires_grad_(False)
# Training loop for each scale
while scale_num < self.opt.stop_scale + 1:
# Number of filters in D and G changes every 4th scale
self.opt.nfc = min(
self.opt.nfc_init * pow(2, math.floor(scale_num / 4)), 128)
self.opt.min_nfc = min(
self.opt.min_nfc_init * pow(2, math.floor(scale_num / 4)), 128)
# Create output directory and save the downsampled image
self.opt.out_ = generate_dir2save(self.opt)
self.opt.outf = '%s/%d' % (self.opt.out_, scale_num)
try:
os.makedirs(self.opt.outf)
except OSError:
pass
#plt.imsave('%s/in.png' % (self.opt.out_), convert_image_np(self.real), vmin=0, vmax=1)
#plt.imsave('%s/original.png' % (self.opt.out_), convert_image_np(real_), vmin=0, vmax=1)
plt.imsave('%s/real_scale.png' % (self.opt.outf),
convert_image_np(self.reals[scale_num]),
vmin=0,
vmax=1)
# Initialize D and G of the current scale. D and G will be initialized with the previous scale's weights if the dimensions match.
D_curr, G_curr = self.init_models()
if (nfc_prev == self.opt.nfc):
G_curr.load_state_dict(
torch.load('%s/%d/netG.pth' %
(self.opt.out_, scale_num - 1)))
D_curr.load_state_dict(
torch.load('%s/%d/netD.pth' %
(self.opt.out_, scale_num - 1)))
# Training of single scale
z_curr, G_curr = self.train_scale(G_curr, D_curr, self.opt)
# Stop gradient calculation for G and D of current scale
G_curr = reset_grads(G_curr, False)
G_curr.eval()
D_curr = reset_grads(D_curr, False)
D_curr.eval()
# Store the necessary variables of this scale
self.Gs.append(G_curr)
self.Zs.append(z_curr)
self.NoiseAmp.append(self.opt.noise_amp)
# Save the networks and important parameters
torch.save(self.Zs, '%s/Zs.pth' % (self.opt.out_))
torch.save(self.Gs, '%s/Gs.pth' % (self.opt.out_))
torch.save(self.reals, '%s/reals.pth' % (self.opt.out_))
torch.save(self.styles, '%s/styles.pth' % (self.opt.out_))
torch.save(self.NoiseAmp, '%s/NoiseAmp.pth' % (self.opt.out_))
scale_num += 1
nfc_prev = self.opt.nfc # Update the number of filters
del D_curr, G_curr
# Generate with training variables
SinGAN_generate(self.Gs, self.Zs, self.reals, self.styles,
self.NoiseAmp, self.opt)
output = np.transpose(output, (1, 2, 0))
image = image[:, :, (2, 1, 0)]
error_image = np.zeros((ind.shape[0], ind.shape[1], 3))
diff_image = label - ind
#TruePositive
#error_image[] = [ 0, 48,255]
#error_image[label ==1] = [255, 0 , 176]
error_image[diff_image > 0] = [178, 255, 102]
error_image[diff_image < 0] = [255, 51, 51]
# print image.shape,rgb_gt.shape,rgb.shape
#scipy.misc.toimage(rgb, cmin=0.0, cmax=255).save(IMAGE_FILE+'_segnet.png')
plt.figure()
plt.imsave("/home/ubuntu/images/" + str(i) + "o.png",
image,
vmin=0,
vmax=1)
#plt.figure()
#plt.imshow(rgb_gt,vmin=0, vmax=1)
plt.figure()
plt.imsave("/home/ubuntu/images/" + str(i) + "h.png", error_image)
#plt.imshow(rgb,vmin=0, vmax=1)
plt.show()
y_true = label.flatten()
y_pred = ind.flatten()
score = jaccard_similarity_score(y_true, y_pred)
scores.append(score)
print "image ", i, " score: ", score
def extract_channel(image_name):
img = cv2.imread(image_name)
plt.imsave(image_name, img[:, :, 0], cmap='gray')
def user_input(local_vars):
save_name = local_vars['exp_config'].save_name
_banner = """
========================
=== ELEKTRONN2 SHELL ===
========================
>> %s <<
Shortcuts:
'help' (display this help text),
'q' (leave menu), 'kill'(saving last params),
'sethist <int>', 'setlr <float>',
'setmom <float>', 'setwd <float> (weight decay)
'paramstats' , 'gradstats',
'actstats' (print statistics)
'sf <nodename>' (show filters)',
'load <filename>' (param files only, no model files),
'preview' (produce preview predictions),
'ip' (start embedded IPython shell)
For everything else enter a command in the command line\n""" % (
save_name, )
_ipython_banner = """ You are now in the embedded IPython shell.
You still have full access to the local scope of the ELEKTRONN2 shell
(e.g. 'model', 'batch'), but shortcuts like 'q' no longer work.
To leave the IPython shell and switch back to the ELEKTRONN2 shell, run
'exit()' or hit 'Ctrl-D'."""
print(_banner)
data = local_vars['data']
batch = local_vars['batch']
trainer = local_vars['self']
model = trainer.model
exp_config = local_vars['exp_config']
local_vars.update(locals()) # put the above into scope of console
console = code.InteractiveConsole(locals=local_vars)
while True:
try:
try:
inp = prompt_toolkit.prompt(
u"%s@neuromancer: " % user_name,
# needs to be an explicit ustring for py2-compat
history=ptk_hist,
completer=NumaCompleter(lambda: local_vars,
lambda: {},
words=shortcut_completions,
words_metastring='(shortcut)'),
auto_suggest=AutoSuggestFromHistory())
# Catch all exceptions in order to prevent catastrophes in case ptk suddenly breaks
except Exception:
inp = console.raw_input("%s@neuromancer: " % user_name)
logger.debug('(Shell received command "{}")'.format(inp))
if inp == 'q':
break
elif inp == 'kill':
break
elif inp == 'help':
print(_banner)
elif inp == 'ip':
try:
import IPython
IPython.embed(header=_ipython_banner)
except ImportError:
print('IPython is not available. You will need to install '
'it to use this function.')
elif inp.startswith('sethist'):
i = int(inp.split()[1])
exp_config.history_freq = i
elif inp.startswith('setlr'):
i = float(inp.split()[1])
model.lr = i
elif inp.startswith('setmom'):
i = float(inp.split()[1])
model.mom = i
elif inp.startswith('setwd'):
i = float(inp.split()[1])
model.wd = i
elif inp.startswith('sf'):
try:
name = inp.split()[1]
w = model[name].w.get_value()
m = plotting.embedfilters(w)
with FileLock('plotting'):
plt.imsave('filters_%s.png' % name, m, cmap='gray')
except: # try to print filter of first Layer with w
for name, node in model.nodes.items():
if hasattr(node, 'w'):
m = plotting.embedfilters(node.w.get_value())
with FileLock('plotting'):
plt.imsave('filters.png', m, cmap='gray')
break
elif inp == 'preview':
try:
trainer.preview_slice(**exp_config.preview_kwargs)
except Exception:
traceback.print_exc()
print(
'\n\nPlease check if/how you have configured previews '
'in your config file.\n(Look for "preview_data_path" '
'and "preview_kwargs" variables.)')
elif inp == 'paramstats':
model.paramstats()
elif inp == 'gradstats':
model.gradstats(*batch)
elif inp == 'actstats':
model.actstats(*batch)
elif inp == 'debugbatch':
trainer.debug_getcnnbatch()
elif inp.startswith('load'):
file_path = inp.split()[1]
params = utils.pickleload(file_path)
model.set_param_values(params)
else:
console.push(inp)
plt.pause(0.00001)
except KeyboardInterrupt:
print(
'Enter "q" to leave the shell and continue training.\n'
'Enter "kill" to kill the training, saving current parameters.'
)
except IndexError as err:
if any([
inp.startswith(shortcut)
for shortcut in shortcut_completions
]): # ignore trailing spaces
print(
'IndexError. Probably you forgot to type a value after the shortcut "{}".'
.format(inp))
else:
raise err # All other IndexErrors are already correctly handled by the console.
except ValueError as err:
if any([
inp.startswith(shortcut)
for shortcut in shortcut_completions
]): # ignore trailing spaces
print(
'ValueError. The "{}" shortcut received an unexpected argument.'
.format(inp))
else:
raise err # All other IndexErrors are already correctly handled by the console.
except Exception:
traceback.print_exc()
print(
'\n\nUnhandled exception occured. See above traceback for debug info.\n'
'If you think this is a bug, please consider reporting it at '
'https://github.com/ELEKTRONN/ELEKTRONN2/issues.')
return inp
def model(data):
return sparse_ssn_iter(data, i, n_iter)
# throw every image into the net
for data in dataloader:
image, label, name = data
height, width = image.shape[-2:]
label_pred = inference(image, args.nspix, args.niter, model,
args.fdim, args.color_scale, args.pos_scale)
label = label.argmax(1).reshape(height, width).numpy()
np.savetxt(os.path.join(args.dest, str(i), name[0] + '.csv'),
label_pred,
fmt='%d',
delimiter=',')
asa = achievable_segmentation_accuracy(label_pred, label)
usa = undersegmentation_error(label_pred, label)
cptness = compactness(label_pred)
BR = boundary_recall(label_pred, label)
image = np.squeeze(image.numpy(), axis=0).transpose(1, 2, 0)
image = lab2rgb(image)
print(
name[0],
'\tprocessed,asa_{:.4f}_usa{:.4f}_co{:.4f}_BR_{:.4f}'.format(
asa, usa, cptness, BR))
plt.imsave(
os.path.join(
args.dest, str(i),
"asa_{:.4f}_usa_{:.4f}_co_{:.4f}_BR_{:.4f}_{}.jpg".format(
asa, usa, cptness, BR, name[0])),
mark_boundaries(image, label_pred))
# Pour l'instant, la superposition donnerait du blanc.
# On mets à 0 les 100 premières lignes de chacune des matrices
R[:100, :] = 223
V[:100, :] = 109
B[:100, :] = 20
R[80:100, 80:100] = 0
V[80:100, 80:100] = 127
B[80:100, 80:100] = 0
#
# On empile les trois matrices
carres = np.stack((R, V, B), axis=2)
# visualisation avec imshow
#plt.imshow(carres)
carres2 = carres[::-1, :]
carres3 = np.concatenate((carres, carres2))
carres4 = carres3[:, ::-1]
carres5 = np.concatenate((carres3, carres4), axis=1)
carres6 = np.concatenate((carres5, carres5))
carres7 = np.concatenate((carres6, carres6, carres6), axis=1)
plt.imshow(carres7)
plt.show() # inutile en interactif
#
# Sauvegarde avec imsave
plt.imsave('carres.png', carres7)
def registration(self, grid_points_x=3, grid_points_y=3):
"""
By default, generate 9 galvo voltage coordinates from (-5,-5) to (5,5),
take the camera images of these points, return a function matrix that
transforms camera_coordinates into galvo_coordinates using polynomial transform.
Parameters
----------
grid_points_x : TYPE, optional
DESCRIPTION. The default is 3.
grid_points_y : TYPE, optional
DESCRIPTION. The default is 3.
Returns
-------
transformation : TYPE
DESCRIPTION.
"""
galvothread = DAQmission()
readinchan = []
x_coords = np.linspace(-10, 10, grid_points_x + 2)[1:-1]
y_coords = np.linspace(-10, 10, grid_points_y + 2)[1:-1]
xy_mesh = np.reshape(np.meshgrid(x_coords, y_coords), (2, -1),
order='F').transpose()
galvo_coordinates = xy_mesh
camera_coordinates = np.zeros((galvo_coordinates.shape))
for i in range(galvo_coordinates.shape[0]):
galvothread.sendSingleAnalog('galvosx', galvo_coordinates[i, 0])
galvothread.sendSingleAnalog('galvosy', galvo_coordinates[i, 1])
time.sleep(1)
image = self.cam.SnapImage(0.06)
plt.imsave(
os.getcwd() +
'/CoordinatesManager/Registration_Images/2P/image_' + str(i) +
'.png', image)
camera_coordinates[i, :] = readRegistrationImages.gaussian_fitting(
image)
print('Galvo Coordinate')
print(galvo_coordinates)
print('Camera coordinates')
print(camera_coordinates)
del galvothread
self.cam.Exit()
transformation_cam2galvo = CoordinateTransformations.polynomial2DFit(
camera_coordinates, galvo_coordinates, order=1)
transformation_galvo2cam = CoordinateTransformations.polynomial2DFit(
galvo_coordinates, camera_coordinates, order=1)
print('Transformation found for x:')
print(transformation_cam2galvo[:, :, 0])
print('Transformation found for y:')
print(transformation_cam2galvo[:, :, 1])
print('galvo2cam found for x:')
print(transformation_galvo2cam[:, :, 0])
print('galvo2cam found for y:')
print(transformation_galvo2cam[:, :, 1])
return transformation_cam2galvo
def train():
with tf.Session() as sess:
with tf.name_scope('inputs'):
x_data = tf.placeholder(tf.float32, [None, img_size], name="x_data")
z_prior = tf.placeholder(tf.float32, [None, z_size], name="z_prior")
noise = tf.placeholder(tf.float32, shape=[None, noise_size])
keep_prob = tf.placeholder(tf.float32, name="keep_prob")
x_generated = build_generator(z_prior, noise)
y_data = build_discriminator(x_data, noise, keep_prob)
y_generated = build_discriminator(x_generated, noise, keep_prob)
with tf.name_scope('loss'):
g_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(
logits=y_generated, labels=tf.ones_like(y_generated)))
d_fake_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(
logits=y_generated, labels=tf.zeros_like(y_generated)))
d_real_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(
logits=y_data, labels=tf.ones_like(y_data)))
d_loss = tf.add(d_fake_loss, d_real_loss)
tf.summary.scalar('g_loss', g_loss)
tf.summary.scalar('d_fake_loss', d_fake_loss)
tf.summary.scalar('d_real_loss', d_real_loss)
tf.summary.scalar('d_loss', d_loss)
with tf.name_scope('optimizer'):
optimizer = tf.train.AdamOptimizer(0.001)
d_trainer = optimizer.minimize(d_loss, var_list=d_params)
g_trainer = optimizer.minimize(g_loss, var_list=g_params)
saver = tf.train.Saver()
# merge summary
merged = tf.summary.merge_all()
# choose dir
writer = tf.summary.FileWriter('F:/tf_board/basic_gan_mnist', sess.graph)
sess.run(tf.global_variables_initializer())
for e in range(max_epoch):
for batch_i in range(mnist.train.num_examples//batch_size):
batch_data, y_data = mnist.train.next_batch(batch_size)
# noise
y_noise = np.random.uniform(-1.0, 1.0, size=(batch_size, noise_size))
# generator noise
batch_noise = np.random.uniform(-1.0, 1.0, size=(batch_size, z_size))
# Run optimizers
sess.run(d_trainer, feed_dict={x_data: batch_data, z_prior: batch_noise, noise: y_noise, keep_prob: 0.7})
sess.run(g_trainer, feed_dict={z_prior: batch_noise, noise: y_noise, keep_prob: 0.7})
if ((mnist.train.num_examples//batch_size) * e + batch_i) % (mnist.train.num_examples//batch_size) == 0:
train_loss_d = sess.run(d_loss, feed_dict={x_data: batch_data, z_prior: batch_noise, noise: y_noise,
keep_prob: 1.0})
fake_loss_d = sess.run(d_fake_loss, feed_dict={z_prior: batch_noise, noise: y_noise, keep_prob: 1.0})
real_loss_d = sess.run(d_real_loss, feed_dict={x_data: batch_data, noise: y_noise, keep_prob: 1.0})
# generator loss
train_loss_g = sess.run(g_loss, feed_dict={z_prior: batch_noise, noise: y_noise, keep_prob: 1.0})
merge_result = sess.run(merged, feed_dict={x_data: batch_data, z_prior: batch_noise, noise: y_noise,
keep_prob: 1.0})
writer.add_summary(merge_result, (mnist.train.num_examples//batch_size) * e + batch_i)
print("Epoch {}/{}...".format(e+1, max_epoch),
"Discriminator Loss: {:.4f}(Real: {:.4f} + Fake: {:.4f})...".format(
train_loss_d, real_loss_d, fake_loss_d), "Generator Loss: {:.4f}".format(train_loss_g))
if e % 10 == 0:
n_sample = 16
sample_noise = np.random.uniform(-1.0, 1.0, size=(n_sample, z_size))
y_sample = np.random.uniform(-1.0, 1.0, size=(n_sample, noise_size))
check_imgs = sess.run(x_generated, feed_dict={z_prior: sample_noise, noise: y_sample}
).reshape((n_sample, 28, 28))[:2]
plt.imsave('F:/tf_board/basic_gan_mnist/' + str(e) + '-' + str(0) + '.png', check_imgs[0],
cmap='Greys_r')
plt.imsave('F:/tf_board/basic_gan_mnist/' + str(e) + '-' + str(1) + '.png', check_imgs[1],
cmap='Greys_r')
print('train done')
n_sample = 16
sample_noise = np.random.uniform(-1.0, 1.0, size=(n_sample, z_size))
y_sample = np.random.uniform(-1.0, 1.0, size=(n_sample, noise_size))
check_imgs = sess.run(x_generated, feed_dict={z_prior: sample_noise, noise: y_sample}
).reshape((n_sample, 28, 28))[:5]
for i in range(5):
plt.imsave('F:/tf_board/basic_gan_mnist/' + 'final-' + str(i) + '.png', check_imgs[i], cmap='Greys_r')
# save sess
saver.save(sess, '/root/basic_gan_mnist.ckpt')
def main():
training_timestamp = str(datetime.now()).replace(":", "-").replace(
" ", "_").replace(".", "-")[:19]
os.mkdir(os.path.join(OUTPUT_DIR, training_timestamp))
file1 = open(os.path.join(OUTPUT_DIR, training_timestamp, "log.txt"), "w+")
print(1)
_, input_right, input_left = loadAllPaths(datasetp=os.path.join(
TEMPDIR, "./FlyingThings3d/input_webp/frames_cleanpass_webp/TRAIN"),
subfolder=['A', 'B', 'C'],
lr=True)
_, output_right, output_left = loadAllPaths(datasetp=os.path.join(
TEMPDIR, "./FlyingThings3d/disparity/disparity/TRAIN"),
subfolder=['A', 'B', 'C'],
lr=True)
TOTAL_IMAGES = input_right.shape[0]
printing_left = input_left[TOTAL_IMAGES - 1]
printing_right = input_right[TOTAL_IMAGES - 1]
printing_output = output_left[TOTAL_IMAGES - 1]
TOTAL_IMAGES = TOTAL_IMAGES - 1
input_one_image = Image.open(printing_left).convert('RGB')
in_arr = np.array(input_one_image)
in_arr = in_arr[crop_up:crop_down, crop_left:crop_right, :]
printing_left = _norm(
np.reshape(in_arr, (1, IMAGE_SIZE_Y, IMAGE_SIZE_X, 3)))
printing_lefts = printing_left
for i in range(1, 10):
printing_lefts = np.concatenate((printing_lefts, printing_left),
axis=0)
input_one_image = Image.open(printing_right).convert('RGB')
in_arr = np.array(input_one_image)
in_arr = in_arr[crop_up:crop_down, crop_left:crop_right, :]
printing_right = _norm(
np.reshape(in_arr, (1, IMAGE_SIZE_Y, IMAGE_SIZE_X, 3)))
printing_rights = printing_right
for i in range(1, 10):
printing_rights = np.concatenate((printing_rights, printing_right),
axis=0)
input_one_image = load_pfm(printing_output)[0]
in_arr = np.array(input_one_image)
in_arr = in_arr[crop_up:crop_down, crop_left:crop_right]
input_one_image = np.reshape(in_arr, (IMAGE_SIZE_Y, IMAGE_SIZE_X, 1))
printing_output = np.reshape(input_one_image,
(1, IMAGE_SIZE_Y, IMAGE_SIZE_X, 1))
printing_outputs = printing_output
for i in range(1, 10):
printing_outputs = np.concatenate((printing_outputs, printing_output),
axis=0)
validation_left = input_left[TOTAL_IMAGES - VALIDATION_SIZE:]
validation_right = input_right[TOTAL_IMAGES - VALIDATION_SIZE:]
validation_output = output_left[TOTAL_IMAGES - VALIDATION_SIZE:]
TOTAL_IMAGES = TOTAL_IMAGES - VALIDATION_SIZE
BATCH_NUM = TOTAL_IMAGES // BATCH_SIZE
BATCH_NUM = 20
VALIDATION_BATCHES = 2
print("TOTAL IMAGES : {}, BATCH_NUM: {} ".format(TOTAL_IMAGES, BATCH_NUM))
file1.write("TOTAL IMAGES : {}, BATCH_NUM: {} \n".format(
TOTAL_IMAGES, BATCH_NUM))
# with open(GT_DIR) as f:
# buf = cPickle.load(f, encoding="utf-8")
#buf = load_pfm_files()
image_left = tf.placeholder(tf.float32,
[None, IMAGE_SIZE_Y, IMAGE_SIZE_X, 3],
name='image_left')
image_right = tf.placeholder(tf.float32,
[None, IMAGE_SIZE_Y, IMAGE_SIZE_X, 3],
name='image_right')
ground_truth = tf.placeholder(tf.float32,
[None, IMAGE_SIZE_Y, IMAGE_SIZE_X, 1],
name='ground_truth')
#image_left = tf.placeholder(tf.float32, [None, crop_down-crop_up, crop_right-crop_left, 3], name='image_left')
#image_right = tf.placeholder(tf.float32, [None, crop_down-crop_up, crop_right-crop_left, 3], name='image_right')
#ground_truth = tf.placeholder(tf.float32, [None, crop_down-crop_up, crop_right-crop_left, 1], name='ground_truth')
is_training = tf.placeholder(tf.bool, name="is_training")
#Maksim je pica!
combine_image = tf.concat([image_left, image_right], 3)
final_output, total_loss, loss1, loss2, loss3, loss4, loss5, loss6, pr6, pr5, pr4, pr3, pr2, pr1, loss6_inf = model(
combine_image=combine_image, ground_truth=ground_truth)
tf.summary.scalar('loss', total_loss)
with tf.name_scope('train'):
optimizer = tf.train.AdamOptimizer(
learning_rate=LEARNING_RATE).minimize(total_loss)
merged = tf.summary.merge_all()
# important step
sess = tf.Session()
if int((tf.__version__).split('.')[1]) < 12 and int(
(tf.__version__).split('.')[0]) < 1: # tensorflow version < 0.12
writer = tf.train.SummaryWriter(LOGS_DIR, sess.graph)
else: # tensorflow version >= 0.12
writer = tf.summary.FileWriter(LOGS_DIR, sess.graph)
#left_images = sorted(os.listdir(DATA_DIR+ '//left//'))
#right_images = sorted(os.listdir(DATA_DIR + '//right//'))
left_images = input_left
right_images = input_right
# output_images = sorted(os.listdir(DATA_DIR + '/output/'))
# tf.initialize_all_variables() no long valid from
# 2017-03-02 if using tensorflow >= 0.12
if int((tf.__version__).split('.')[1]) < 12:
init = tf.initialize_all_variables()
else:
init = tf.global_variables_initializer()
# saver = tf.train.Saver(write_version = saver_pb2.SaverDef.V2)
saver = tf.train.Saver()
sess.run(init)
# saver.restore(sess, MODEL_PATH)
with open(
RUNNING_LOGS_DIR + "/log" + date.isoformat(date.today()) +
str(time.time()) + ".txt", "w+") as file:
# file.write('BATCH_SIZE ' + str(BATCH_SIZE) + '\n'
#+ ' EPOCH ' + str(EPOCH) + '\n'
# + ' image_num ' + str(image_num) + '\n'
#+ ' LEARNING_RATE ' + str(LEARNING_RATE) + '\n')
for round in range(EPOCH):
#for i in range(0 , image_num - BATCH_SIZE, ROUND_STEP):
for i in range(BATCH_NUM):
trackTime(time.time())
for j in range(BATCH_SIZE):
if (i == BATCH_NUM - 1
and i * BATCH_SIZE + j >= TOTAL_IMAGES):
break
# input data
#full_pic_name = DATA_DIR+ '/left/' + left_images[TRAIN_SERIES[i + j]]
full_pic_name = left_images[i * BATCH_SIZE + j]
input_one_image = Image.open(full_pic_name).convert('RGB')
in_arr = np.array(input_one_image)
in_arr = in_arr[crop_up:crop_down, crop_left:crop_right, :]
input_one_image = _norm(
np.reshape(in_arr, (1, IMAGE_SIZE_Y, IMAGE_SIZE_X, 3)))
if (j == 0):
input_left_images = input_one_image
else:
input_left_images = np.concatenate(
(input_left_images, input_one_image), axis=0)
#full_pic_name = DATA_DIR + '/right/' + right_images[TRAIN_SERIES[i + j]]
full_pic_name = right_images[i * BATCH_SIZE + j]
input_one_image = Image.open(full_pic_name).convert('RGB')
in_arr = np.array(input_one_image)
in_arr = in_arr[crop_up:crop_down, crop_left:crop_right, :]
input_one_image = _norm(
np.reshape(in_arr, (1, IMAGE_SIZE_Y, IMAGE_SIZE_X, 3)))
if (j == 0):
input_right_images = input_one_image
else:
input_right_images = np.concatenate(
(input_right_images, input_one_image), axis=0)
#input_one_image = buf[TRAIN_SERIES[i + j]]
input_one_image = load_pfm(output_left[i * BATCH_SIZE +
j])[0]
in_arr = np.array(input_one_image)
in_arr = in_arr[crop_up:crop_down, crop_left:crop_right]
input_one_image = np.reshape(
in_arr, (IMAGE_SIZE_Y, IMAGE_SIZE_X, 1))
input_one_image = np.reshape(
input_one_image, (1, IMAGE_SIZE_Y, IMAGE_SIZE_X, 1))
if (j == 0):
input_gts = input_one_image
else:
input_gts = np.concatenate(
(input_gts, input_one_image), axis=0)
result, optimizer_res, total_loss_res, loss1_res, loss2_res, loss3_res, loss4_res, loss5_res, loss6_res, pr6_res, pr5_res, pr4_res, pr3_res, pr2_res, pr1_res, loss6_inf_res = sess.run(
[
merged, optimizer, total_loss, loss1, loss2, loss3,
loss4, loss5, loss6, pr6, pr5, pr4, pr3, pr2, pr1,
loss6_inf
],
feed_dict={
image_left: input_left_images,
image_right: input_right_images,
ground_truth: input_gts
})
#result, optimizer_res, total_loss_res =sess.run([merged, optimizer, total_loss],feed_dict={image_left:input_left_images, image_right:input_right_images, ground_truth:input_gts})
print("training: epoch: {}, batch num: {}, total loss: {}".
format(round, i, total_loss_res))
print("training: losses: total={}, {},{},{},{},{},{}".format(
total_loss_res, loss1_res, loss2_res, loss3_res, loss4_res,
loss5_res, loss6_res))
file1.write(
"training: epoch: {}, batch num: {}, total loss: {} \n".
format(round, i, total_loss_res))
file1.write(
"training: losses: total={}, {},{},{},{},{},{} \n".format(
total_loss_res, loss1_res, loss2_res, loss3_res,
loss4_res, loss5_res, loss6_res))
#print("losses:" + str(total_loss_res) + " " + str(loss1_res) + " " + str(loss2_res) + " " + str(loss3_res) + " " + str(loss4_res) + " " + str(loss5_res) + " " + str(loss6_res))
#print("round: "str(round) + " total loss: " + str(total_loss_res))
#print("losses:" + str(total_loss_res) + " " + str(loss1_res) + " " + str(loss2_res) + " " + str(loss3_res) + " " + str(loss4_res) + " " + str(loss5_res) + " " + str(loss6_res))
if round % SAVE_PER_EPOCH == SAVE_PER_EPOCH - 1 and i % SAVE_PER_BATCH == SAVE_PER_BATCH - 1:
#print("ajde bre sacuvaj")
#result, total_loss_res, loss1_res, loss2_res, loss3_res, loss4_res, loss5_res, loss6_res, pr6_res, pr5_res, pr4_res, pr3_res, pr2_res, pr1_res, loss6_inf_res =sess.run([merged, total_loss, loss1, loss2, loss3, loss4, loss5, loss6, pr6, pr5, pr4, pr3, pr2, pr1, loss6_inf],feed_dict={image_left:printing_left, image_right:printing_right, ground_truth:printing_output})
result, total_loss_res, loss1_res, loss2_res, loss3_res, loss4_res, loss5_res, loss6_res, pr6_res, pr5_res, pr4_res, pr3_res, pr2_res, pr1_res, loss6_inf_res = sess.run(
[
merged, total_loss, loss1, loss2, loss3, loss4,
loss5, loss6, pr6, pr5, pr4, pr3, pr2, pr1,
loss6_inf
],
feed_dict={
image_left: printing_lefts,
image_right: printing_rights,
ground_truth: printing_outputs
})
#slika = slika
#slika = np.min(1,slika)
plt.imsave(os.path.join(
OUTPUT_DIR, training_timestamp,
"epoch{}_batch{}.png".format(round, i)),
pr1_res[0, :, :, 0],
cmap="gray")
##plt.imshow(slika[:,:,0], cmap="gray")
##plt.show()
saver = tf.train.Saver()
saver.save(
sess,
os.path.join(OUTPUT_DIR, training_timestamp,
"model_epoch{}.ckpt".format(round)))
for i in range(VALIDATION_BATCHES):
trackTime(time.time())
for j in range(BATCH_SIZE):
if (i == BATCH_NUM - 1
and i * BATCH_SIZE + j >= VALIDATION_SIZE):
break
# input data
#full_pic_name = DATA_DIR+ '/left/' + left_images[TRAIN_SERIES[i + j]]
full_pic_name = validation_left[i * BATCH_SIZE + j]
input_one_image = Image.open(full_pic_name).convert('RGB')
in_arr = np.array(input_one_image)
in_arr = in_arr[crop_up:crop_down, crop_left:crop_right, :]
input_one_image = _norm(
np.reshape(in_arr, (1, IMAGE_SIZE_Y, IMAGE_SIZE_X, 3)))
if (j == 0):
input_left_images = input_one_image
else:
input_left_images = np.concatenate(
(input_left_images, input_one_image), axis=0)
#full_pic_name = DATA_DIR + '/right/' + right_images[TRAIN_SERIES[i + j]]
full_pic_name = validation_right[i * BATCH_SIZE + j]
input_one_image = Image.open(full_pic_name).convert('RGB')
in_arr = np.array(input_one_image)
in_arr = in_arr[crop_up:crop_down, crop_left:crop_right, :]
input_one_image = _norm(
np.reshape(in_arr, (1, IMAGE_SIZE_Y, IMAGE_SIZE_X, 3)))
if (j == 0):
input_right_images = input_one_image
else:
input_right_images = np.concatenate(
(input_right_images, input_one_image), axis=0)
#input_one_image = buf[TRAIN_SERIES[i + j]]
input_one_image = load_pfm(
validation_output[i * BATCH_SIZE + j])[0]
in_arr = np.array(input_one_image)
in_arr = in_arr[crop_up:crop_down, crop_left:crop_right]
input_one_image = np.reshape(
in_arr, (IMAGE_SIZE_Y, IMAGE_SIZE_X, 1))
input_one_image = np.reshape(
input_one_image, (1, IMAGE_SIZE_Y, IMAGE_SIZE_X, 1))
if (j == 0):
input_gts = input_one_image
else:
input_gts = np.concatenate(
(input_gts, input_one_image), axis=0)
result, total_loss_res, loss1_res, loss2_res, loss3_res, loss4_res, loss5_res, loss6_res, pr6_res, pr5_res, pr4_res, pr3_res, pr2_res, pr1_res, loss6_inf_res = sess.run(
[
merged, total_loss, loss1, loss2, loss3, loss4, loss5,
loss6, pr6, pr5, pr4, pr3, pr2, pr1, loss6_inf
],
feed_dict={
image_left: input_left_images,
image_right: input_right_images,
ground_truth: input_gts
})
#result, optimizer_res, total_loss_res =sess.run([merged, optimizer, total_loss],feed_dict={image_left:input_left_images, image_right:input_right_images, ground_truth:input_gts})
print("validation: epoch: {}, batch num: {}, total loss: {}".
format(round, i, total_loss_res))
print("validation: losses: total={}, {},{},{},{},{},{}".format(
total_loss_res, loss1_res, loss2_res, loss3_res, loss4_res,
loss5_res, loss6_res))
file1.write(
"validation: epoch: {}, batch num: {}, total loss: {} \n".
format(round, i, total_loss_res))
file1.write(
"validation: losses: total={}, {},{},{},{},{},{} \n".
format(total_loss_res, loss1_res, loss2_res, loss3_res,
loss4_res, loss5_res, loss6_res))
return aia_sub
if __name__ == '__main__':
# get the flare data
data = pd.read_csv('hessi_goes_flare_data.csv')
data['Peak_time'] = pd.to_datetime(data['Peak_time'],
format='%Y-%m-%d %H:%M:%S')
data = data[data['Peak_time'] >= dt.datetime.strptime(
'2010-06-06 02:52:58',
'%Y-%m-%d %H:%M:%S')] # SDO started after HESSI and GOES!!!!
print(data.head())
print('number of valid flares = {}'.format(len(data.index)))
# save the images to their respective directories
for idx, row in data.head().iterrows():
print('getting image {}/{}'.format(idx, len(data.index)))
img = get_image(row['Peak_time'], row['X_pos'], row['Y_pos'])
img.plot()
img_name = str(row['Peak_time']).replace(' ', '_').replace(
':', '_').replace('-', '_') + '.png'
if row['Class'] == 'B':
img_name = os.path.join('B_class', img_name)
elif row['Class'] == 'C':
img_name = os.path.join('C_class', img_name)
plt.imsave(fname=os.path.join('data', img_name),
arr=img.data,
cmap=plt.cm.gray)
print('image saved\n')
print('Done')
count = 0
img = imgs[ix]
tile_output = np.zeros((img.shape[0], img.shape[1], 4))
zeros = np.zeros((img.shape[0], img.shape[1], 4))
for i in xrange(0, img.shape[0], inner_size):
for j in xrange(0, img.shape[1], inner_size):
zeros[i:i + inner_size, j:j + inner_size] = y[count]
count += 1
for i in range(img.shape[0]):
for j in range(img.shape[1]):
output = tile_output[i, j]
zeros[i, j, np.argmax(output)] = 1
#count += 1
#import pdb; pdb.set_trace()
zeros[:, :, 3] = 1
#color = output_to_colors(zeros, img)
#colors = [output_to_colors(y, imgs[i]) for i,y in enumerate(ys)]
#colors = [label2rgb(y.argmax(axis=-1), image=imgs[i], colors=[(1,0,0), (0,1,0), (0,0,1), (0,0,0)], alpha=0.9, bg_label=3) for i,y in enumerate(ys)]
#[plt.imsave('plots/%s_%s'%(model_n, file_names[i]), zeros) for i,zeros in enumerate(colors)]
#print(file_names)
plt.imsave('plots/results/%s.png' % (file_names[ix]), zeros)
print "total processing done in: " + str(
(datetime.now() - tick).total_seconds())
def btn_save_Pressed(self):
fileName, _ = QtWidgets.QFileDialog.getSaveFileName(None, 'Guardar Espectro',"","Bitmaps (*.bmp)")
plt.imsave(fileName, self.out, cmap="gray")
def save_img(self, grid, filename):
if not os.path.exists('./gif'):
os.mkdir('./gif')
plt.figure(figsize=(15,15))
plt.imsave('./gif/' + filename, np.transpose(grid, (1,2,0)).numpy())