def get_image_from_array(img_array, denormalize=True, dtype='float32' ,is_cv2_image = False):
"""Converts numpy image array to a PIL Image instance.
Parameters
----------
img: Input Numpy image array.
denormalize: Revert back normalized image to unnormalized form
Default: True.
dtype: Dtype to use.
Default: "float32".
is_cv2_image: Set to True if image is loaded using cv2
Default: False
Returns
-------
A PIL Image.
Raises
------
Raises TypeError if image_array is not an numpy ndarray
"""
if not hasattr(img_array, 'ndim'):
raise TypeError(f'Required image_array to be of type numpy.ndarray but got {type(img_array)} instead')
if img_array.ndim != 3:
if img_array.ndim == 2:
"""expand image dimensions only if image is 2D grayscale
manually adding channel dimension `1` to image (only for 2D grayscale image)"""
img_array = expand_dims(img_array,axis=2)
else:
raise ValueError(f'Expected array with 3 dimensions Got array with shape {img_array.shape}\n'
'Incase you have used expand_dims for preprocessing, use nv.reduce_dims() for reducing expanded dimensions\n'
'make sure to check the axis position while expanding or reducing dimensions.')
if is_cv2_image: #If numpy array is cv2 image
img_array = img_array[...,::-1] #Convert BGR to RGB
img_array = toarray(img_array,dtype=dtype)
# Original Numpy array x has format (height, width, channel)
# or (channel, height, width)
# but target PIL image has format (width, height, channel)
if denormalize:
img_array = img_array - npmin(img_array)
img_max = npmax(img_array)
if img_max != 0:
img_array /= img_max
img_array *= 255
if img_array.shape[2] == 4: #RGBA Image
return pilimage.fromarray(img_array.astype('uint8'), 'RGBA')
elif img_array.shape[2] == 3: #RGB image
return pilimage.fromarray(img_array.astype('uint8'), 'RGB')
elif img_array.shape[2] == 1: # grayscale image
if npmax(img_array) > 255:
# 32-bit signed integer grayscale image. PIL mode "I"
return pilimage.fromarray(img_array[:, :, 0].astype('int32'), 'I')
return pilimage.fromarray(img_array[:, :, 0].astype('uint8'), 'L')
else:
raise ValueError(f'Channel {img_array.shape[2]} not supported')
def fit(self, X, y):
assert type(y) in [np.ndarray, list], 'expecting array or numpy array'
assert type(X) in [np.ndarray, list,
bsr_matrix], 'expecting array or numpy array'
if type(X) == bsr_matrix:
y = np.asarray(y)
X = X.toarray()
elif type(X) == list:
y = np.asarray(y)
X = np.toarray(X)
self.labels = np.unique(y)
self.numclasses = self.labels.shape[0]
self.numattributes = X.shape[1]
self.priors = np.zeros(self.numclasses, dtype=float)
self.numsamples = y.shape[0]
self.likelihood = np.zeros((self.numclasses, X.shape[1]), dtype=float)
updcount = float(self.smoothing * self.numattributes)
self.priors = np.log(
np.asarray([
np.where(y == cl)[0].shape[0] / float(self.numsamples)
for cl in self.labels
]))
# compute tfidf weights instead of the count
if self.tfidf:
alldoc = X.shape[0]
# freqperdoc = np.sum(np.where(X > 0, 1, 0), axis=0)
idf = np.log((alldoc + 1.0) /
(np.sum(np.where(X > 0, 1, 0), axis=0) + 1.0)) + 1.0
X = X.astype(float) / X.sum(axis=1)[:, None]
X = X * idf
def attlikelihood(X):
attsum = np.sum(X)
return np.log((X + self.smoothing) / (updcount + attsum))
labelwordsum = np.squeeze(np.asarray(
[np.sum(X[np.where(y == cl), :], axis=1) for cl in self.labels]),
axis=1)
self.likelihood = np.apply_along_axis(attlikelihood, 1, labelwordsum)
return self.likelihood, self.priors
def all_locs_numpy_total(hash):
for hash in range(len(dbr)):
a = np.toarray(dbr[hash])
raise NotImplemented()
def all_locs_numpy(hash):
a = np.toarray(dbr[hash])
return a
def show(img, res=1080, kernel=NEAREST_NEIGHBOR):
todisplay = img
if img.shape[0] != res:
todisplay = upscale(np.toarray(img), (res, res), kernel)
todisplay.show()
def imread(image_path,resize=None,color_mode = None,interpolation='nearest',dtype='float32',return_original = False,normalize=False):
"""Converts a PIL Image instance to a Ndarray optimised for model.
Parameters
----------
image_path: Image Path or bytes.
resize: (width,height) tuple
color_mode: default is None
you can also use color_mode as `rgb` or `rgba` or `grayscale`
interpolation:
Interpolation method used to resample the image if the
target size is different from that of the loaded image.
Supported methods are "nearest", "bilinear", and "bicubic".
If PIL version 1.1.3 or newer is installed, "lanczos" is also
supported. If PIL version 3.4.0 or newer is installed, "box" and
"hamming" are also supported.
Default: "nearest".
dtype: Dtype to use for the returned array.
Default: float32
return_original: Returns original image array along with resized image array.
Default: False
Note: This parameter only works with resize parameter
normalize: Returns normalized image if set to True
Default: False
# Returns
A 3D Numpy array.
# Raises
ValueError: if invalid `image_path` or `resize` or `color_mode` or `interpolation` or `dtype` is passed.
ValueError: if return_original is True and resize is None
"""
image = pilimage.open(image_path)
if color_mode is not None:
if color_mode == 'grayscale':
if image.mode not in ('L', 'I;16', 'I'):
image = image.convert('L')
elif color_mode == 'rgba':
if image.mode != 'RGBA':
image = image.convert('RGBA')
elif color_mode == 'rgb':
if image.mode != 'RGB':
image = image.convert('RGB')
else:
raise ValueError('color_mode must be "grayscale", "rgb", or "rgba"')
if resize is not None:
if not isinstance(resize,tuple):
raise TypeError(f'resize must be tuple of (width,height) but got {resize} of type {type(resize)} instead')
if len(resize) != 2:
raise ValueError(f'Tuple with (width,height) required but got {resize} instead.')
original_image_array = toarray(image,dtype=dtype)
if image.size != resize:
if interpolation not in interpolation_methods:
raise ValueError(f'Invalid interpolation, currently supported interpolations:{interpolation_methods.keys()}')
resample = interpolation_methods.get(interpolation)
image = image.resize(resize, resample)
image_array = toarray(image,dtype=dtype)
if normalize:
image_array /= 255.
if return_original:
if resize is None:
raise ValueError("return_original parameter only works with resize parameter")
return original_image_array , image_array
return image_array
text = [sent_tokenize(d) for d in data_list]
text = [[clean_str(s).split(" ") for s in j] for j in text]
x, vocabulary, vocabulary_inv = build_input(text)
word2vec = vocab_to_word2vec('/Users/johnbeieler/GoogleNews-vectors-negative300.bin', vocabulary)
embedding_mat = build_word_embedding_mat(word2vec, vocabulary_inv)
sentences = LabeledLineSentence(text, names)
model = Doc2Vec.load_word2vec_format('/Users/johnbeieler/GoogleNews-vectors-negative300.bin',
binary=True)
#model = Doc2Vec(min_count=1, window=10, size=100, sample=1e-4, negative=5,
# workers=8)
model.build_vocab(sentences.to_array())
for epoch in range(10):
model.train(sentences.sentences_perm())
model.save('HR_docs.d2v')
data = np.zeros((len(data_list), NUM_SENTS, 100))
for ix, x in enumerate(mapping):
for w in xrange(NUM_SENTS):
if x:
try:
data[ix, w, :] = model.docvecs['{}_{}_{}'.format(x[1], x[0],
w)]
except KeyError:
pass
cPickle.dump([data, np.toarray(y)], open('HR_monarchy_data.p', 'wb'))