Currently developers have to either hardcode or manually calculate the number of elements in a given vector. It would be helpful to expose a Count property that does this for you.
Proposed API

public partial struct Vector64
{
public static int Count { get; }
}

public partial struct Vector128
{
public static int Count { get; }
}

public partial struct Vector256
{
public static int Count { get; }
}

Usages

We currently expose this property internally as part of our argument validation for things like GetElement and WithElement. This is expected to be used by the user to validate that inputs to the various intrinsics or helper methods are also in range, when they are not statically known to be so. It is also expected to be used as the increment for certain for loops (such as when performing vectorized operations over an array of T) and other similar cases.

system.net.network is failing

System.Data timeout when connecting to ... SQL

For HttpClientHandler layer (above the WinHttpHandler layer on Windows), we should be consistent and throw the exception in the CookieContainer setter when null value is provided, to match .NET Framework's behavior. This would keep the same behavior across all platforms for the setter of the HttpClientHandler.CookieContainer property.

Improve BMI2 MultiplyNoFlags APIs
The current Bmi2.MultiplyNoFlags API follows the C/C++ intrinsic design that returns lower half of the result and stores the higher half in memory via a pointer of out argument. According to feedback dotnet/coreclr#18712 (comment), the API returning higher half is more useful for developers and simpler to implement and optimize for compiler writers. So, we suggest changing the API to:

public static unsafe uint MultiplyNoFlags(uint left, uint right);
public static unsafe uint MultiplyNoFlags(uint left, uint right, uint* lower);

The current Bmi2.MultiplyNoFlags API follows the C/C++ intrinsic design that returns lower half of the result and stores the higher half in memory via a pointer of out argument. According to feedback dotnet/coreclr#18712 (comment), the API returning higher half is more useful for developers and simpler to implement and optimize for compiler writers. So, we suggest changing the API to:

public static unsafe uint MultiplyNoFlags(uint left, uint right);
public static unsafe uint MultiplyNoFlags(uint left, uint right, uint* lower);

Hello @elbruno
I have a model in custom vision and it is detecting object Very good at https://www.customvision.ai/.
After i export it(onnx) and i will check with ml.net
our accuracy decrease and it does not recognize object .
note : my objects are small , character size ,
please help me.

"URI construction is failing on valid URIs under the following conditions: - An absolute URI is constructed using the Uri(Uri absolute, string relative) constructor. - The relative string begins with 1024+ characters, followed by a colon. - The relative string contains but does not begin with a forward or back slash. See the test added in this PR for an example URI. The fix is to check the scheme length after validating that the potential scheme contains only legal characters (ie, not a forward or back slash). This keeps us from running into the situation above, where the relative URI contains a colon that is unambiguously not a scheme separator because the ""scheme"" is actually just a path that contains a colon. This fix improves the correctness of our relative path parsing at the cost of an additional stacalloc in the case where the relative part of the URI is really an absolute URI with a scheme length >= 1024. Fixes: #29011 Details below: --------- When we construct an absolute URI from a relative URI, the first thing we try to do is parse the relative URI as an absolute URI. That parsing process returns an error code that we use to determine what happens next. The parsing errors are as follows: https://github.com/dotnet/corefx/blob/bffef76f6af208e2042a2f27bc081ee908bb390b/src/System.Private.Uri/src/System/UriEnumTypes.cs#L67-L93 If we successfully parse an absolute URI (error = None), we return that URI and ignore the absolute URI we were passed. That might seem a little odd, but it's a useful behavior in practice. If we get an error that is less than LastRelativeUriOkErrIndex(see the code above), we attempt to create a relative URI from the string and then root it with the absolute URI provided. If we return any other error, we believe that the string is neither a valid relative or absolute URI and throw an exception. In this case, PrivateParseMinimal is returning the error SchemeLimit, which indicates that we have too large of a scheme. As documented in the code above, this isn't considered a recoverable error. The relative string provided has some characters that are clearly invalid in a scheme, so the real error we should be returning from TryParse is InvalidScheme. Since InvalidScheme is less than LastRelativeUriOkErrIndex, we will then be able to create a relative URI. Fixing the returned parsing error allows this URI to be constructed successfully."

an error with system.data

yada yada yada

The current Bmi2.MultiplyNoFlags API follows the C/C++ intrinsic design that returns lower half of the result and stores the higher half in memory via a pointer of out argument. According to feedback dotnet/coreclr#18712 (comment), the API returning higher half is more useful for developers and simpler to implement and optimize for compiler writers. So, we suggest changing the API to:

public static unsafe uint MultiplyNoFlags(uint left, uint right);
public static unsafe uint MultiplyNoFlags(uint left, uint right, uint* lower);

higher half in memory via a pointer of out argument. According to feedback dotnet/coreclr#18712 (comment), the API returning higher half is more useful for developers and simpler to implement and optimize for compiler writers. So, we suggest changing the API to:

public static unsafe uint MultiplyNoFlags(uint left, uint right);
public static unsafe uint MultiplyNoFlags(uint left, uint right, uint* lower);

Running the [Tensorflow sample]
(https://github.com/dotnet/machinelearning-samples/tree/master/samples/csharp/examples/DeepLearning_TensorFlowMLNETInceptionv3ModelScoring) prints a bunch of warnings on the transforms it uses.

They are discouraging to sample users :)

List of warnings for that sample:
CacheClassesFromAssembly: can't instantiate loadable class IDataView with name KeyToVectorTransform
CacheClassesFromAssembly: can't instantiate loadable class IDataView with name TermTransform
CacheClassesFromAssembly: can't map name ToVector to IDataTransform, already mapped to IDataTransform
CacheClassesFromAssembly: can't instantiate loadable class IDataView with name KeyToBinaryTransform

You can extract weights out of the MulticlassLogisticRegressionPredictor now:

MulticlassLogisticRegressionPredictor predictor;
VBuffer[] weights = null;
predictor.GetWeights(ref weights, out int numClasses);

There is no way to extract _biases out of the predictor though. And we should have a way.
There's an internal method that accessed biases, but no public method to do so.

The current Bmi2.MultiplyNoFlags API follows the C/C++ intrinsic design that returns lower half of the result and stores the higher half in memory via a pointer of out argument. According to feedback dotnet/coreclr#18712 (comment), the API returning higher half is more useful for developers and simpler to implement and optimize for compiler writers. So, we suggest changing the API to:

public static unsafe uint MultiplyNoFlags(uint left, uint right);
public static unsafe uint MultiplyNoFlags(uint left, uint right, uint* lower);

The definition for LightGBM in ‘Machine Learning lingo’ is: A high-performance gradient boosting framework based on decision tree algorithms.