aug

type AffineOption ¶

type AffineOption func(*affineOptions)

func WithAffineDegree(degree []int64) AffineOption

func WithAffineFillValue(fillValue []float64) AffineOption

func WithAffineMode(mode string) AffineOption

func WithAffineScale(scale []float64) AffineOption

func WithAffineShear(shear []float64) AffineOption

func WithAffineTranslate(translate []float64) AffineOption

type Augment ¶

type Augment struct {
	// contains filtered or unexported fields
}

Augment is a struct composes of augmentation functions to implement Transformer interface.

func (a *Augment) Transform(image *ts.Tensor) *ts.Tensor

type CenterCrop ¶

type CenterCrop struct {
	// contains filtered or unexported fields
}

CenterCrop crops the given image at the center. If the image is torch Tensor, it is expected to have [..., H, W] shape, where ... means an arbitrary number of leading dimensions. If image size is smaller than output size along any edge, image is padded with 0 and then center cropped.

func (cc *CenterCrop) Forward(x *ts.Tensor) *ts.Tensor

type ColorJitter ¶

type ColorJitter struct {
	// contains filtered or unexported fields
}

func (c *ColorJitter) Forward(x *ts.Tensor) *ts.Tensor

type ColorOption ¶

type ColorOption func(*colorOptions)

func WithColorBrightness(v []float64) ColorOption

func WithColorContrast(v []float64) ColorOption

func WithColorHue(vals []float64) ColorOption

func WithColorSaturation(v []float64) ColorOption

type CutoutOption ¶

type CutoutOption func(o *cutoutOptions)

func WithCutoutPvalue(p float64) CutoutOption

func WithCutoutRatio(ratio []float64) CutoutOption

func WithCutoutScale(scale []float64) CutoutOption

func WithCutoutValue(rgb []int64) CutoutOption

type DownSample ¶

type DownSample struct{}

func (rs *DownSample) Forward(x *ts.Tensor) *ts.Tensor

type GaussianBlur ¶

type GaussianBlur struct {
	// contains filtered or unexported fields
}

func (b *GaussianBlur) Forward(x *ts.Tensor) *ts.Tensor

type Grayscale ¶

type Grayscale struct {
	// contains filtered or unexported fields
}

GrayScale converts image to grayscale. If the image is torch Tensor, it is expected to have [..., 3, H, W] shape, where ... means an arbitrary number of leading dimensions Args: - num_output_channels (int): (1 or 3) number of channels desired for output image

func NewGrayscale(outChanOpt ...int64) *Grayscale

func (gs *Grayscale) Forward(x *ts.Tensor) *ts.Tensor

type Normalize ¶

type Normalize struct {
	// contains filtered or unexported fields
}

Normalize normalizes a tensor image with mean and standard deviation. Given mean: “(mean[1],...,mean[n])“ and std: “(std[1],..,std[n])“ for “n“ channels, this transform will normalize each channel of the input “torch.*Tensor“ i.e., “output[channel] = (input[channel] - mean[channel]) / std[channel]“ .. note:: This transform acts out of place, i.e., it does not mutate the input tensor. Args: - mean (sequence): Sequence of means for each channel. - std (sequence): Sequence of standard deviations for each channel.

func (n *Normalize) Forward(x *ts.Tensor) *ts.Tensor

type NormalizeOption ¶

type NormalizeOption func(*normalizeOptions)

func WithNormalizeMean(mean []float64) NormalizeOption

func WithNormalizeStd(std []float64) NormalizeOption

type Option ¶

type Option func(o *Options)

func OneOf(pvalue float64, tfOpts ...Option) Option

func WithCenterCrop(size []int64) Option

func WithColorJitter(opts ...ColorOption) Option

func WithGaussianBlur(ks []int64, sig []float64) Option

func WithNormalize(opts ...NormalizeOption) Option

func WithRandRotate(minAngle, maxAngle float64) Option

func WithRandomAdjustSharpness(opts ...SharpnessOption) Option

func WithRandomAffine(opts ...AffineOption) Option

func WithRandomAutocontrast(p ...float64) Option

func WithRandomCrop(size []int64, padding []int64, paddingIfNeeded bool, paddingMode string) Option

func WithRandomCutout(opts ...CutoutOption) Option

func WithRandomEqualize(p ...float64) Option

func WithRandomGrayscale(pvalueOpt ...float64) Option

func WithRandomHFlip(pvalue float64) Option

func WithRandomInvert(pvalueOpt ...float64) Option

func WithRandomPerspective(opts ...PerspectiveOption) Option

func WithRandomPosterize(opts ...PosterizeOption) Option

func WithRandomSolarize(opts ...SolarizeOption) Option

func WithRandomVFlip(pvalue float64) Option

func WithResize(h, w int64) Option

func WithRotate(angle float64) Option

func WithZoomIn(v float64) Option

func WithZoomOut(v float64) Option

type Options ¶

type Options struct {
	// contains filtered or unexported fields
}

type PerspectiveOption ¶

type PerspectiveOption func(*perspectiveOptions)

func WithPerspectiveMode(m string) PerspectiveOption

func WithPerspectivePvalue(p float64) PerspectiveOption

func WithPerspectiveScale(s float64) PerspectiveOption

func WithPerspectiveValue(v []float64) PerspectiveOption

type PosterizeOption ¶

type PosterizeOption func(*posterizeOptions)

func WithPosterizeBits(bits uint8) PosterizeOption

func WithPosterizePvalue(p float64) PosterizeOption

type RandRotateModule ¶

type RandRotateModule struct {
	// contains filtered or unexported fields
}

RandomRotateModule

func (rr *RandRotateModule) Forward(x *ts.Tensor) *ts.Tensor

type RandomAdjustSharpness ¶

type RandomAdjustSharpness struct {
	// contains filtered or unexported fields
}

Adjust the sharpness of the image randomly with a given probability. If the image is torch Tensor, it is expected to have [..., 1 or 3, H, W] shape, where ... means an arbitrary number of leading dimensions. Args: sharpness_factor (float): How much to adjust the sharpness. Can be any non negative number. 0 gives a blurred image, 1 gives the original image while 2 increases the sharpness by a factor of 2. p (float): probability of the image being color inverted. Default value is 0.5

func (ras *RandomAdjustSharpness) Forward(x *ts.Tensor) *ts.Tensor

type RandomAffine ¶

type RandomAffine struct {
	// contains filtered or unexported fields
}

RandomAffine is transformation of the image keeping center invariant. If the image is torch Tensor, it is expected to have [..., H, W] shape, where ... means an arbitrary number of leading dimensions. Args: - degrees (sequence or number): Range of degrees to select from. If degrees is a number instead of sequence like (min, max), the range of degrees will be (-degrees, +degrees). Set to 0 to deactivate rotations. - translate (tuple, optional): tuple of maximum absolute fraction for horizontal and vertical translations. For example translate=(a, b), then horizontal shift is randomly sampled in the range -img_width * a < dx < img_width * a and vertical shift is randomly sampled in the range -img_height * b < dy < img_height * b. Will not translate by default. - scale (tuple, optional): scaling factor interval, e.g (a, b), then scale is randomly sampled from the range a <= scale <= b. Will keep original scale by default. - shear (sequence or number, optional): Range of degrees to select from. If shear is a number, a shear parallel to the x axis in the range (-shear, +shear) will be applied. Else if shear is a sequence of 2 values a shear parallel to the x axis in the range (shear[0], shear[1]) will be applied. Else if shear is a sequence of 4 values, a x-axis shear in (shear[0], shear[1]) and y-axis shear in (shear[2], shear[3]) will be applied. Will not apply shear by default. - interpolation (InterpolationMode): Desired interpolation enum defined by :class:`torchvision.transforms.InterpolationMode`. Default is “InterpolationMode.NEAREST“. If input is Tensor, only “InterpolationMode.NEAREST“, “InterpolationMode.BILINEAR“ are supported. For backward compatibility integer values (e.g. “PIL.Image.NEAREST“) are still acceptable. - fill (sequence or number): Pixel fill value for the area outside the transformed image. Default is “0“. If given a number, the value is used for all bands respectively. Please use the “interpolation“ parameter instead. .. _filters: https://pillow.readthedocs.io/en/latest/handbook/concepts.html#filters

func (ra *RandomAffine) Forward(x *ts.Tensor) *ts.Tensor

type RandomAutocontrast ¶

type RandomAutocontrast struct {
	// contains filtered or unexported fields
}

RandomAutocontrast autocontrasts the pixels of the given image randomly with a given probability. If the image is torch Tensor, it is expected to have [..., 1 or 3, H, W] shape, where ... means an arbitrary number of leading dimensions. Args: - p (float): probability of the image being autocontrasted. Default value is 0.5

func (rac *RandomAutocontrast) Forward(x *ts.Tensor) *ts.Tensor

type RandomCrop ¶

type RandomCrop struct {
	// contains filtered or unexported fields
}

func (c *RandomCrop) Forward(x *ts.Tensor) *ts.Tensor

type RandomCutout ¶

type RandomCutout struct {
	// contains filtered or unexported fields
}

Randomly selects a rectangle region in an torch Tensor image and erases its pixels. This transform does not support PIL Image. 'Random Erasing Data Augmentation' by Zhong et al. See https://arxiv.org/abs/1708.04896

Args: p: probability that the random erasing operation will be performed. scale: range of proportion of erased area against input image. ratio: range of aspect ratio of erased area. value: erasing value. Default is 0. If a single int, it is used to erase all pixels. If a tuple of length 3, it is used to erase R, G, B channels respectively. If a str of 'random', erasing each pixel with random values.

func (rc *RandomCutout) Forward(img *ts.Tensor) *ts.Tensor

type RandomEqualize ¶

type RandomEqualize struct {
	// contains filtered or unexported fields
}

RandomEqualize equalizes the histogram of the given image randomly with a given probability. If the image is torch Tensor, it is expected to have [..., 1 or 3, H, W] shape, where ... means an arbitrary number of leading dimensions. Args: - p (float): probability of the image being equalized. Default value is 0.5 Histogram equalization Ref. https://en.wikipedia.org/wiki/Histogram_equalization

func (re *RandomEqualize) Forward(x *ts.Tensor) *ts.Tensor

type RandomGrayscale ¶

type RandomGrayscale struct {
	// contains filtered or unexported fields
}

RandomGrayscale randomly converts image to grayscale with a probability of p (default 0.1). If the image is torch Tensor, it is expected to have [..., 3, H, W] shape, where ... means an arbitrary number of leading dimensions Args: - p (float): probability that image should be converted to grayscale.

func (rgs *RandomGrayscale) Forward(x *ts.Tensor) *ts.Tensor

type RandomHorizontalFlip ¶

type RandomHorizontalFlip struct {
	// contains filtered or unexported fields
}

RandomHorizontalFlip horizontally flips the given image randomly with a given probability.

If the image is torch Tensor, it is expected to have [..., H, W] shape, where ... means an arbitrary number of leading dimensions Args: p (float): probability of the image being flipped. Default value is 0.5

func (hf *RandomHorizontalFlip) Forward(x *ts.Tensor) *ts.Tensor

type RandomInvert ¶

type RandomInvert struct {
	// contains filtered or unexported fields
}

func (ri *RandomInvert) Forward(x *ts.Tensor) *ts.Tensor

type RandomPerspective ¶

type RandomPerspective struct {
	// contains filtered or unexported fields
}

RandomPerspective performs a random perspective transformation of the given image with a given probability. If the image is torch Tensor, it is expected to have [..., H, W] shape, where ... means an arbitrary number of leading dimensions. Args: distortion_scale (float): argument to control the degree of distortion and ranges from 0 to 1. Default is 0.5. p (float): probability of the image being transformed. Default is 0.5. interpolation (InterpolationMode): Desired interpolation enum defined by :class:`torchvision.transforms.InterpolationMode`. Default is “InterpolationMode.BILINEAR“. If input is Tensor, only “InterpolationMode.NEAREST“, “InterpolationMode.BILINEAR“ are supported. For backward compatibility integer values (e.g. “PIL.Image.NEAREST“) are still acceptable. fill (sequence or number): Pixel fill value for the area outside the transformed image. Default is “0“. If given a number, the value is used for all bands respectively.

func (rp *RandomPerspective) Forward(x *ts.Tensor) *ts.Tensor

type RandomPosterize ¶

type RandomPosterize struct {
	// contains filtered or unexported fields
}

RandomPosterize posterizes the image randomly with a given probability by reducing the number of bits for each color channel. If the image is torch Tensor, it should be of type torch.uint8, and it is expected to have [..., 1 or 3, H, W] shape, where ... means an arbitrary number of leading dimensions. Args: - bits (int): number of bits to keep for each channel (0-8) - p (float): probability of the image being color inverted. Default value is 0.5 Ref. https://en.wikipedia.org/wiki/Posterization

func (rp *RandomPosterize) Forward(x *ts.Tensor) *ts.Tensor

type RandomResizedCrop ¶

type RandomResizedCrop struct{}

TODO.

type RandomSolarize ¶

type RandomSolarize struct {
	// contains filtered or unexported fields
}

RandomSolarize solarizes the image randomly with a given probability by inverting all pixel values above a threshold. If img is a Tensor, it is expected to be in [..., 1 or 3, H, W] format, where ... means it can have an arbitrary number of leading dimensions. If img is PIL Image, it is expected to be in mode "L" or "RGB". Args: - threshold (float): all pixels equal or above this value are inverted. - p (float): probability of the image being color inverted. Default value is 0.5 Ref. https://en.wikipedia.org/wiki/Solarization_(photography)

func (rs *RandomSolarize) Forward(x *ts.Tensor) *ts.Tensor

type RandomVerticalFlip ¶

type RandomVerticalFlip struct {
	// contains filtered or unexported fields
}

RandomVerticalFlip vertically flips the given image randomly with a given probability.

If the image is torch Tensor, it is expected to have [..., H, W] shape, where ... means an arbitrary number of leading dimensions Args: p (float): probability of the image being flipped. Default value is 0.5

func (vf *RandomVerticalFlip) Forward(x *ts.Tensor) *ts.Tensor

type ResizeModule ¶

type ResizeModule struct {
	// contains filtered or unexported fields
}

func (rs *ResizeModule) Forward(x *ts.Tensor) *ts.Tensor

type RotateModule ¶

type RotateModule struct {
	// contains filtered or unexported fields
}

RotateModule

func (r *RotateModule) Forward(x *ts.Tensor) *ts.Tensor

type SharpnessOption ¶

type SharpnessOption func(*sharpnessOptions)

func WithSharpnessFactor(f float64) SharpnessOption

func WithSharpnessPvalue(p float64) SharpnessOption

type SolarizeOption ¶

type SolarizeOption func(*solarizeOptions)

func WithSolarizePvalue(p float64) SolarizeOption

func WithSolarizeThreshold(th float64) SolarizeOption

type Transformer ¶

type Transformer interface {
	Transform(x *ts.Tensor) *ts.Tensor
}

Transformer is an interface that can transform an image tensor.

func Compose(opts ...Option) (Transformer, error)

type ZoomIn ¶

type ZoomIn struct {
	// contains filtered or unexported fields
}

func (rs *ZoomIn) Forward(x *ts.Tensor) *ts.Tensor

type ZoomOut ¶

type ZoomOut struct {
	// contains filtered or unexported fields
}

func (rs *ZoomOut) Forward(x *ts.Tensor) *ts.Tensor