The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.

Example 1

def _get_colors(self, f):
        '''
        Misterious function, ask @inconvergent :)
        '''
        scale = 1./255.
        im = Image.open(f)
        w, h = im.size
        rgbim = im.convert('RGB')
        res = []
        for i in xrange(0, w):
            for j in xrange(0, h):
                r, g, b = rgbim.getpixel((i, j))
                res.append((r*scale, g*scale, b*scale))

        np.shuffle(res)
        self.colors = res
        self.n_colors = len(res) 

Example 2

def _get_colors(self, f):
        '''
        Misterious function, ask @inconvergent :)
        '''
        scale = 1./255.
        im = Image.open(f)
        w, h = im.size
        rgbim = im.convert('RGB')
        res = []
        for i in xrange(0, w):
            for j in xrange(0, h):
                r, g, b = rgbim.getpixel((i, j))
                res.append((r*scale, g*scale, b*scale))

        np.shuffle(res)
        self.colors = res
        self.n_colors = len(res) 

Example 3

def __next__(self):
        if self._train_location >= len(self._train_indices)  or  self._test_location >= len(self._test_indices):
            # Reset:
            np.shuffle(self._train_indices)
            np.shuffle(self._test_indices)
            self._train_location = 0
            self._test_location  = 0
            raise StopIteration()
        return self.get_train_test_batch() 

Example 4

def sample(self, n=1):
        counts = np.random.multinomial(n, self.weights, size=1)
        samples = np.empty((n, len(self.means[0])))
        
        k = 0
        for i in range(len(self.means)):
            for j in range(len(self.means[i])):
                samples[k:k+counts[i], j] = stats.norm.rvs(loc=self.means[i, j], scale=self.stds[i, j], size=counts[i])
            k += counts[i]
        
        np.shuffle(samples)
        
        return samples 

Example 5

def sample(self, n=1):
        counts = np.random.multinomial(n, self.weights, size=1)
        samples = np.empty((n, len(self.means[0])))
        
        j = 0
        for i in range(len(self.means)):
            samples[j:j+counts[i]] = stats.multivariate_normal.rvs(mean=self.means[i], cov=self.covs[i], size=counts[i])
            j += counts[i]
        
        np.shuffle(samples)
        
        return samples 

Example 6

def _split_into_groups(iterable, ngroups=-1, fractions=None, shuffle=True):
	if shuffle:
		iterable = np.copy(iterable)
		np.shuffle(iterable)

	start_idxs, end_idxs = _group_start_end_idxs(len(iterable), ngroups,
		fractions)

	return [iterable[start:end] for start, end in zip(start_idxs, end_idxs)] 

Example 7

def __init__(self, hdf_filename, test_pct=0.25, neg_bias=0.5, batch_size=64,  normalize=False, malignancy_to_class=None, window_normalize=False):       
        neg_bias = 0.5 if neg_bias is None else neg_bias
        self._hdf_filename        = hdf_filename
        self._neg_bias            = neg_bias
        self._test_pct            = test_pct
        self._batch_size          = batch_size
        self._test_location       = 0
        self._train_location      = 0
        self._test_indices        = []
        self._train_indices       = []
        self._malignancy_to_class = malignancy_to_class
        self._normalize           = normalize
        self._Xmin                = None
        self._Xmax                = None
        self._window_normalize    = window_normalize
        if malignancy_to_class is not None and len(malignancy_to_class) != 6:
            raise Exception("malignancy_class mapping must contain exactly 6 values, one for each malignancy level 0 - 5")
        # Open the hdf file 
        self._hdf_file = h5py.File(self._hdf_filename, 'r')
        # Get info on classes and makeup of the dataset by examining the y values (classes):
        y          = self._hdf_file['nodule_classes'].value        
        if self._malignancy_to_class is not None:
            if malignancy_to_class is not None:
                mal = self._hdf_file['nodule_malignancy']          
                for i in range(len(y)):
                    y[i] = [malignancy_to_class[int(mal[i])]]
        if self._normalize:
            self._Xmin = self._hdf_file['nodule_pixel_min']
            self._Xmax = self._hdf_file['nodule_pixel_max']    
        n_examples = len(y)
        negatives  = [i for i in range(n_examples) if y[i] == [0]]
        positives  = [i for i in range(n_examples) if y[i][0] > 0]
        neg_count  = len(negatives)
        pos_count  = len(positives)
        n_examples = neg_count + pos_count
        neg_goal   = int(min(neg_count, round(neg_bias * n_examples)))
        pos_goal   = n_examples - neg_goal
        if pos_goal > pos_count:
            neg_goal = int(round(pos_count * (1-neg_bias+0.5)))
            pos_goal = pos_count
        # print("Before: neg count: {0}; goal: {1} - pos count: {2}; goal: {3}".format(neg_count, neg_goal, pos_count, pos_goal))
        # randomly choose neg_goal negatives and pos_goal positives:
        selected_indices = list(np.random.choice(negatives, size=(min(neg_count,neg_goal)), replace=False))
        selected_indices.extend(list(np.random.choice(positives, size=(min(pos_count, pos_goal)), replace=False)))
        # print("n examples: {0}".format(len(selected_indices)))
        n_examples = len(selected_indices)
        np.random.shuffle(selected_indices)
        test_examples = int(round(test_pct * n_examples))
        # print("test_examples: {0}".format(test_examples))
        self._test_indices  = selected_indices[0:test_examples]
        self._train_indices = selected_indices[test_examples:]