Split (1)

train · 199k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

INSTRUCTION stringlengths 1 46.3k	RESPONSE stringlengths 75 80.2k
Fixed `mode` `padding` and random crop of `size`	def rand_pad(padding:int, size:int, mode:str='reflection'): "Fixed `mode` `padding` and random crop of `size`" return [pad(padding=padding,mode=mode), crop(size=size, **rand_pos)]
Randomized version of `zoom`.	def rand_zoom(scale:uniform=1.0, p:float=1.): "Randomized version of `zoom`." return zoom(scale=scale, **rand_pos, p=p)
Randomized version of `crop_pad`.	def rand_crop(args, padding_mode='reflection', p:float=1.): "Randomized version of `crop_pad`." return crop_pad(args, **rand_pos, padding_mode=padding_mode, p=p)
Randomly zoom and/or crop.	def zoom_crop(scale:float, do_rand:bool=False, p:float=1.0): "Randomly zoom and/or crop." zoom_fn = rand_zoom if do_rand else zoom crop_fn = rand_crop if do_rand else crop_pad return [zoom_fn(scale=scale, p=p), crop_fn()]
Find 8 coeff mentioned [here](https://web.archive.org/web/20150222120106/xenia.media.mit.edu/~cwren/interpolator/).	def _find_coeffs(orig_pts:Points, targ_pts:Points)->Tensor: "Find 8 coeff mentioned [here](https://web.archive.org/web/20150222120106/xenia.media.mit.edu/~cwren/interpolator/)." matrix = [] #The equations we'll need to solve. for p1, p2 in zip(targ_pts, orig_pts): matrix.append([p1[0], p1[1], 1,...
Transform `coords` with `coeffs`.	def _apply_perspective(coords:FlowField, coeffs:Points)->FlowField: "Transform `coords` with `coeffs`." size = coords.flow.size() #compress all the dims expect the last one ang adds ones, coords become N * 3 coords.flow = coords.flow.view(-1,2) #Transform the coeffs in a 3*3 matrix with a 1 at the b...
Apply warp to `targ_pts` from `_orig_pts` to `c` `FlowField`.	def _do_perspective_warp(c:FlowField, targ_pts:Points, invert=False): "Apply warp to `targ_pts` from `_orig_pts` to `c` `FlowField`." if invert: return _apply_perspective(c, _find_coeffs(targ_pts, _orig_pts)) return _apply_perspective(c, _find_coeffs(_orig_pts, targ_pts))
Apply warp of `magnitude` to `c`.	def _perspective_warp(c, magnitude:partial(uniform,size=8)=0, invert=False): "Apply warp of `magnitude` to `c`." magnitude = magnitude.view(4,2) targ_pts = [[x+m for x,m in zip(xs, ms)] for xs, ms in zip(_orig_pts, magnitude)] return _do_perspective_warp(c, targ_pts, invert)
Apply symmetric warp of `magnitude` to `c`.	def _symmetric_warp(c, magnitude:partial(uniform,size=4)=0, invert=False): "Apply symmetric warp of `magnitude` to `c`." m = listify(magnitude, 4) targ_pts = [[-1-m[3],-1-m[1]], [-1-m[2],1+m[1]], [1+m[3],-1-m[0]], [1+m[2],1+m[0]]] return _do_perspective_warp(c, targ_pts, invert)
Tilt `c` field with random `direction` and `magnitude`.	def _tilt(c, direction:uniform_int, magnitude:uniform=0, invert=False): "Tilt `c` field with random `direction` and `magnitude`." orig_pts = [[-1,-1], [-1,1], [1,-1], [1,1]] if direction == 0: targ_pts = [[-1,-1], [-1,1], [1,-1-magnitude], [1,1+magnitude]] elif direction == 1: targ_pts = [[-1,-1-magni...
Utility func to easily create a list of flip, rotate, `zoom`, warp, lighting transforms.	def get_transforms(do_flip:bool=True, flip_vert:bool=False, max_rotate:float=10., max_zoom:float=1.1, max_lighting:float=0.2, max_warp:float=0.2, p_affine:float=0.75, p_lighting:float=0.75, xtra_tfms:Optional[Collection[Transform]]=None)->Collection[Transform]: "Utility func to...
Utility routine to compute zoom/squish matrix.	def _compute_zs_mat(sz:TensorImageSize, scale:float, squish:float, invert:bool, row_pct:float, col_pct:float)->AffineMatrix: "Utility routine to compute zoom/squish matrix." orig_ratio = math.sqrt(sz[1]/sz[0]) for s,r,i in zip(scale,squish, invert): s,r = 1/math.sqrt(s),math.sqrt(...
Randomly resize and crop the image to a ratio in `ratios` after a zoom of `max_scale`.	def rand_resize_crop(size:int, max_scale:float=2., ratios:Tuple[float,float]=(0.75,1.33)): "Randomly resize and crop the image to a ratio in `ratios` after a zoom of `max_scale`." return [zoom_squish(scale=(1.,max_scale,8), squish=(*ratios,8), invert=(0.5,8), row_pct=(0.,1.), col_pct=(0.,1.)), crop(...
Sets the learning rate to the initial LR decayed by 10 every 30 epochs	def adjust_learning_rate(optimizer, epoch, gammas, schedule): """Sets the learning rate to the initial LR decayed by 10 every 30 epochs""" lr = args.learning_rate assert len(gammas) == len(schedule), "length of gammas and schedule should be equal" for (gamma, step) in zip(gammas, schedule): if (epoch >= ste...
Method does some preparation before finally delegating to the 'fit' method for fitting the model. Namely, if cycle_len is defined, it adds a 'Cosine Annealing' scheduler for varying the learning rate across iterations. Method also computes the total number of epochs to fit based on provided 'cy...	def fit_gen(self, model, data, layer_opt, n_cycle, cycle_len=None, cycle_mult=1, cycle_save_name=None, best_save_name=None, use_clr=None, use_clr_beta=None, metrics=None, callbacks=None, use_wd_sched=False, norm_wds=False, wds_sched_mult=None, use_swa=False, swa_start=1, swa...
Method returns an instance of the LayerOptimizer class, which allows for setting differential learning rates for different parts of the model. An example of how a model maybe differentiated into different parts for application of differential learning rates and weight decays is ...	def get_layer_opt(self, lrs, wds): """Method returns an instance of the LayerOptimizer class, which allows for setting differential learning rates for different parts of the model. An example of how a model maybe differentiated into different parts for application of differenti...
Method gets an instance of LayerOptimizer and delegates to self.fit_gen(..) Note that one can specify a list of learning rates which, when appropriately defined, will be applied to different segments of an architecture. This seems mostly relevant to ImageNet-trained models, where we want to alt...	def fit(self, lrs, n_cycle, wds=None, **kwargs): """Method gets an instance of LayerOptimizer and delegates to self.fit_gen(..) Note that one can specify a list of learning rates which, when appropriately defined, will be applied to different segments of an architecture. This seems mos...
Helps you find an optimal learning rate for a model. It uses the technique developed in the 2015 paper `Cyclical Learning Rates for Training Neural Networks`, where we simply keep increasing the learning rate from a very small value, until the loss starts decreasing. Args: ...	def lr_find(self, start_lr=1e-5, end_lr=10, wds=None, linear=False, **kwargs): """Helps you find an optimal learning rate for a model. It uses the technique developed in the 2015 paper `Cyclical Learning Rates for Training Neural Networks`, where we simply keep increasing the learnin...
A variant of lr_find() that helps find the best learning rate. It doesn't do an epoch but a fixed num of iterations (which may be more or less than an epoch depending on your data). At each step, it computes the validation loss and the metrics on the next batch of the validation data, so...	def lr_find2(self, start_lr=1e-5, end_lr=10, num_it = 100, wds=None, linear=False, stop_dv=True, **kwargs): """A variant of lr_find() that helps find the best learning rate. It doesn't do an epoch but a fixed num of iterations (which may be more or less than an epoch depending on your data). ...
Args: arr: a numpy array to be used as input to the model for prediction purposes Returns: a numpy array containing the predictions from the model	def predict_array(self, arr): """ Args: arr: a numpy array to be used as input to the model for prediction purposes Returns: a numpy array containing the predictions from the model """ if not isinstance(arr, np.ndarray): raise OSError(f'Not valid numpy arr...
Predict with Test Time Augmentation (TTA) Additional to the original test/validation images, apply image augmentation to them (just like for training images) and calculate the mean of predictions. The intent is to increase the accuracy of predictions by examining the images using multiple ...	def TTA(self, n_aug=4, is_test=False): """ Predict with Test Time Augmentation (TTA) Additional to the original test/validation images, apply image augmentation to them (just like for training images) and calculate the mean of predictions. The intent is to increase the accuracy of predi...
Wraps us the content of phases to send them to model.fit(..) This will split the training in several parts, each with their own learning rates/ wds/momentums/optimizer detailed in phases. Additionaly we can add a list of different data objets in data_list to train on different datasets...	def fit_opt_sched(self, phases, cycle_save_name=None, best_save_name=None, stop_div=False, data_list=None, callbacks=None, cut = None, use_swa=False, swa_start=1, swa_eval_freq=5, **kwargs): """Wraps us the content of phases to send them to model.fit(..) This will split the train...
Save the extra outputs for later and only returns the true output.	def on_loss_begin(self, last_output:Tuple[Tensor,Tensor,Tensor], **kwargs): "Save the extra outputs for later and only returns the true output." self.raw_out,self.out = last_output[1],last_output[2] return {'last_output': last_output[0]}
Apply AR and TAR to `last_loss`.	def on_backward_begin(self, last_loss:Rank0Tensor, last_input:Tensor, *kwargs): "Apply AR and TAR to `last_loss`." #AR and TAR if self.alpha != 0.: last_loss += self.alpha self.out[-1].float().pow(2).mean() if self.beta != 0.: h = self.raw_out[-1] if len(h)>1:...
Convert the model `wgts` to go with a new vocabulary.	def convert_weights(wgts:Weights, stoi_wgts:Dict[str,int], itos_new:Collection[str]) -> Weights: "Convert the model `wgts` to go with a new vocabulary." dec_bias, enc_wgts = wgts.get('1.decoder.bias', None), wgts['0.encoder.weight'] wgts_m = enc_wgts.mean(0) if dec_bias is not None: bias_m = dec_bias.me...
Create a language model from `arch` and its `config`, maybe `pretrained`.	def get_language_model(arch:Callable, vocab_sz:int, config:dict=None, drop_mult:float=1.): "Create a language model from `arch` and its `config`, maybe `pretrained`." meta = _model_meta[arch] config = ifnone(config, meta['config_lm'].copy()) for k in config.keys(): if k.endswith('_p'): config[k...
Create a `Learner` with a language model from `data` and `arch`.	def language_model_learner(data:DataBunch, arch, config:dict=None, drop_mult:float=1., pretrained:bool=True, pretrained_fnames:OptStrTuple=None, **learn_kwargs) -> 'LanguageLearner': "Create a `Learner` with a language model from `data` and `arch`." model = get_language_model(arch, le...
Create a text classifier from `arch` and its `config`, maybe `pretrained`.	def get_text_classifier(arch:Callable, vocab_sz:int, n_class:int, bptt:int=70, max_len:int=20*70, config:dict=None, drop_mult:float=1., lin_ftrs:Collection[int]=None, ps:Collection[float]=None, pad_idx:int=1) -> nn.Module: "Create a text classifier from `arch` and it...
Create a `Learner` with a text classifier from `data` and `arch`.	def text_classifier_learner(data:DataBunch, arch:Callable, bptt:int=70, max_len:int=7020, config:dict=None, pretrained:bool=True, drop_mult:float=1., lin_ftrs:Collection[int]=None, ps:Collection[float]=None, *learn_kwargs) -> 'TextClassifierLearner': "Crea...
Save the encoder to `name` inside the model directory.	def save_encoder(self, name:str): "Save the encoder to `name` inside the model directory." encoder = get_model(self.model)[0] if hasattr(encoder, 'module'): encoder = encoder.module torch.save(encoder.state_dict(), self.path/self.model_dir/f'{name}.pth')
Load the encoder `name` from the model directory.	def load_encoder(self, name:str, device:torch.device=None): "Load the encoder `name` from the model directory." encoder = get_model(self.model)[0] if device is None: device = self.data.device if hasattr(encoder, 'module'): encoder = encoder.module encoder.load_state_dict(torch.lo...
Load a pretrained model and adapts it to the data vocabulary.	def load_pretrained(self, wgts_fname:str, itos_fname:str, strict:bool=True): "Load a pretrained model and adapts it to the data vocabulary." old_itos = pickle.load(open(itos_fname, 'rb')) old_stoi = {v:k for k,v in enumerate(old_itos)} wgts = torch.load(wgts_fname, map_location=lambda st...
Return predictions and targets on the valid, train, or test set, depending on `ds_type`.	def get_preds(self, ds_type:DatasetType=DatasetType.Valid, with_loss:bool=False, n_batch:Optional[int]=None, pbar:Optional[PBar]=None, ordered:bool=False) -> List[Tensor]: "Return predictions and targets on the valid, train, or test set, depending on `ds_type`." self.model.reset() ...
Return the `n_words` that come after `text`.	def predict(self, text:str, n_words:int=1, no_unk:bool=True, temperature:float=1., min_p:float=None, sep:str=' ', decoder=decode_spec_tokens): "Return the `n_words` that come after `text`." ds = self.data.single_dl.dataset self.model.reset() xb,yb = self.data.one_item(tex...
Return the `n_words` that come after `text` using beam search.	def beam_search(self, text:str, n_words:int, no_unk:bool=True, top_k:int=10, beam_sz:int=1000, temperature:float=1., sep:str=' ', decoder=decode_spec_tokens): "Return the `n_words` that come after `text` using beam search." ds = self.data.single_dl.dataset self.model.reset() ...
Show `rows` result of predictions on `ds_type` dataset.	def show_results(self, ds_type=DatasetType.Valid, rows:int=5, max_len:int=20): from IPython.display import display, HTML "Show `rows` result of predictions on `ds_type` dataset." ds = self.dl(ds_type).dataset x,y = self.data.one_batch(ds_type, detach=False, denorm=False) preds = ...
Concatenate the `arrs` along the batch dimension.	def concat(self, arrs:Collection[Tensor])->Tensor: "Concatenate the `arrs` along the batch dimension." return [torch.cat([l[si] for l in arrs], dim=1) for si in range_of(arrs[0])]
A batchnorm2d layer with `nf` features initialized depending on `norm_type`.	def batchnorm_2d(nf:int, norm_type:NormType=NormType.Batch): "A batchnorm2d layer with `nf` features initialized depending on `norm_type`." bn = nn.BatchNorm2d(nf) with torch.no_grad(): bn.bias.fill_(1e-3) bn.weight.fill_(0. if norm_type==NormType.BatchZero else 1.) return bn
Sequence of batchnorm (if `bn`), dropout (with `p`) and linear (`n_in`,`n_out`) layers followed by `actn`.	def bn_drop_lin(n_in:int, n_out:int, bn:bool=True, p:float=0., actn:Optional[nn.Module]=None): "Sequence of batchnorm (if `bn`), dropout (with `p`) and linear (`n_in`,`n_out`) layers followed by `actn`." layers = [nn.BatchNorm1d(n_in)] if bn else [] if p != 0: layers.append(nn.Dropout(p)) layers.append(...
Create and initialize a `nn.Conv1d` layer with spectral normalization.	def conv1d(ni:int, no:int, ks:int=1, stride:int=1, padding:int=0, bias:bool=False): "Create and initialize a `nn.Conv1d` layer with spectral normalization." conv = nn.Conv1d(ni, no, ks, stride=stride, padding=padding, bias=bias) nn.init.kaiming_normal_(conv.weight) if bias: conv.bias.data.zero_() re...