def readXML_pascal(path, name_to_label, c=0, is_pytorch=False): #Create a dictionnary from the XML file (given its path here) following naming patterns used by torchvision for detection root = ET.parse(path).getroot() info = {} shape = (int(root.find('imagesize/nrows').text), int(root.find('imagesize/ncols').text), 3) folder = root.find('folder').text name = root.find('filename').text info['boxes'] = [] info['labels'] = [] info['area'] = [] info['image_id'] = np.array([c]) info['parents'] = [] for type_tag in root.findall('object'): info['parents'].append(type_tag.find('parts/ispartof')) for pt in type_tag.findall('polygon'): xs = pt.findall('pt/x') ys = pt.findall('pt/y') xs = [int(x.text) for x in xs] ys = [int(y.text) for y in ys] local_box = [min(xs), min(ys), max(xs), max(ys)] if local_box[3] > shape[0] or local_box[2] > shape[1]: continue info['labels'].append(name_to_label[type_tag.find('name').text]) info['boxes'].append(local_box) info['area'].append( (local_box[2] - local_box[0]) * (local_box[3] - local_box[1])) info['boxes'] = np.array(info['boxes']) info['area'] = np.array(info['area']) info['labels'] = np.array(info['labels']) info['iscrowd'] = np.zeros_like(info['area']) info['parents'] = np.arrays(info['parents']) return name, folder, shape, info
def __init__(self, ns=[10, 10], Ls=[1., 1.]): self.dim = len(ns) self.n_cells = np.prod(ns) self.cell_dims = ns self.lens = Ls self.cell_ds = np.arrays(ns) / np.array(Ls) ## The create_grid function initializes all of the matrices needed for deposition self._create_grid() self.kind = 'Field'
def __init__(self): #supplies the test and train data in the format with ZipFile('model.zip', 'r') as zipObj: zipObj.extractall() training_data_folders = {} entries = os.listdir('model/') size = 224 for entry in entries: training_data_folders[(Path("model") / entry)] = entry images = [] labels = [] for folder in training_data_folders: for img in folder.glob("*.png"): img = Image.open(img) wpercent = (size / float(img.size[0])) hsize = int((float(img.size[1]) * float(wpercent))) img = img.resize((size, hsize), Image.ANTIALIAS) img.save(img) img = image.load_img(img) image_array = image.img_to_array(img) images.append(image_array) labels.append(training_data_folders[folder]) for img in folder.glob("*.jpg"): img = Image.open(img) wpercent = (size / float(img.size[0])) hsize = int((float(img.size[1]) * float(wpercent))) img = img.resize((size, hsize), Image.ANTIALIAS) img.save(img) img = image.load_img(img) image_array = image.img_to_array(img) images.append(image_array) labels.append(training_data_folders[folder]) for img in folder.glob("*.jpg"): img = Image.open(img) wpercent = (size / float(img.size[0])) hsize = int((float(img.size[1]) * float(wpercent))) img = img.resize((size, hsize), Image.ANTIALIAS) img.save(img) img = image.load_img(img) image_array = image.img_to_array(img) images.append(image_array) labels.append(training_data_folders[folder]) x_train = np.arrays(images) y_train = np.array(labels)
def load_pose(data_json_path, joints_num=17): """ load pose data from data json """ f = open(data_json_path) data = json.load(f) img_num = len(data) joints = np.arrays(img_num, joints_num, 2) for img in data: joints[img, :, :] = img['joints'] return joints
def sample(self, sample_size): """ Uniformly sample (s,a,r,s) experiences from the replay dataset. Args: sample_size: (self explanatory) Returns: A tuple of numpy arrays for the |sample_size| experiences. (state, action, reward, next_state) The zeroth dimension of each array corresponds to the experience index. The i_th experience is given by: (state[i], action[i], reward[i], next_state[i]) """ if sample_size >= self.valid: raise ValueError( "Can't draw sample of size %d from replay dataset of size %d" % (sample_size, self.valid)) idx = random.sample(xrange(0, self.valid), sample_size) # We can't include head - 1 in sample because we don't know the next # state, so simply resample (very rare if dataset is large) while (self.head - 1) in idx: idx = random.sample(xrange(0, self.valid), sample_size) idx.sort() # Slicing for hdf5 must be in increasing order next_idx = [x + 1 for x in idx] # next_state might wrap around end of dataset if next_idx[-1] == self.dset_size: next_idx[-1] = 0 shape = (sample_size,)+self.state[0].shape next_states = np.empty(shape, dtype=np.uint8) next_states[0:-1] = self.state[next_idx[0:-1]] next_states[-1] = self.state[0] else: next_states = self.state[next_idx] is_non_terminal = np.arrays([not self.is_terminal(idx) for idx in next_idx], dtype=bool) return (self.state[idx], self.action[next_idx], self.reward[next_idx], next_states, self.non_terminal[next_idx])
def sample(self, sample_size): """ Uniformly sample (s,a,r,s) experiences from the replay dataset. Args: sample_size: (self explanatory) Returns: A tuple of numpy arrays for the |sample_size| experiences. (state, action, reward, next_state) The zeroth dimension of each array corresponds to the experience index. The i_th experience is given by: (state[i], action[i], reward[i], next_state[i]) """ if sample_size >= self.valid: raise ValueError( "Can't draw sample of size %d from replay dataset of size %d" % (sample_size, self.valid)) idx = random.sample(xrange(0, self.valid), sample_size) # We can't include head - 1 in sample because we don't know the next # state, so simply resample (very rare if dataset is large) while (self.head - 1) in idx: idx = random.sample(xrange(0, self.valid), sample_size) idx.sort() # Slicing for hdf5 must be in increasing order next_idx = [x + 1 for x in idx] # next_state might wrap around end of dataset if next_idx[-1] == self.dset_size: next_idx[-1] = 0 shape = (sample_size, ) + self.state[0].shape next_states = np.empty(shape, dtype=np.uint8) next_states[0:-1] = self.state[next_idx[0:-1]] next_states[-1] = self.state[0] else: next_states = self.state[next_idx] is_non_terminal = np.arrays( [not self.is_terminal(idx) for idx in next_idx], dtype=bool) return (self.state[idx], self.action[next_idx], self.reward[next_idx], next_states, self.non_terminal[next_idx])
def One_step_search(self, state, Value): """ Function for calculating the value function v(s) ----------- Function parameters -------------- state: current state, for example, say s: coordinates [x,y] V: value function: array A: all possible actions: array/ list """ Action_list = np.arrays(self.env.actions) for actions in range(self.env.actions): for prabability, next_state, reward, done in self.env.array[state][actions]: Action_list[actions] += probability*(reward + self.lambda*V[next_state]) return Action_list
def _compute_sum_last_errors(self): import torch with torch.no_grad(): X = self.memory_x[self.evaluation_index:self._memory_size(self)] if type(X[0]) == type(torch.zeros(0)): X = torch.stack(X) else: X = torch.tensor(X).to(self.device) a = self.memory_a[self.evaluation_index:self._memory_size(self)] if type(a[0]) == type(torch.zeros(0)): a = torch.stack(a) else: a = torch.tensor(a).to(self.device) # il y a surement moyen de faire ca en mode matricielle losses = [] for ae in self.auto_encoders: loss = self.loss(X, ae(X).gather(1, a)).item() losses.append(loss) losses = np.arrays(losses) return losses * len(X)
# mixture of normal distributions in 2D # Distributions should not be too far away each other not be too close each other # Performance of methods depends on (i) locations/variance of normal distributions and (ii) sample size # Write the codes to generate a sample set first, and # Visualize the sample records in 2D and grab the difficuty of the task at a glance # Number of normal distributions : ndist = 3 # Sample size : nsample = 100 # Centers of normal distributions import numpy as np ctrs = np.arrays([[0.0,0],[1,0],[0.7,0.4]]) # Sigma matrix sigmas = np.arrays([[],[]],[[],[]],[[],[]])
import cv2 import numpy as np #CAPTURING THE VIDEO FROM THE DEFAULT WEBCAM cap = cv2.VideoCapture(0) while True: # ' _ ' IS A PYTHON CONVENTION THAT TELLS THE READER/USER TO IGNORE THE VALUE WHICH IS IN THERE. _, frame = cap.read() #HSV IS IMPORTANT FOR DIFFERENT VALUES AND RANGES OF COLORS INSTEAD OF RGB hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) #MAXIMUM AND MINIMUM OF THE COLOR VALUES # WE NEED TO CHANGE THE VALUE OF THE FOLLOWING IN ORDER TO GET THE DESIRED RESULTS color_value_1 = np.arrays([0, 0, 0]) color_value_2 = np.arrays([255, 255, 255]) # MASK IS THE RANGE BETWEEN color_value_1 AND color_value_2. SO BASICALLY MASK IS CURRENTLY IDENTICAL TO FRAME mask = cv2.inRange(hsv, color_value_1, color_value_2) #OPERATING A 'BITWISE-AND' OPERATION ON MASK AND FRAME result = cv2.bitwise_and(frame, frame, mask=mask) #AVERAGING THE PIXELS kernel = np.ones((10, 10), np.float32) / 100 # SMOOTHING smooth_result = cv2.filter2D(result, -1, kernel) #BELOW IS THE SHOCASING OF A FEW DIFFERENT TYPES OF BLUR OPEN-CV HAS TO OFFER
def classify(self): sorted_cards = np.sort(self.cards, axis=None) flush = False straight = False ranks = {} suits = {} straight_count = 1 straight_cards = np.array([]) ace_present = False highest_rank = 0 high_card = None previous_card = None for i in range(len(sorted_cards)): card = sorted_cards[i] rank = card.get_rank() suit = card.get_suit() if rank not in ranks: ranks[rank] = np.array([card]) else: ranks[rank] = np.append(ranks[rank], card) if suit not in suits: suits[suit] = np.array([card]) else: suits[suit] = np.append(suits[suit], card) if previous_card is None: previous_card = card else: if highest_rank < rank: highest_rank = rank high_card = card previous_rank = previous_card.get_rank() # Accumulates points towards a straight classification if previous_rank == rank - 1: straight_count += 1 # Resets points else: straight_count = 1 # Defines straight if straight_count >= 5: straight = True straight_cards = np.arrays([sorted_cards[i-4], sorted_cards[i-3], sorted_cards[i-2], sorted_cards[i-1], sorted_cards[i]]) # Handles ace high straights elif straight_count == 4 and rank == 13 and ace_present: straight = True straight_cards = np.arrays([sorted_cards[i-3], sorted_cards[i-2], sorted_cards[i-1], sorted_cards[i], sorted_cards[0]]) if straight: self.assign_classification(handClassification=4, cards=straight_cards) # Assigns junk card classification if ace_present: high_card = sorted_cards[0] self.assign_classification(handClassification=0, cards=high_card) # Checking for float classification for suit, cards in suits.items(): if len(cards) == 5: flush = True if flush: self.assign_classification(handClassification=5, cards=cards) # Checking for special straight classifications (straight flush, royal flush) if straight: if cards == straight_cards: self.assign_classification(handClassification=8, cards=cards) if cards[-1].rank == 1: self.assign_classification(handClassification=9, cards=cards) # Checking for pair classifications (pair, two pair, 3oak, 4oak, full house) pairs = np.array([]) for rank, cards in ranks.items(): appearances = len(cards) # print(f"rank: {rank}, appearances: {appearances}, cards: {cards}") # Check Pair if appearances == 2: # Check for full house if len(pairs) == 2: pairs = np.append(pairs, cards) self.assign_classification(handClassification=2, cards=pairs) if len(pairs) == 3: pairs = np.append(pairs, cards) self.assign_classification(handClassification=6, cards=pairs) pairs = cards self.assign_classification(handClassification=1, cards=cards) # Check 3 of a kind if appearances == 3: # Check for full house if len(pairs) == 2: pairs = np.append(pairs, cards) self.assign_classification(handClassification=6, cards=pairs) pairs = cards self.assign_classification(handClassification=3, cards=cards) # Checks 4 of a kind if appearances == 4: self.assign_classification(handClassification=7, cards=cards)
test_end = dt.datetime.now() test_data = web.DataReader(company, 'yahoo', test_start, test_end) actual_prices = test_data['Close'].values total_dataset = pd.concat((data['Close'], test_data['Close'])) model_inputs = total_dataset[len(total_dataset) - len(test_data) - prediction_days:].values model_inputs = model_inputs.reshape(-1, 1) model_inputs = scaler.transform(model_inputs) # Make Predictions on Test Data x_test = [] for x in range(prediction_days, len(model_inputs)): x_test.append(model_inputs[x - prediction_days:x, 0]) x_test = np.arrays(x_test) x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1)) predicted_prices = model.predict(x_test) predicted_prices = scaler.inverse_transform(predicted_prices) # Plot the Test Predictions plt.plot(actual_prices, color="black", label=f"Actual {company} price") plt.plot(predicted_prices, color="green", label=f"Predicted {company} price") plt.title(f"{company} share price ") plt.xlabel('Time') plt.ylabel(f'{company} Share price') plt.legend() plt.show()
np.mean(CRSP_Unconstrained2.fit_err) np.std(CRSP_Unconstrained2.fit_err) np.mean(CRSP_Unconstrained2.fit_err['2011-01-01':]) np.std(CRSP_Unconstrained2.fit_err['2011-01-01':]) np.mean(CRSP_EW.price_err) np.std(CRSP_EW.price_err) np.mean(CRSP_EW.price_err['2011-01-01':]) np.std(CRSP_EW.price_err['2011-01-01':]) number_bonds = np.array([len(r['cusips']) for r in CRSP_Unconstrained_Results_list]) np.arrays(number_bonds).mean() np.argmin(number_bonds) CRSP_Unconstrained2_Results_list[0].keys() len(CRSP_by_cusip[CRSP_by_cusip.ITYPE < 5]) len(CRSP_by_cusip[CRSP_by_cusip.ITYPE == 4]) len(CRSP_by_cusip[CRSP_by_cusip.ITYPE == 2]) len(CRSP_by_cusip[CRSP_by_cusip.ITYPE == 1]) unconstrained_beta = np.array([r['nss_params'] for r in CRSP_Unconstrained2_Results_list]) ridge_beta = np.array([r['nss_params'] for r in CRSP_ZeroRidge_Results_list]) unconstrained_beta = np.array([r['nss_params'] for r in CRSP_EW_Results_list]) ridge_beta = np.array([r['nss_params'] for r in CRSP_EWZeroRidge_Results_list])
def predict(clf, data): data = np.arrays(data) return int(clf.predict(data.reshape(1, -1)))