public Model(string name, torch.Device device = null) : base(name) { RegisterComponents(); if (device != null && device.type == DeviceType.CUDA) { this.to(device); } }
public Model(string name, int numClasses, torch.Device device = null) : base(name) { features = Sequential( ("c1", Conv2d(3, 64, kernelSize: 3, stride: 2, padding: 1)), ("r1", ReLU(inPlace: true)), ("mp1", MaxPool2d(kernelSize: new long[] { 2, 2 })), ("c2", Conv2d(64, 192, kernelSize: 3, padding: 1)), ("r2", ReLU(inPlace: true)), ("mp2", MaxPool2d(kernelSize: new long[] { 2, 2 })), ("c3", Conv2d(192, 384, kernelSize: 3, padding: 1)), ("r3", ReLU(inPlace: true)), ("c4", Conv2d(384, 256, kernelSize: 3, padding: 1)), ("r4", ReLU(inPlace: true)), ("c5", Conv2d(256, 256, kernelSize: 3, padding: 1)), ("r5", ReLU(inPlace: true)), ("mp3", MaxPool2d(kernelSize: new long[] { 2, 2 }))); avgPool = AdaptiveAvgPool2d(new long[] { 2, 2 }); classifier = Sequential( ("d1", Dropout()), ("l1", Linear(256 * 2 * 2, 4096)), ("r1", ReLU(inPlace: true)), ("d2", Dropout()), ("l2", Linear(4096, 4096)), ("r3", ReLU(inPlace: true)), ("d3", Dropout()), ("l3", Linear(4096, numClasses)) ); RegisterModule("features", features); RegisterModule("avg", avgPool); RegisterModule("classify", classifier); if (device != null && device.type == DeviceType.CUDA) { this.to(device); } }
public static torch.Tensor CollateTokens(IList <torch.Tensor> values, int padIndex, int?eosIndex = null, bool leftPad = false, bool moveEosToBeginning = false, torch.Device device = null) { Contracts.AssertNonEmpty(values, "Can't collate 0 values"); Contracts.Assert(values.All(v => v.dim() == 1), "All tensors should be 1D to collate."); var size = values.Select(v => v.size(0)).Max(); var res = values[0].new_full(values.Count, size, padIndex, device: device); for (var i = 0; i < values.Count; ++i) { var v = values[i]; CopyTensor( v, leftPad ? res[torch.TensorIndex.Single(i), torch.TensorIndex.Slice(start: size - v.size(0))] : res[torch.TensorIndex.Single(i), torch.TensorIndex.Slice(stop: v.size(0))], moveEosToBeginning, eosIndex); } return(res); }
/// <summary> /// Normalize a float tensor image with mean and standard deviation. /// </summary> /// <param name="means">Sequence of means for each channel.</param> /// <param name="stdevs">Sequence of standard deviations for each channel.</param> /// <param name="dtype">Bool to make this operation inplace.</param> /// <param name="device">The device to place the output tensor on.</param> /// <returns></returns> static public ITransform Normalize(double[] means, double[] stdevs, ScalarType dtype = ScalarType.Float32, torch.Device device = null) { return(new Normalize(means, stdevs, dtype, device)); }
internal Normalize(double[] means, double[] stdevs, ScalarType dtype = ScalarType.Float32, torch.Device device = null) { if (means.Length != stdevs.Length) { throw new ArgumentException("means and stdevs must be the same length in call to Normalize"); } this.means = means.ToTensor(new long[] { 1, means.Length, 1, 1 }); // Assumes NxCxHxW this.stdevs = stdevs.ToTensor(new long[] { 1, stdevs.Length, 1, 1 }); // Assumes NxCxHxW if (dtype != ScalarType.Float64) { this.means = this.means.to_type(dtype); this.stdevs = this.stdevs.to_type(dtype); } if (device != null && device.type != DeviceType.CPU) { this.means = this.means.to(device); this.stdevs = this.stdevs.to(device); } }