#r "nuget:FSharp.Stats"
#r "nuget: Microsoft.ML, 1.7.*"
#r "nuget: Microsoft.ML.FastTree"
#r "nuget: FSharp.Data, 5.0.2"
#r "nuget: Plotly.NET, 3.*"
#r "nuget: Plotly.NET.Interactive, 3.*"

#time "on"

open System
open System.IO
open System.IO.Compression
open System.Text.Json
open System.Net
open FSharp.Data
open FSharp.Stats
open Plotly.NET
open Microsoft.ML
open Microsoft.ML.Data
open Microsoft.ML.Transforms.Text

Environment.CurrentDirectory <- __SOURCE_DIRECTORY__

let download (inputUrl:string) (outputFile:string) =
    Directory.CreateDirectory(Path.GetDirectoryName(outputFile)) |> ignore
    if IO.File.Exists(outputFile) then
        printfn $"The file {outputFile} already exists. Skipping download" 
    else
        let web = Http.RequestStream(inputUrl)
        use fileStream = IO.File.Create(outputFile)
        web.ResponseStream.CopyTo(fileStream)
        fileStream.Close()

// Decompress a gzip file
let gunzip (inputFile:string) (outputFile:string) =
    Directory.CreateDirectory(Path.GetDirectoryName(outputFile)) |> ignore
    if File.Exists(outputFile) then File.Delete(outputFile)
    use inputStream = File.OpenRead(inputFile)
    use outputStream = File.Create(outputFile)
    use gzipStream = new GZipStream(inputStream, CompressionMode.Decompress)
    gzipStream.CopyTo(outputStream)

let nq100FullUrl = "https://www.dropbox.com/s/izcsjp06lgwbauu/Nasdaq100CallFull.json.gz?dl=1"
let dataFolder = "data"
let nqFullFile = Path.Combine(dataFolder, "Nasdaq100CallFull.json")
let nq100FullFileGz = nqFullFile.Replace(".json", ".json.gz")

download nq100FullUrl nq100FullFileGz
gunzip nq100FullFileGz nqFullFile

// Types - Earnings Announcement
type CallId =
    { Ticker: string
      Exchange: string
      FiscalQuarter: int
      Date: DateTime }

type CallFull = 
    { CallId: CallId
      Header: string
      PreparedRemarks: string
      QuestionsAndAnswers: string
      Label: float }

let nq100Full = 
    File.ReadAllText(nqFullFile)
    |> JsonSerializer.Deserialize<List<CallFull>>

let tsla2021q4 =
    nq100Full
    |> List.find (fun x -> 
        x.CallId.Ticker = "TSLA" &&
        x.CallId.Date.Year = 2021 && 
        x.CallId.FiscalQuarter = 4)

let elonStarts = tsla2021q4.PreparedRemarks.IndexOf("Elon has some opening remarks. Elon?")
tsla2021q4.PreparedRemarks[elonStarts..elonStarts+1_000]

let firstAnalystQuestion = tsla2021q4.QuestionsAndAnswers.IndexOf("Please go ahead.")
tsla2021q4.QuestionsAndAnswers[firstAnalystQuestion..firstAnalystQuestion+1_000]

tsla2021q4.Label

let preparedLengthChart =
    nq100Full
    |> Seq.map (fun x -> x.PreparedRemarks.Split([|' '|]).Length)
    |> Chart.Histogram
    |> Chart.withTraceInfo(Name = "Prepared Remarks Length")


let qaLengthChart =
    nq100Full
    |> Seq.map (fun x -> x.QuestionsAndAnswers.Split([|' '|]).Length)
    |> Chart.Histogram
    |> Chart.withTraceInfo(Name = "Q&A Length")

let returnChart =
    nq100Full
    |> Seq.map (fun x -> x.Label)
    |> Chart.Histogram
    |> Chart.withTraceInfo(Name = "Return")

[ preparedLengthChart; qaLengthChart; returnChart ]
|> Chart.SingleStack()

[<CLIMutable>]
type BinarySentimentInput =
    { Label: bool
      Text: string }

[<CLIMutable>]
type BinarySentimentOutput =
    { PredictedLabel: bool
      Probability: single
      Score: single }

// ML.NET context
let ctx = new MLContext(seed = 1)

let nq100FullSentiment =
    nq100Full
    |> Seq.map (fun x ->
        { Label = x.Label > 0.0
          Text =  x.QuestionsAndAnswers })
    |> ctx.Data.LoadFromEnumerable    
    

let nq100FullSplits =
    ctx.Data.TrainTestSplit(nq100FullSentiment,
                            testFraction = 0.2, 
                            seed = 1)

let featurizePipeline = 
    ctx.Transforms.Text.FeaturizeText(
        outputColumnName = "Features", 
        inputColumnName = "Text")

let treeTrainer = 
    ctx.BinaryClassification.Trainers.FastTree(
        labelColumnName = "Label",
        featureColumnName = "Features")

let treePipeline = featurizePipeline.Append(treeTrainer)

let binaryTreeModel = treePipeline.Fit(nq100FullSplits.TrainSet)

let computeMetrics (model:TransformerChain<_>) iDataView =
    let predictions = model.Transform iDataView
    ctx.BinaryClassification
        .Evaluate(predictions, 
                  labelColumnName = "Label",
                  scoreColumnName = "Score")

let printBinaryClassificationMetrics name (metrics : CalibratedBinaryClassificationMetrics) =
    printfn"************************************************************"
    printfn"*       Metrics for %s binary classification model      " name
    printfn"*-----------------------------------------------------------"
    printfn"*       Accuracy:                             %.2f%%" (metrics.Accuracy * 100.)
    printfn"*       Area Under Curve:                     %.2f%%" (metrics.AreaUnderRocCurve * 100.)
    printfn"*       Area under Precision recall Curve:    %.2f%%" (metrics.AreaUnderPrecisionRecallCurve * 100.)
    printfn"*       F1Score:                              %.2f%%" (metrics.F1Score * 100.)
    printfn"*       LogLogg:                              %.2f%%" (metrics.LogLoss)
    printfn"*       LogLossreduction:                     %.2f%%" (metrics.LogLossReduction)
    printfn"*       PositivePrecision:                    %.2f" (metrics.PositivePrecision)
    printfn"*       PositiveRecall:                       %.2f" (metrics.PositiveRecall)
    printfn"*       NegativePrecision:                    %.2f" (metrics.NegativePrecision)
    printfn"*       NegativeRecall:                       %.2f" (metrics.NegativeRecall)
    printfn"*\n-----------------------------------------------------------"
    printfn"*      Confusion matrix for %s binary classification model      " name
    printfn"*-----------------------------------------------------------"
    printfn $"{(metrics.ConfusionMatrix.GetFormattedConfusionTable())}"
    printfn"************************************************************"

nq100FullSplits.TrainSet 
|> computeMetrics binaryTreeModel
|> printBinaryClassificationMetrics "Train set"

nq100FullSplits.TestSet 
|> computeMetrics binaryTreeModel
|> printBinaryClassificationMetrics "Test set"

let downcastPipeline (pipeline : IEstimator<'a>) =
    match pipeline with
    | :? IEstimator<ITransformer> as p -> p
    | _ -> failwith "The pipeline has to be an instance of IEstimator<ITransformer>."

//https://docs.microsoft.com/en-us/dotnet/machine-learning/how-to-guides/train-machine-learning-model-cross-validation-ml-net
let cvResults = 
    ctx.BinaryClassification
        .CrossValidate(data = nq100FullSentiment, 
                       estimator = downcastPipeline treePipeline,
                       numberOfFolds=5,
                       seed = 1) 

cvResults
|> Seq.iteri (fun i x -> printfn $"Fold {i+1}: {x.Metrics.Accuracy}")

cvResults
|> Seq.averageBy (fun  x -> x.Metrics.Accuracy)
|> printfn "Average accuracy: %.2f%%"

let textFeatureOptions =
    // Set up word n-gram options
    // https://docs.microsoft.com/en-us/dotnet/api/microsoft.ml.transforms.text.wordbagestimator.options?view=ml-dotnet
    let wordOptions = new WordBagEstimator.Options()
    wordOptions.NgramLength <- 2
    wordOptions.MaximumNgramsCount <- [| for i = 0 to wordOptions.NgramLength-1 do 1_000 |]

    // Set up stop word options
    // https://docs.microsoft.com/en-us/dotnet/api/microsoft.ml.transforms.text.textfeaturizingestimator.options.stopwordsremoveroptions?view=ml-dotnet
    let stopOptions = new StopWordsRemovingEstimator.Options()

    // Set up char n-gram options
    // https://docs.microsoft.com/en-us/dotnet/api/microsoft.ml.transforms.text.charbagestimator.options?view=ml-dotnet
    let charOptions = null //new WordBagEstimator.Options()                                        
    
    // Set the text options
    // https://docs.microsoft.com/en-us/dotnet/api/microsoft.ml.transforms.text.textfeaturizingestimator?view=ml-dotnet
    let textOptions = new Transforms.Text.TextFeaturizingEstimator.Options()
    textOptions.CharFeatureExtractor <- charOptions
    textOptions.WordFeatureExtractor <- wordOptions
    textOptions.StopWordsRemoverOptions <- stopOptions
    
    // return the text options
    textOptions

let featurizePipelineSimple = 
    ctx.Transforms.Text
        .FeaturizeText("Features",
                       "Text", 
                       options=textFeatureOptions)

let treeSimple = featurizePipelineSimple.Append(treeTrainer)

let cvSimple = 
    ctx.BinaryClassification
        .CrossValidate(data = nq100FullSentiment, 
                       estimator = downcastPipeline treeSimple,
                       numberOfFolds=5,
                       seed = 1) 

cvSimple
|> Seq.iteri (fun i x -> printfn $"Fold {i+1}: {x.Metrics.Accuracy}")

cvSimple
|> Seq.averageBy (fun  x -> x.Metrics.Accuracy)
|> printfn "Average accuracy: %.2f%%"

(* That's pretty good, and much faster that the default featurization pipeline. Let's use that going forward.

Let's try a model on prepared remarks.
*)

let nq100PreparedSentiment =
    nq100Full
    |> Seq.map (fun x ->
        { Label = x.Label > 0.0
          Text =  x.PreparedRemarks })
    |> ctx.Data.LoadFromEnumerable    

let cvPreparedRemarks = 
    ctx.BinaryClassification
        .CrossValidate(data = nq100PreparedSentiment, 
                       estimator = downcastPipeline treeSimple,
                       numberOfFolds=5, 
                       seed = 1)

cvPreparedRemarks
|> Seq.iteri (fun i x -> printfn $"Fold {i+1}: {x.Metrics.Accuracy}")

cvPreparedRemarks
|> Seq.averageBy (fun  x -> x.Metrics.Accuracy)
|> printfn "Average accuracy: %.2f%%"

let nq100ExtremeSentiment =
    nq100Full
    |> Seq.filter (fun x -> (abs x.Label) > 0.075)
    |> Seq.map (fun x ->
        { Label = x.Label > 0.0
          Text =  x.QuestionsAndAnswers })
    |> ctx.Data.LoadFromEnumerable    

let cvExtreme = 
    ctx.BinaryClassification
        .CrossValidate(data = nq100ExtremeSentiment, 
                       estimator = downcastPipeline treeSimple,
                       numberOfFolds=5, 
                       seed = 1)

cvExtreme
|> Seq.iteri (fun i x -> printfn $"Fold {i+1}: {x.Metrics.Accuracy}")

cvExtreme
|> Seq.averageBy (fun  x -> x.Metrics.Accuracy)
|> printfn "Average accuracy: %.2f%%"

[<CLIMutable>]
type MulticlassSentimentInput =
    { Label: string
      Text: string }

[<CLIMutable>]
type MulticlassSentimentOutput =
    { PredictedLabel: string
      Probability: single
      Score: single }

let nq100MulticlassSentiment =
    nq100Full
    |> Seq.map (fun x ->
        { Label = 
            if x.Label < -0.05 then "neg"
            elif x.Label > 0.05 then "pos"
            else "neutral"
          Text =  x.QuestionsAndAnswers })
    |> ctx.Data.LoadFromEnumerable    

let nq100MulticlassSplits =
    ctx.Data.TrainTestSplit(nq100MulticlassSentiment,
                            testFraction = 0.2, 
                            seed = 1)

let multiTrainer = 
    ctx.MulticlassClassification.Trainers.SdcaMaximumEntropy(
        labelColumnName = "Label",
        featureColumnName = "Features")

let multiPipeline =
    // Estimator chain seems to speed this up.
    EstimatorChain()
        .Append(featurizePipelineSimple)
        // for multiclass, you have to put the label in a keyvalue store
        .Append(ctx.Transforms.Conversion.MapValueToKey("Label"))
        .AppendCacheCheckpoint(ctx)
        .Append(multiTrainer)

let multiModel = multiPipeline.Fit(nq100MulticlassSplits.TrainSet)

let computeMultiClassMetrics (model:TransformerChain<_>) iDataView =
    let predictions = model.Transform iDataView
    ctx.MulticlassClassification
        .Evaluate(predictions, 
                  labelColumnName = "Label",
                  scoreColumnName = "Score")

let printMultiClassClassificationMetrics name (metrics : MulticlassClassificationMetrics) =
    printfn "************************************************************"
    printfn "*    Metrics for %s multi-class classification model   " name
    printfn "*-----------------------------------------------------------"
    printfn "    AccuracyMacro = %.4f, a value between 0 and 1, the closer to 1, the better" metrics.MacroAccuracy
    printfn "    AccuracyMicro = %.4f, a value between 0 and 1, the closer to 1, the better" metrics.MacroAccuracy
    printfn "    LogLoss = %.4f, the closer to 0, the better" metrics.LogLoss
    printfn "    LogLoss for class 1 = %.4f, the closer to 0, the better" metrics.PerClassLogLoss.[0]
    printfn "    LogLoss for class 2 = %.4f, the closer to 0, the better" metrics.PerClassLogLoss.[1]
    printfn "    LogLoss for class 3 = %.4f, the closer to 0, the better" metrics.PerClassLogLoss.[2]
    printfn "************************************************************"
    printfn $"{metrics.ConfusionMatrix.GetFormattedConfusionTable()}"

nq100MulticlassSplits.TrainSet
|> computeMultiClassMetrics multiModel
|> printMultiClassClassificationMetrics "Multi-class: TrainSet"

nq100MulticlassSplits.TestSet
|> computeMultiClassMetrics multiModel
|> printMultiClassClassificationMetrics "Multi-class: TestSet"

let binaryTreePredictions = 
    ctx.Model.CreatePredictionEngine<BinarySentimentInput, BinarySentimentOutput>(binaryTreeModel)

let sampleNegCall :BinarySentimentInput = { 
    Label = false
    Text = "Our earnings are terrible. All our customers are leaving 
    and are profits and free cash flow is falling. "}

binaryTreePredictions.Predict(sampleNegCall)

let samplePosCall: BinarySentimentInput = { 
    Label = true
    Text = "We had very high free cash flow. Sales were up, profits were up, 
    we paid down debt. We expect to beat expectations."}

binaryTreePredictions.Predict(samplePosCall)

namespace System

namespace System.IO

namespace System.IO.Compression

namespace System.Text

namespace System.Text.Json

namespace System.Net

Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp

Multiple items
namespace FSharp.Data

--------------------
namespace Microsoft.FSharp.Data

namespace FSharp.Stats

namespace Plotly

namespace Plotly.NET

namespace Microsoft

namespace Microsoft.ML

namespace Microsoft.ML.Data

namespace Microsoft.ML.Transforms

namespace Microsoft.ML.Transforms.Text

type Environment = static member Exit: exitCode: int -> unit static member ExpandEnvironmentVariables: name: string -> string static member FailFast: message: string -> unit + 1 overload static member GetCommandLineArgs: unit -> string array static member GetEnvironmentVariable: variable: string -> string + 1 overload static member GetEnvironmentVariables: unit -> IDictionary + 1 overload static member GetFolderPath: folder: SpecialFolder -> string + 1 overload static member GetLogicalDrives: unit -> string array static member SetEnvironmentVariable: variable: string * value: string -> unit + 1 overload static member CommandLine: string ...
<summary>Provides information about, and means to manipulate, the current environment and platform. This class cannot be inherited.</summary>

property Environment.CurrentDirectory: string with get, set
<summary>Gets or sets the fully qualified path of the current working directory.</summary>
<exception cref="T:System.ArgumentException">Attempted to set to an empty string ("").</exception>
<exception cref="T:System.ArgumentNullException">Attempted to set to <see langword="null" />.</exception>
<exception cref="T:System.IO.IOException">An I/O error occurred.</exception>
<exception cref="T:System.IO.DirectoryNotFoundException">Attempted to set a local path that cannot be found.</exception>
<exception cref="T:System.Security.SecurityException">The caller does not have the appropriate permission.</exception>
<returns>The directory path.</returns>

val download: inputUrl: string -> outputFile: string -> unit

val inputUrl: string

Multiple items
val string: value: 'T -> string

--------------------
type string = String

val outputFile: string

type Directory = static member CreateDirectory: path: string -> DirectoryInfo + 1 overload static member CreateSymbolicLink: path: string * pathToTarget: string -> FileSystemInfo static member CreateTempSubdirectory: ?prefix: string -> DirectoryInfo static member Delete: path: string -> unit + 1 overload static member EnumerateDirectories: path: string -> IEnumerable<string> + 3 overloads static member EnumerateFileSystemEntries: path: string -> IEnumerable<string> + 3 overloads static member EnumerateFiles: path: string -> IEnumerable<string> + 3 overloads static member Exists: path: string -> bool static member GetCreationTime: path: string -> DateTime static member GetCreationTimeUtc: path: string -> DateTime ...
<summary>Exposes static methods for creating, moving, and enumerating through directories and subdirectories. This class cannot be inherited.</summary>

Directory.CreateDirectory(path: string) : DirectoryInfo
Directory.CreateDirectory(path: string, unixCreateMode: UnixFileMode) : DirectoryInfo

type Path = static member ChangeExtension: path: string * extension: string -> string static member Combine: path1: string * path2: string -> string + 3 overloads static member EndsInDirectorySeparator: path: ReadOnlySpan<char> -> bool + 1 overload static member Exists: path: string -> bool static member GetDirectoryName: path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload static member GetExtension: path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload static member GetFileName: path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload static member GetFileNameWithoutExtension: path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload static member GetFullPath: path: string -> string + 1 overload static member GetInvalidFileNameChars: unit -> char array ...
<summary>Performs operations on <see cref="T:System.String" /> instances that contain file or directory path information. These operations are performed in a cross-platform manner.</summary>

Path.GetDirectoryName(path: string) : string
Path.GetDirectoryName(path: ReadOnlySpan<char>) : ReadOnlySpan<char>

val ignore: value: 'T -> unit

type File = static member AppendAllLines: path: string * contents: IEnumerable<string> -> unit + 1 overload static member AppendAllLinesAsync: path: string * contents: IEnumerable<string> * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload static member AppendAllText: path: string * contents: string -> unit + 1 overload static member AppendAllTextAsync: path: string * contents: string * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload static member AppendText: path: string -> StreamWriter static member Copy: sourceFileName: string * destFileName: string -> unit + 1 overload static member Create: path: string -> FileStream + 2 overloads static member CreateSymbolicLink: path: string * pathToTarget: string -> FileSystemInfo static member CreateText: path: string -> StreamWriter static member Decrypt: path: string -> unit ...
<summary>Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.</summary>

File.Exists(path: string) : bool

val printfn: format: Printf.TextWriterFormat<'T> -> 'T

val web: HttpResponseWithStream

Multiple items
namespace System.Net.Http

--------------------
type Http = static member AsyncRequest: url: string * [<Optional>] ?query: (string * string) list * [<Optional>] ?headers: (string * string) seq * [<Optional>] ?httpMethod: string * [<Optional>] ?body: HttpRequestBody * [<Optional>] ?cookies: (string * string) seq * [<Optional>] ?cookieContainer: CookieContainer * [<Optional>] ?silentHttpErrors: bool * [<Optional>] ?silentCookieErrors: bool * [<Optional>] ?responseEncodingOverride: string * [<Optional>] ?customizeHttpRequest: (HttpWebRequest -> HttpWebRequest) * [<Optional>] ?timeout: int -> Async<HttpResponse> static member AsyncRequestStream: url: string * [<Optional>] ?query: (string * string) list * [<Optional>] ?headers: (string * string) seq * [<Optional>] ?httpMethod: string * [<Optional>] ?body: HttpRequestBody * [<Optional>] ?cookies: (string * string) seq * [<Optional>] ?cookieContainer: CookieContainer * [<Optional>] ?silentHttpErrors: bool * [<Optional>] ?silentCookieErrors: bool * [<Optional>] ?customizeHttpRequest: (HttpWebRequest -> HttpWebRequest) * [<Optional>] ?timeout: int -> Async<HttpResponseWithStream> static member AsyncRequestString: url: string * [<Optional>] ?query: (string * string) list * [<Optional>] ?headers: (string * string) seq * [<Optional>] ?httpMethod: string * [<Optional>] ?body: HttpRequestBody * [<Optional>] ?cookies: (string * string) seq * [<Optional>] ?cookieContainer: CookieContainer * [<Optional>] ?silentHttpErrors: bool * [<Optional>] ?silentCookieErrors: bool * [<Optional>] ?responseEncodingOverride: string * [<Optional>] ?customizeHttpRequest: (HttpWebRequest -> HttpWebRequest) * [<Optional>] ?timeout: int -> Async<string> static member Request: url: string * [<Optional>] ?query: (string * string) list * [<Optional>] ?headers: (string * string) seq * [<Optional>] ?httpMethod: string * [<Optional>] ?body: HttpRequestBody * [<Optional>] ?cookies: (string * string) seq * [<Optional>] ?cookieContainer: CookieContainer * [<Optional>] ?silentHttpErrors: bool * [<Optional>] ?silentCookieErrors: bool * [<Optional>] ?responseEncodingOverride: string * [<Optional>] ?customizeHttpRequest: (HttpWebRequest -> HttpWebRequest) * [<Optional>] ?timeout: int -> HttpResponse static member RequestStream: url: string * [<Optional>] ?query: (string * string) list * [<Optional>] ?headers: (string * string) seq * [<Optional>] ?httpMethod: string * [<Optional>] ?body: HttpRequestBody * [<Optional>] ?cookies: (string * string) seq * [<Optional>] ?cookieContainer: CookieContainer * [<Optional>] ?silentHttpErrors: bool * [<Optional>] ?silentCookieErrors: bool * [<Optional>] ?customizeHttpRequest: (HttpWebRequest -> HttpWebRequest) * [<Optional>] ?timeout: int -> HttpResponseWithStream static member RequestString: url: string * [<Optional>] ?query: (string * string) list * [<Optional>] ?headers: (string * string) seq * [<Optional>] ?httpMethod: string * [<Optional>] ?body: HttpRequestBody * [<Optional>] ?cookies: (string * string) seq * [<Optional>] ?cookieContainer: CookieContainer * [<Optional>] ?silentHttpErrors: bool * [<Optional>] ?silentCookieErrors: bool * [<Optional>] ?responseEncodingOverride: string * [<Optional>] ?customizeHttpRequest: (HttpWebRequest -> HttpWebRequest) * [<Optional>] ?timeout: int -> string
<summary> Utilities for working with network via HTTP. Includes methods for downloading resources with specified headers, query parameters and HTTP body </summary>

static member Http.RequestStream: url: string * [<Runtime.InteropServices.Optional>] ?query: (string * string) list * [<Runtime.InteropServices.Optional>] ?headers: (string * string) seq * [<Runtime.InteropServices.Optional>] ?httpMethod: string * [<Runtime.InteropServices.Optional>] ?body: HttpRequestBody * [<Runtime.InteropServices.Optional>] ?cookies: (string * string) seq * [<Runtime.InteropServices.Optional>] ?cookieContainer: CookieContainer * [<Runtime.InteropServices.Optional>] ?silentHttpErrors: bool * [<Runtime.InteropServices.Optional>] ?silentCookieErrors: bool * [<Runtime.InteropServices.Optional>] ?customizeHttpRequest: (HttpWebRequest -> HttpWebRequest) * [<Runtime.InteropServices.Optional>] ?timeout: int -> HttpResponseWithStream

val fileStream: FileStream

File.Create(path: string) : FileStream
File.Create(path: string, bufferSize: int) : FileStream
File.Create(path: string, bufferSize: int, options: FileOptions) : FileStream

HttpResponseWithStream.ResponseStream: Stream

Stream.CopyTo(destination: Stream) : unit
Stream.CopyTo(destination: Stream, bufferSize: int) : unit

Stream.Close() : unit

val gunzip: inputFile: string -> outputFile: string -> unit

val inputFile: string

File.Delete(path: string) : unit

val inputStream: FileStream

File.OpenRead(path: string) : FileStream

val outputStream: FileStream

val gzipStream: GZipStream

Multiple items
type GZipStream = inherit Stream new: stream: Stream * compressionLevel: CompressionLevel -> unit + 3 overloads member BeginRead: buffer: byte array * offset: int * count: int * asyncCallback: AsyncCallback * asyncState: obj -> IAsyncResult member BeginWrite: buffer: byte array * offset: int * count: int * asyncCallback: AsyncCallback * asyncState: obj -> IAsyncResult member CopyTo: destination: Stream * bufferSize: int -> unit member CopyToAsync: destination: Stream * bufferSize: int * cancellationToken: CancellationToken -> Task member DisposeAsync: unit -> ValueTask member EndRead: asyncResult: IAsyncResult -> int member EndWrite: asyncResult: IAsyncResult -> unit member Flush: unit -> unit ...
<summary>Provides methods and properties used to compress and decompress streams by using the GZip data format specification.</summary>

--------------------
GZipStream(stream: Stream, compressionLevel: CompressionLevel) : GZipStream
GZipStream(stream: Stream, mode: CompressionMode) : GZipStream
GZipStream(stream: Stream, compressionLevel: CompressionLevel, leaveOpen: bool) : GZipStream
GZipStream(stream: Stream, mode: CompressionMode, leaveOpen: bool) : GZipStream

[<Struct>] type CompressionMode = | Decompress = 0 | Compress = 1
<summary>Specifies whether to compress data to or decompress data from the underlying stream.</summary>

field CompressionMode.Decompress: CompressionMode = 0

Stream.CopyTo(destination: Stream) : unit
GZipStream.CopyTo(destination: Stream, bufferSize: int) : unit

val nq100FullUrl: string

val dataFolder: string

val nqFullFile: string

Path.Combine([<ParamArray>] paths: string array) : string
Path.Combine(path1: string, path2: string) : string
Path.Combine(path1: string, path2: string, path3: string) : string
Path.Combine(path1: string, path2: string, path3: string, path4: string) : string

val nq100FullFileGz: string

String.Replace(oldValue: string, newValue: string) : string
String.Replace(oldChar: char, newChar: char) : string
String.Replace(oldValue: string, newValue: string, comparisonType: StringComparison) : string
String.Replace(oldValue: string, newValue: string, ignoreCase: bool, culture: Globalization.CultureInfo) : string

type CallId = { Ticker: string Exchange: string FiscalQuarter: int Date: DateTime }

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

Multiple items
[<Struct>] type DateTime = new: year: int * month: int * day: int -> unit + 16 overloads member Add: value: TimeSpan -> DateTime member AddDays: value: float -> DateTime member AddHours: value: float -> DateTime member AddMicroseconds: value: float -> DateTime member AddMilliseconds: value: float -> DateTime member AddMinutes: value: float -> DateTime member AddMonths: months: int -> DateTime member AddSeconds: value: float -> DateTime member AddTicks: value: int64 -> DateTime ...
<summary>Represents an instant in time, typically expressed as a date and time of day.</summary>

--------------------
DateTime ()
   (+0 other overloads)
DateTime(ticks: int64) : DateTime
   (+0 other overloads)
DateTime(ticks: int64, kind: DateTimeKind) : DateTime
   (+0 other overloads)
DateTime(date: DateOnly, time: TimeOnly) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int) : DateTime
   (+0 other overloads)
DateTime(date: DateOnly, time: TimeOnly, kind: DateTimeKind) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, calendar: Globalization.Calendar) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, kind: DateTimeKind) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, calendar: Globalization.Calendar) : DateTime
   (+0 other overloads)

type CallFull = { CallId: CallId Header: string PreparedRemarks: string QuestionsAndAnswers: string Label: float }

Multiple items
val float: value: 'T -> float (requires member op_Explicit)

--------------------
type float = Double

--------------------
type float<'Measure> = float

val nq100Full: List<CallFull>

File.ReadAllText(path: string) : string
File.ReadAllText(path: string, encoding: Text.Encoding) : string

type JsonSerializer = static member Deserialize: utf8Json: Stream * jsonTypeInfo: JsonTypeInfo -> obj + 39 overloads static member DeserializeAsync: utf8Json: Stream * jsonTypeInfo: JsonTypeInfo * ?cancellationToken: CancellationToken -> ValueTask<obj> + 4 overloads static member DeserializeAsyncEnumerable<'TValue> : utf8Json: Stream * ?options: JsonSerializerOptions * ?cancellationToken: CancellationToken -> IAsyncEnumerable<'TValue> + 1 overload static member Serialize: utf8Json: Stream * value: obj * jsonTypeInfo: JsonTypeInfo -> unit + 14 overloads static member SerializeAsync: utf8Json: Stream * value: obj * jsonTypeInfo: JsonTypeInfo * ?cancellationToken: CancellationToken -> Task + 4 overloads static member SerializeToDocument: value: obj * jsonTypeInfo: JsonTypeInfo -> JsonDocument + 4 overloads static member SerializeToElement: value: obj * jsonTypeInfo: JsonTypeInfo -> JsonElement + 4 overloads static member SerializeToNode: value: obj * jsonTypeInfo: JsonTypeInfo -> JsonNode + 4 overloads static member SerializeToUtf8Bytes: value: obj * jsonTypeInfo: JsonTypeInfo -> byte array + 4 overloads static member IsReflectionEnabledByDefault: bool
<summary>Provides functionality to serialize objects or value types to JSON and to deserialize JSON into objects or value types.</summary>

JsonSerializer.Deserialize<'TValue>(reader: byref<Utf8JsonReader>, jsonTypeInfo: Serialization.Metadata.JsonTypeInfo<'TValue>) : 'TValue
   (+0 other overloads)
JsonSerializer.Deserialize<'TValue>(reader: byref<Utf8JsonReader>, ?options: JsonSerializerOptions) : 'TValue
   (+0 other overloads)
JsonSerializer.Deserialize<'TValue>(node: Nodes.JsonNode, jsonTypeInfo: Serialization.Metadata.JsonTypeInfo<'TValue>) : 'TValue
   (+0 other overloads)
JsonSerializer.Deserialize<'TValue>(node: Nodes.JsonNode, ?options: JsonSerializerOptions) : 'TValue
   (+0 other overloads)
JsonSerializer.Deserialize<'TValue>(element: JsonElement, jsonTypeInfo: Serialization.Metadata.JsonTypeInfo<'TValue>) : 'TValue
   (+0 other overloads)
JsonSerializer.Deserialize<'TValue>(element: JsonElement, ?options: JsonSerializerOptions) : 'TValue
   (+0 other overloads)
JsonSerializer.Deserialize<'TValue>(document: JsonDocument, jsonTypeInfo: Serialization.Metadata.JsonTypeInfo<'TValue>) : 'TValue
   (+0 other overloads)
JsonSerializer.Deserialize<'TValue>(document: JsonDocument, ?options: JsonSerializerOptions) : 'TValue
   (+0 other overloads)
JsonSerializer.Deserialize<'TValue>(json: string, jsonTypeInfo: Serialization.Metadata.JsonTypeInfo<'TValue>) : 'TValue
   (+0 other overloads)
JsonSerializer.Deserialize<'TValue>(json: string, ?options: JsonSerializerOptions) : 'TValue
   (+0 other overloads)

Multiple items
module List from FSharp.Stats
<summary> Module to compute common statistical measure on list </summary>

--------------------
module List from Microsoft.FSharp.Collections

--------------------
type List = new: unit -> List static member geomspace: start: float * stop: float * num: int * ?IncludeEndpoint: bool -> float list static member linspace: start: float * stop: float * num: int * ?IncludeEndpoint: bool -> float list

--------------------
type List<'T> = | op_Nil | op_ColonColon of Head: 'T * Tail: 'T list interface IReadOnlyList<'T> interface IReadOnlyCollection<'T> interface IEnumerable interface IEnumerable<'T> member GetReverseIndex: rank: int * offset: int -> int member GetSlice: startIndex: int option * endIndex: int option -> 'T list static member Cons: head: 'T * tail: 'T list -> 'T list member Head: 'T member IsEmpty: bool member Item: index: int -> 'T with get ...

--------------------
new: unit -> List

val tsla2021q4: CallFull

val find: predicate: ('T -> bool) -> list: 'T list -> 'T

val x: CallFull

CallFull.CallId: CallId

CallId.Ticker: string

CallId.Date: DateTime

property DateTime.Year: int with get
<summary>Gets the year component of the date represented by this instance.</summary>
<returns>The year, between 1 and 9999.</returns>

CallId.FiscalQuarter: int

val elonStarts: int

CallFull.PreparedRemarks: string

String.IndexOf(value: string) : int
String.IndexOf(value: char) : int
String.IndexOf(value: string, comparisonType: StringComparison) : int
String.IndexOf(value: string, startIndex: int) : int
String.IndexOf(value: char, comparisonType: StringComparison) : int
String.IndexOf(value: char, startIndex: int) : int
String.IndexOf(value: string, startIndex: int, comparisonType: StringComparison) : int
String.IndexOf(value: string, startIndex: int, count: int) : int
String.IndexOf(value: char, startIndex: int, count: int) : int
String.IndexOf(value: string, startIndex: int, count: int, comparisonType: StringComparison) : int

val firstAnalystQuestion: int

CallFull.QuestionsAndAnswers: string

CallFull.Label: float

val preparedLengthChart: GenericChart.GenericChart

Multiple items
module Seq from FSharp.Stats
<summary> Module to compute common statistical measure </summary>

--------------------
module Seq from Microsoft.FSharp.Collections

--------------------
type Seq = new: unit -> Seq static member geomspace: start: float * stop: float * num: int * ?IncludeEndpoint: bool -> float seq static member linspace: start: float * stop: float * num: int * ?IncludeEndpoint: bool -> float seq

--------------------
new: unit -> Seq

val map: mapping: ('T -> 'U) -> source: 'T seq -> 'U seq

String.Split([<ParamArray>] separator: char array) : string array
String.Split(separator: string array, options: StringSplitOptions) : string array
String.Split(separator: string, ?options: StringSplitOptions) : string array
String.Split(separator: char array, options: StringSplitOptions) : string array
String.Split(separator: char array, count: int) : string array
String.Split(separator: char, ?options: StringSplitOptions) : string array
String.Split(separator: string array, count: int, options: StringSplitOptions) : string array
String.Split(separator: string, count: int, ?options: StringSplitOptions) : string array
String.Split(separator: char array, count: int, options: StringSplitOptions) : string array
String.Split(separator: char, count: int, ?options: StringSplitOptions) : string array

type Chart = static member AnnotatedHeatmap: zData: #('a1 seq) seq * annotationText: #(string seq) seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Name: string * [<Optional; DefaultParameterValue ((null :> obj))>] ?ShowLegend: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?Opacity: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?X: #IConvertible seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?XGap: int * [<Optional; DefaultParameterValue ((null :> obj))>] ?Y: #IConvertible seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?YGap: int * [<Optional; DefaultParameterValue ((null :> obj))>] ?Text: 'a5 * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiText: 'a5 seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?ColorBar: ColorBar * [<Optional; DefaultParameterValue ((null :> obj))>] ?ColorScale: Colorscale * [<Optional; DefaultParameterValue ((null :> obj))>] ?ShowScale: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?ReverseScale: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?ZSmooth: SmoothAlg * [<Optional; DefaultParameterValue ((null :> obj))>] ?Transpose: bool * [<Optional; DefaultParameterValue ((false :> obj))>] ?UseWebGL: bool * [<Optional; DefaultParameterValue ((false :> obj))>] ?ReverseYAxis: bool * [<Optional; DefaultParameterValue ((true :> obj))>] ?UseDefaults: bool -> GenericChart (requires 'a1 :> IConvertible and 'a5 :> IConvertible) + 1 overload static member Area: x: #IConvertible seq * y: #IConvertible seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?ShowMarkers: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?Name: string * [<Optional; DefaultParameterValue ((null :> obj))>] ?ShowLegend: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?Opacity: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiOpacity: float seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Text: 'a2 * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiText: 'a2 seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?TextPosition: TextPosition * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiTextPosition: TextPosition seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerColor: Color * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerColorScale: Colorscale * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerOutline: Line * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerSymbol: MarkerSymbol * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiMarkerSymbol: MarkerSymbol seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Marker: Marker * [<Optional; DefaultParameterValue ((null :> obj))>] ?LineColor: Color * [<Optional; DefaultParameterValue ((null :> obj))>] ?LineColorScale: Colorscale * [<Optional; DefaultParameterValue ((null :> obj))>] ?LineWidth: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?LineDash: DrawingStyle * [<Optional; DefaultParameterValue ((null :> obj))>] ?Line: Line * [<Optional; DefaultParameterValue ((null :> obj))>] ?StackGroup: string * [<Optional; DefaultParameterValue ((null :> obj))>] ?Orientation: Orientation * [<Optional; DefaultParameterValue ((null :> obj))>] ?GroupNorm: GroupNorm * [<Optional; DefaultParameterValue ((null :> obj))>] ?FillColor: Color * [<Optional; DefaultParameterValue ((false :> obj))>] ?UseWebGL: bool * [<Optional; DefaultParameterValue ((true :> obj))>] ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible) + 1 overload static member Bar: values: #IConvertible seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Keys: #IConvertible seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Name: string * [<Optional; DefaultParameterValue ((null :> obj))>] ?ShowLegend: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?Opacity: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiOpacity: float seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Text: 'a2 * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiText: 'a2 seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerColor: Color * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerColorScale: Colorscale * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerOutline: Line * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerPatternShape: PatternShape * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiMarkerPatternShape: PatternShape seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerPattern: Pattern * [<Optional; DefaultParameterValue ((null :> obj))>] ?Marker: Marker * [<Optional; DefaultParameterValue ((null :> obj))>] ?Base: #IConvertible * [<Optional; DefaultParameterValue ((null :> obj))>] ?Width: 'a4 * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiWidth: 'a4 seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?TextPosition: TextPosition * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiTextPosition: TextPosition seq * [<Optional; DefaultParameterValue ((true :> obj))>] ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible and 'a4 :> IConvertible) + 1 overload static member BoxPlot: [<Optional; DefaultParameterValue ((null :> obj))>] ?X: #IConvertible seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Y: #IConvertible seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Name: string * [<Optional; DefaultParameterValue ((null :> obj))>] ?ShowLegend: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?Text: 'a2 * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiText: 'a2 seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?FillColor: Color * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerColor: Color * [<Optional; DefaultParameterValue ((null :> obj))>] ?Marker: Marker * [<Optional; DefaultParameterValue ((null :> obj))>] ?Opacity: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?WhiskerWidth: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?BoxPoints: BoxPoints * [<Optional; DefaultParameterValue ((null :> obj))>] ?BoxMean: BoxMean * [<Optional; DefaultParameterValue ((null :> obj))>] ?Jitter: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?PointPos: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?Orientation: Orientation * [<Optional; DefaultParameterValue ((null :> obj))>] ?OutlineColor: Color * [<Optional; DefaultParameterValue ((null :> obj))>] ?OutlineWidth: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?Outline: Line * [<Optional; DefaultParameterValue ((null :> obj))>] ?AlignmentGroup: string * [<Optional; DefaultParameterValue ((null :> obj))>] ?OffsetGroup: string * [<Optional; DefaultParameterValue ((null :> obj))>] ?Notched: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?NotchWidth: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?QuartileMethod: QuartileMethod * [<Optional; DefaultParameterValue ((true :> obj))>] ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible) + 2 overloads static member Bubble: x: #IConvertible seq * y: #IConvertible seq * sizes: int seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Name: string * [<Optional; DefaultParameterValue ((null :> obj))>] ?ShowLegend: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?Opacity: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiOpacity: float seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Text: 'a2 * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiText: 'a2 seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?TextPosition: TextPosition * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiTextPosition: TextPosition seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerColor: Color * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerColorScale: Colorscale * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerOutline: Line * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerSymbol: MarkerSymbol * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiMarkerSymbol: MarkerSymbol seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Marker: Marker * [<Optional; DefaultParameterValue ((null :> obj))>] ?LineColor: Color * [<Optional; DefaultParameterValue ((null :> obj))>] ?LineColorScale: Colorscale * [<Optional; DefaultParameterValue ((null :> obj))>] ?LineWidth: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?LineDash: DrawingStyle * [<Optional; DefaultParameterValue ((null :> obj))>] ?Line: Line * [<Optional; DefaultParameterValue ((null :> obj))>] ?StackGroup: string * [<Optional; DefaultParameterValue ((null :> obj))>] ?Orientation: Orientation * [<Optional; DefaultParameterValue ((null :> obj))>] ?GroupNorm: GroupNorm * [<Optional; DefaultParameterValue ((false :> obj))>] ?UseWebGL: bool * [<Optional; DefaultParameterValue ((true :> obj))>] ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible) + 1 overload static member Candlestick: ``open`` : #IConvertible seq * high: #IConvertible seq * low: #IConvertible seq * close: #IConvertible seq * x: #IConvertible seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Name: string * [<Optional; DefaultParameterValue ((null :> obj))>] ?ShowLegend: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?Opacity: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?Text: 'a5 * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiText: 'a5 seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Line: Line * [<Optional; DefaultParameterValue ((null :> obj))>] ?IncreasingColor: Color * [<Optional; DefaultParameterValue ((null :> obj))>] ?Increasing: FinanceMarker * [<Optional; DefaultParameterValue ((null :> obj))>] ?DecreasingColor: Color * [<Optional; DefaultParameterValue ((null :> obj))>] ?Decreasing: FinanceMarker * [<Optional; DefaultParameterValue ((null :> obj))>] ?WhiskerWidth: float * [<Optional; DefaultParameterValue ((true :> obj))>] ?UseDefaults: bool -> GenericChart (requires 'a5 :> IConvertible) + 1 overload static member Column: values: #IConvertible seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Keys: #IConvertible seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Name: string * [<Optional; DefaultParameterValue ((null :> obj))>] ?ShowLegend: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?Opacity: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiOpacity: float seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Text: 'a2 * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiText: 'a2 seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerColor: Color * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerColorScale: Colorscale * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerOutline: Line * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerPatternShape: PatternShape * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiMarkerPatternShape: PatternShape seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerPattern: Pattern * [<Optional; DefaultParameterValue ((null :> obj))>] ?Marker: Marker * [<Optional; DefaultParameterValue ((null :> obj))>] ?Base: #IConvertible * [<Optional; DefaultParameterValue ((null :> obj))>] ?Width: 'a4 * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiWidth: 'a4 seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?TextPosition: TextPosition * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiTextPosition: TextPosition seq * [<Optional; DefaultParameterValue ((true :> obj))>] ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible and 'a4 :> IConvertible) + 1 overload static member Contour: zData: #('a1 seq) seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Name: string * [<Optional; DefaultParameterValue ((null :> obj))>] ?ShowLegend: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?Opacity: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?X: #IConvertible seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Y: #IConvertible seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Text: 'a4 * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiText: 'a4 seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?ColorBar: ColorBar * [<Optional; DefaultParameterValue ((null :> obj))>] ?ColorScale: Colorscale * [<Optional; DefaultParameterValue ((null :> obj))>] ?ShowScale: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?ReverseScale: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?Transpose: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?ContourLineColor: Color * [<Optional; DefaultParameterValue ((null :> obj))>] ?ContourLineDash: DrawingStyle * [<Optional; DefaultParameterValue ((null :> obj))>] ?ContourLineSmoothing: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?ContourLine: Line * [<Optional; DefaultParameterValue ((null :> obj))>] ?ContoursColoring: ContourColoring * [<Optional; DefaultParameterValue ((null :> obj))>] ?ContoursOperation: ConstraintOperation * [<Optional; DefaultParameterValue ((null :> obj))>] ?ContoursType: ContourType * [<Optional; DefaultParameterValue ((null :> obj))>] ?ShowContourLabels: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?ContourLabelFont: Font * [<Optional; DefaultParameterValue ((null :> obj))>] ?Contours: Contours * [<Optional; DefaultParameterValue ((null :> obj))>] ?FillColor: Color * [<Optional; DefaultParameterValue ((null :> obj))>] ?NContours: int * [<Optional; DefaultParameterValue ((true :> obj))>] ?UseDefaults: bool -> GenericChart (requires 'a1 :> IConvertible and 'a4 :> IConvertible) static member Funnel: x: #IConvertible seq * y: #IConvertible seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Name: string * [<Optional; DefaultParameterValue ((null :> obj))>] ?ShowLegend: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?Opacity: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?Width: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?Offset: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?Text: 'a2 * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiText: 'a2 seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?TextPosition: TextPosition * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiTextPosition: TextPosition seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Orientation: Orientation * [<Optional; DefaultParameterValue ((null :> obj))>] ?AlignmentGroup: string * [<Optional; DefaultParameterValue ((null :> obj))>] ?OffsetGroup: string * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerColor: Color * [<Optional; DefaultParameterValue ((null :> obj))>] ?MarkerOutline: Line * [<Optional; DefaultParameterValue ((null :> obj))>] ?Marker: Marker * [<Optional; DefaultParameterValue ((null :> obj))>] ?TextInfo: TextInfo * [<Optional; DefaultParameterValue ((null :> obj))>] ?ConnectorLineColor: Color * [<Optional; DefaultParameterValue ((null :> obj))>] ?ConnectorLineStyle: DrawingStyle * [<Optional; DefaultParameterValue ((null :> obj))>] ?ConnectorFillColor: Color * [<Optional; DefaultParameterValue ((null :> obj))>] ?ConnectorLine: Line * [<Optional; DefaultParameterValue ((null :> obj))>] ?Connector: FunnelConnector * [<Optional; DefaultParameterValue ((null :> obj))>] ?InsideTextFont: Font * [<Optional; DefaultParameterValue ((null :> obj))>] ?OutsideTextFont: Font * [<Optional; DefaultParameterValue ((true :> obj))>] ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible) static member Heatmap: zData: #('a1 seq) seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?Name: string * [<Optional; DefaultParameterValue ((null :> obj))>] ?ShowLegend: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?Opacity: float * [<Optional; DefaultParameterValue ((null :> obj))>] ?X: #IConvertible seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?XGap: int * [<Optional; DefaultParameterValue ((null :> obj))>] ?Y: #IConvertible seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?YGap: int * [<Optional; DefaultParameterValue ((null :> obj))>] ?Text: 'a4 * [<Optional; DefaultParameterValue ((null :> obj))>] ?MultiText: 'a4 seq * [<Optional; DefaultParameterValue ((null :> obj))>] ?ColorBar: ColorBar * [<Optional; DefaultParameterValue ((null :> obj))>] ?ColorScale: Colorscale * [<Optional; DefaultParameterValue ((null :> obj))>] ?ShowScale: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?ReverseScale: bool * [<Optional; DefaultParameterValue ((null :> obj))>] ?ZSmooth: SmoothAlg * [<Optional; DefaultParameterValue ((null :> obj))>] ?Transpose: bool * [<Optional; DefaultParameterValue ((false :> obj))>] ?UseWebGL: bool * [<Optional; DefaultParameterValue ((false :> obj))>] ?ReverseYAxis: bool * [<Optional; DefaultParameterValue ((true :> obj))>] ?UseDefaults: bool -> GenericChart (requires 'a1 :> IConvertible and 'a4 :> IConvertible) + 1 overload ...

static member Chart.Histogram: data: #IConvertible seq * orientation: StyleParam.Orientation * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Name: string * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?ShowLegend: bool * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Opacity: float * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Text: 'a1 * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?MultiText: 'a1 seq * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?HistFunc: StyleParam.HistFunc * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?HistNorm: StyleParam.HistNorm * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?AlignmentGroup: string * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?OffsetGroup: string * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?NBinsX: int * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?NBinsY: int * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?BinGroup: string * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?XBins: TraceObjects.Bins * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?YBins: TraceObjects.Bins * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?MarkerColor: Color * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Marker: TraceObjects.Marker * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Line: Line * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?XError: TraceObjects.Error * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?YError: TraceObjects.Error * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Cumulative: TraceObjects.Cumulative * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?HoverLabel: LayoutObjects.Hoverlabel * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((true :> obj))>] ?UseDefaults: bool -> GenericChart.GenericChart (requires 'a1 :> IConvertible)
static member Chart.Histogram: [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?X: #IConvertible seq * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Y: #IConvertible seq * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Orientation: StyleParam.Orientation * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Name: string * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?ShowLegend: bool * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Opacity: float * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Text: 'c * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?MultiText: 'c seq * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?HistFunc: StyleParam.HistFunc * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?HistNorm: StyleParam.HistNorm * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?AlignmentGroup: string * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?OffsetGroup: string * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?NBinsX: int * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?NBinsY: int * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?BinGroup: string * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?XBins: TraceObjects.Bins * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?YBins: TraceObjects.Bins * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?MarkerColor: Color * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Marker: TraceObjects.Marker * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Line: Line * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?XError: TraceObjects.Error * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?YError: TraceObjects.Error * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Cumulative: TraceObjects.Cumulative * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?HoverLabel: LayoutObjects.Hoverlabel * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((true :> obj))>] ?UseDefaults: bool -> GenericChart.GenericChart (requires 'c :> IConvertible)

static member Chart.withTraceInfo: [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Name: string * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Visible: StyleParam.Visible * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?ShowLegend: bool * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?LegendRank: int * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?LegendGroup: string * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?LegendGroupTitle: Title -> (GenericChart.GenericChart -> GenericChart.GenericChart)

val qaLengthChart: GenericChart.GenericChart

val returnChart: GenericChart.GenericChart

static member Chart.SingleStack: [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?SubPlots: (StyleParam.LinearAxisId * StyleParam.LinearAxisId) array array * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?XAxes: StyleParam.LinearAxisId array * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?YAxes: StyleParam.LinearAxisId array * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?RowOrder: StyleParam.LayoutGridRowOrder * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Pattern: StyleParam.LayoutGridPattern * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?XGap: float * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?YGap: float * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?Domain: LayoutObjects.Domain * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?XSide: StyleParam.LayoutGridXSide * [<Runtime.InteropServices.Optional; Runtime.InteropServices.DefaultParameterValue ((null :> obj))>] ?YSide: StyleParam.LayoutGridYSide -> (#(GenericChart.GenericChart seq) -> GenericChart.GenericChart)

Multiple items
type CLIMutableAttribute = inherit Attribute new: unit -> CLIMutableAttribute

--------------------
new: unit -> CLIMutableAttribute

type BinarySentimentInput = { Label: bool Text: string }

type bool = Boolean

Multiple items
union case HttpResponseBody.Text: string -> HttpResponseBody

--------------------
namespace System.Text

type BinarySentimentOutput = { PredictedLabel: bool Probability: single Score: single }

Multiple items
val single: value: 'T -> single (requires member op_Explicit)

--------------------
type single = Single

--------------------
type single<'Measure> = float32<'Measure>

val ctx: MLContext

Multiple items
type MLContext = interface IHostEnvironmentInternal interface IHostEnvironment interface IChannelProvider interface IExceptionContext interface IProgressChannelProvider new: ?seed: Nullable<int> -> unit member AnomalyDetection: AnomalyDetectionCatalog member BinaryClassification: BinaryClassificationCatalog member Clustering: ClusteringCatalog member ComponentCatalog: ComponentCatalog ...
<summary> The common context for all ML.NET operations. Once instantiated by the user, it provides a way to create components for data preparation, feature engineering, training, prediction, and model evaluation. It also allows logging, execution control, and the ability to set repeatable random numbers. </summary>

--------------------
MLContext(?seed: Nullable<int>) : MLContext

val nq100FullSentiment: IDataView

property MLContext.Data: DataOperationsCatalog with get
<summary> Data loading and saving. </summary>

DataOperationsCatalog.LoadFromEnumerable<'TRow (requires reference type)>(data: Collections.Generic.IEnumerable<'TRow>, schema: DataViewSchema) : IDataView
DataOperationsCatalog.LoadFromEnumerable<'TRow (requires reference type)>(data: Collections.Generic.IEnumerable<'TRow>, ?schemaDefinition: SchemaDefinition) : IDataView

val nq100FullSplits: DataOperationsCatalog.TrainTestData

DataOperationsCatalog.TrainTestSplit(data: IDataView, ?testFraction: float, ?samplingKeyColumnName: string, ?seed: Nullable<int>) : DataOperationsCatalog.TrainTestData

val featurizePipeline: TextFeaturizingEstimator

property MLContext.Transforms: TransformsCatalog with get
<summary> Data processing operations. </summary>

property TransformsCatalog.Text: TransformsCatalog.TextTransforms with get
<summary> The list of operations for processing text data. </summary>

(extension) TransformsCatalog.TextTransforms.FeaturizeText(outputColumnName: string, ?inputColumnName: string) : TextFeaturizingEstimator
(extension) TransformsCatalog.TextTransforms.FeaturizeText(outputColumnName: string, options: TextFeaturizingEstimator.Options, [<ParamArray>] inputColumnNames: string array) : TextFeaturizingEstimator

val treeTrainer: Trainers.FastTree.FastTreeBinaryTrainer

property MLContext.BinaryClassification: BinaryClassificationCatalog with get
<summary> Trainers and tasks specific to binary classification problems. </summary>

property BinaryClassificationCatalog.Trainers: BinaryClassificationCatalog.BinaryClassificationTrainers with get
<summary> The list of trainers for performing binary classification. </summary>

(extension) BinaryClassificationCatalog.BinaryClassificationTrainers.FastTree(options: Trainers.FastTree.FastTreeBinaryTrainer.Options) : Trainers.FastTree.FastTreeBinaryTrainer
(extension) BinaryClassificationCatalog.BinaryClassificationTrainers.FastTree(?labelColumnName: string, ?featureColumnName: string, ?exampleWeightColumnName: string, ?numberOfLeaves: int, ?numberOfTrees: int, ?minimumExampleCountPerLeaf: int, ?learningRate: float) : Trainers.FastTree.FastTreeBinaryTrainer

val treePipeline: EstimatorChain<BinaryPredictionTransformer<Calibrators.CalibratedModelParametersBase<Trainers.FastTree.FastTreeBinaryModelParameters,Calibrators.PlattCalibrator>>>

(extension) IEstimator.Append<'TTrans (requires reference type and 'TTrans :> ITransformer)>(estimator: IEstimator<'TTrans>, ?scope: TransformerScope) : EstimatorChain<'TTrans>

val binaryTreeModel: TransformerChain<BinaryPredictionTransformer<Calibrators.CalibratedModelParametersBase<Trainers.FastTree.FastTreeBinaryModelParameters,Calibrators.PlattCalibrator>>>

EstimatorChain.Fit(input: IDataView) : TransformerChain<BinaryPredictionTransformer<Calibrators.CalibratedModelParametersBase<Trainers.FastTree.FastTreeBinaryModelParameters,Calibrators.PlattCalibrator>>>

field DataOperationsCatalog.TrainTestData.TrainSet: IDataView
<summary> Training set. </summary>

val computeMetrics: model: TransformerChain<'a> -> iDataView: IDataView -> CalibratedBinaryClassificationMetrics (requires reference type and 'a :> ITransformer)

val model: TransformerChain<'a> (requires reference type and 'a :> ITransformer)

Multiple items
type TransformerChain<'TLastTransformer (requires reference type and 'TLastTransformer :> ITransformer)> = interface ITransformer interface ICanSaveModel interface IEnumerable<ITransformer> interface IEnumerable interface ITransformerChainAccessor interface IDisposable new: transformers: IEnumerable<ITransformer> * scopes: IEnumerable<TransformerScope> -> unit + 1 overload member Append<'TNewLast (requires reference type and 'TNewLast :> ITransformer)> : transformer: 'TNewLast * ?scope: TransformerScope -> TransformerChain<'TNewLast> member Dispose: unit -> unit member GetEnumerator: unit -> IEnumerator<ITransformer> ...
<summary> A chain of transformers (possibly empty) that end with a <typeparamref name="TLastTransformer" />. For an empty chain, <typeparamref name="TLastTransformer" /> is always <see cref="T:Microsoft.ML.ITransformer" />. </summary>

--------------------
TransformerChain([<ParamArray>] transformers: ITransformer array) : TransformerChain<'TLastTransformer>
TransformerChain(transformers: Collections.Generic.IEnumerable<ITransformer>, scopes: Collections.Generic.IEnumerable<TransformerScope>) : TransformerChain<'TLastTransformer>

val iDataView: IDataView

val predictions: IDataView

TransformerChain.Transform(input: IDataView) : IDataView

val printBinaryClassificationMetrics: name: string -> metrics: CalibratedBinaryClassificationMetrics -> unit

val name: string

val metrics: CalibratedBinaryClassificationMetrics

type CalibratedBinaryClassificationMetrics = inherit BinaryClassificationMetrics member Entropy: float member LogLoss: float member LogLossReduction: float
<summary> Evaluation results for binary classifiers, including probabilistic metrics. </summary>

property BinaryClassificationMetrics.Accuracy: float with get
<summary> Gets the accuracy of a classifier which is the proportion of correct predictions in the test set. </summary>

property BinaryClassificationMetrics.AreaUnderRocCurve: float with get
<summary> Gets the area under the ROC curve. </summary>
<remarks> The area under the ROC curve is equal to the probability that the classifier ranks a randomly chosen positive instance higher than a randomly chosen negative one (assuming 'positive' ranks higher than 'negative'). Area under the ROC curve ranges between 0 and 1, with a value closer to 1 indicating a better model. <a href="https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve">Area Under ROC Curve</a></remarks>

property BinaryClassificationMetrics.AreaUnderPrecisionRecallCurve: float with get
<summary> Gets the area under the precision/recall curve of the classifier. </summary>
<remarks> The area under the precision/recall curve is a single number summary of the information in the precision/recall curve. It is increasingly used in the machine learning community, particularly for imbalanced datasets where one class is observed more frequently than the other. On these datasets, <see cref="P:Microsoft.ML.Data.BinaryClassificationMetrics.AreaUnderPrecisionRecallCurve" /> can highlight performance differences that are lost with <see cref="P:Microsoft.ML.Data.BinaryClassificationMetrics.AreaUnderRocCurve" />. </remarks>

property BinaryClassificationMetrics.F1Score: float with get
<summary> Gets the F1 score of the classifier, which is a measure of the classifier's quality considering both precision and recall. </summary>
<remarks> F1 score is the harmonic mean of precision and recall: 2 * precision * recall / (precision + recall). F1 ranges between 0 and 1, with a value of 1 indicating perfect precision and recall. </remarks>

property CalibratedBinaryClassificationMetrics.LogLoss: float with get
<summary> Gets the log-loss of the classifier. Log-loss measures the performance of a classifier with respect to how much the predicted probabilities diverge from the true class label. Lower log-loss indicates a better model. A perfect model, which predicts a probability of 1 for the true class, will have a log-loss of 0. </summary>
<remarks><format type="text/markdown"><![CDATA[ The log-loss metric, is computed as follows: $LogLoss = - \frac{1}{m} \sum{i = 1}^m ln(p_i)$ where m is the number of instances in the test set and $p_i$ is the probability returned by the classifier if the instance belongs to class 1, and 1 minus the probability returned by the classifier if the instance belongs to class 0. ]]></format></remarks>

property CalibratedBinaryClassificationMetrics.LogLossReduction: float with get
<summary> Gets the log-loss reduction (also known as relative log-loss, or reduction in information gain - RIG) of the classifier. It gives a measure of how much a model improves on a model that gives random predictions. Log-loss reduction closer to 1 indicates a better model. </summary>
<remarks><format type="text/markdown"><![CDATA[ The log-loss reduction is scaled relative to a classifier that predicts the prior for every example: $LogLossReduction = \frac{LogLoss(prior) - LogLoss(classifier)}{LogLoss(prior)}$ This metric can be interpreted as the advantage of the classifier over a random prediction. For example, if the RIG equals 0.2, it can be interpreted as "the probability of a correct prediction is 20% better than random guessing". ]]></format></remarks>

property BinaryClassificationMetrics.PositivePrecision: float with get
<summary> Gets the positive precision of a classifier which is the proportion of correctly predicted positive instances among all the positive predictions (i.e., the number of positive instances predicted as positive, divided by the total number of instances predicted as positive). </summary>

property BinaryClassificationMetrics.PositiveRecall: float with get, set
<summary> Gets the positive recall of a classifier which is the proportion of correctly predicted positive instances among all the positive instances (i.e., the number of positive instances predicted as positive, divided by the total number of positive instances). </summary>

property BinaryClassificationMetrics.NegativePrecision: float with get
<summary> Gets the negative precision of a classifier which is the proportion of correctly predicted negative instances among all the negative predictions (i.e., the number of negative instances predicted as negative, divided by the total number of instances predicted as negative). </summary>

property BinaryClassificationMetrics.NegativeRecall: float with get
<summary> Gets the negative recall of a classifier which is the proportion of correctly predicted negative instances among all the negative instances (i.e., the number of negative instances predicted as negative, divided by the total number of negative instances). </summary>

property BinaryClassificationMetrics.ConfusionMatrix: ConfusionMatrix with get
<summary> The <a href="https://en.wikipedia.org/wiki/Confusion_matrix">confusion matrix</a> giving the counts of the true positives, true negatives, false positives and false negatives for the two classes of data. </summary>

ConfusionMatrix.GetFormattedConfusionTable() : string

field DataOperationsCatalog.TrainTestData.TestSet: IDataView
<summary> Testing set. </summary>

val downcastPipeline: pipeline: IEstimator<#ITransformer> -> IEstimator<ITransformer>

val pipeline: IEstimator<#ITransformer>

type IEstimator<'TTransformer (requires 'TTransformer :> ITransformer)> = override Fit: input: IDataView -> 'TTransformer override GetOutputSchema: inputSchema: SchemaShape -> SchemaShape
<summary> The estimator (in Spark terminology) is an 'untrained transformer'. It needs to 'fit' on the data to manufacture a transformer. It also provides the 'schema propagation' like transformers do, but over <see cref="T:Microsoft.ML.SchemaShape" /> instead of <see cref="T:Microsoft.ML.DataViewSchema" />. </summary>

'a

type ITransformer = inherit ICanSaveModel override GetOutputSchema: inputSchema: DataViewSchema -> DataViewSchema override GetRowToRowMapper: inputSchema: DataViewSchema -> IRowToRowMapper override Transform: input: IDataView -> IDataView member IsRowToRowMapper: bool
<summary> The transformer is a component that transforms data. It also supports 'schema propagation' to answer the question of 'how will the data with this schema look, after you transform it?'. </summary>

val p: IEstimator<ITransformer>

val failwith: message: string -> 'T

val cvResults: Collections.Generic.IReadOnlyList<TrainCatalogBase.CrossValidationResult<CalibratedBinaryClassificationMetrics>>

val iteri: action: (int -> 'T -> unit) -> source: 'T seq -> unit

val i: int

val x: TrainCatalogBase.CrossValidationResult<CalibratedBinaryClassificationMetrics>

field TrainCatalogBase.CrossValidationResult<CalibratedBinaryClassificationMetrics>.Metrics: CalibratedBinaryClassificationMetrics
<summary> Metrics for this cross-validation fold. </summary>

val averageBy: projection: ('T -> 'U) -> source: 'T seq -> 'U (requires member (+) and member DivideByInt and member Zero)

val textFeatureOptions: TextFeaturizingEstimator.Options

val wordOptions: WordBagEstimator.Options

type WordBagEstimator = interface IEstimator<ITransformer> member Fit: input: IDataView -> ITransformer member GetOutputSchema: inputSchema: SchemaShape -> SchemaShape
<summary><see cref="T:Microsoft.ML.IEstimator`1" /> for the <see cref="T:Microsoft.ML.ITransformer" />. </summary>
<remarks><format type="text/markdown">< | | Output column data type | Vector of known-size of <xref:System.Single> | | Exportable to ONNX | Yes | The resulting <xref:Microsoft.ML.ITransformer> creates a new column, named as specified in the output column name parameters, and produces a vector of n-gram counts (sequences of n consecutive words) from a given data. It does so by building a dictionary of n-grams and using the id in the dictionary as the index in the bag. <xref:Microsoft.ML.Transforms.Text.WordBagEstimator> is different from <xref:Microsoft.ML.Transforms.Text.NgramExtractingEstimator> in that the former takes tokenizes text internally while the latter takes tokenized text as input. Check the See Also section for links to usage examples. ]]></format></remarks>
<seealso cref="M:Microsoft.ML.TextCatalog.ProduceWordBags(Microsoft.ML.TransformsCatalog.TextTransforms,System.String,System.String,System.Int32,System.Int32,System.Boolean,System.Int32,Microsoft.ML.Transforms.Text.NgramExtractingEstimator.WeightingCriteria)" />
<seealso cref="M:Microsoft.ML.TextCatalog.ProduceWordBags(Microsoft.ML.TransformsCatalog.TextTransforms,System.String,System.String[],System.Int32,System.Int32,System.Boolean,System.Int32,Microsoft.ML.Transforms.Text.NgramExtractingEstimator.WeightingCriteria)" />

type Options = new: unit -> unit val MaximumNgramsCount: int array val NgramLength: int val SkipLength: int val UseAllLengths: bool val Weighting: WeightingCriteria
<summary> Options for how the n-grams are extracted. </summary>

field WordBagEstimator.Options.NgramLength: int

field WordBagEstimator.Options.MaximumNgramsCount: int array

val stopOptions: StopWordsRemovingEstimator.Options

type StopWordsRemovingEstimator = inherit TrivialEstimator<StopWordsRemovingTransformer> member GetOutputSchema: inputSchema: SchemaShape -> SchemaShape
<summary><see cref="T:Microsoft.ML.IEstimator`1" /> for the <see cref="T:Microsoft.ML.Transforms.Text.CustomStopWordsRemovingTransformer" />. </summary>
<remarks><format type="text/markdown">< | | Output column data type | Variable-sized vector of [Text](xref:Microsoft.ML.Data.TextDataViewType) | | Exportable to ONNX | Yes | The resulting <xref:Microsoft.ML.Transforms.Text.StopWordsRemovingTransformer> creates a new column, named as specified in the output column name parameter, and fills it with a vector of words containing all of the words in the input column **except the predefined list of stopwords for the specified language. All text comparison made by casting predefined text and text from input column to lower case using casing rules of invariant culture. Check the See Also section for links to usage examples. ]]></format></remarks>
<seealso cref="M:Microsoft.ML.TextCatalog.RemoveDefaultStopWords(Microsoft.ML.TransformsCatalog.TextTransforms,System.String,System.String,Microsoft.ML.Transforms.Text.StopWordsRemovingEstimator.Language)" />

type Options = interface IStopWordsRemoverOptions new: unit -> unit val Language: Language
<summary> Use stop words remover that can remove language-specific list of stop words (most common words) already defined in the system. </summary>

val charOptions: 'a (requires 'a: null)

val textOptions: TextFeaturizingEstimator.Options

type TextFeaturizingEstimator = interface IEstimator<ITransformer> member Fit: input: IDataView -> ITransformer member GetOutputSchema: inputSchema: SchemaShape -> SchemaShape
<summary> An estimator that turns a collection of text documents into numerical feature vectors. The feature vectors are normalized counts of word and/or character n-grams (based on the options supplied). </summary>
<remarks><format type="text/markdown">< | | Output column data type | Vector of <xref:System.Single> | | Exportable to ONNX | No | This estimator gives the user one-stop solution for doing: * Language Detection * [Tokenization](https://en.wikipedia.org/wiki/Lexical_analysis#Tokenization) * [Text normalization](https://en.wikipedia.org/wiki/Text_normalization) * [Predefined and custom stopwords removal](https://en.wikipedia.org/wiki/Stop_words) * [Word-based or character-based Ngram extraction and SkipGram extraction (through the advanced [options](xref:Microsoft.ML.Transforms.TextFeaturizingEstimator.Options.WordFeatureExtractor))](https://en.wikipedia.org/wiki/N-gram) * [TF, IDF or TF-IDF](https://en.wikipedia.org/wiki/Tf%E2%80%93idf) * [L-p vector normalization](xref: Microsoft.ML.Transforms.LpNormNormalizingTransformer) By default the features are made of (word/character) n-grams/skip-grams​ and the number of features are equal to the vocabulary size found by analyzing the data. To output an additional column with the tokens generated, use [OutputTokensColumnName](xref:Microsoft.ML.Transforms.Text.TextFeaturizingEstimator.Options.OutputTokensColumnName). The number of features can also be specified by selecting the maximum number of n-gram to keep in the <xref:Microsoft.ML.Transforms.Text.TextFeaturizingEstimator.Options>, where the estimator can be further tuned. Check the See Also section for links to usage examples. ]]></format></remarks>
<seealso cref="M:Microsoft.ML.TextCatalog.FeaturizeText(Microsoft.ML.TransformsCatalog.TextTransforms,System.String,Microsoft.ML.Transforms.Text.TextFeaturizingEstimator.Options,System.String[])" />
<seealso cref="M:Microsoft.ML.TextCatalog.FeaturizeText(Microsoft.ML.TransformsCatalog.TextTransforms,System.String,System.String)" />

type Options = inherit TransformInputBase new: unit -> unit val CaseMode: CaseMode val KeepDiacritics: bool val KeepNumbers: bool val KeepPunctuations: bool val Norm: NormFunction val OutputTokensColumnName: string member CharFeatureExtractor: Options member StopWordsRemoverOptions: IStopWordsRemoverOptions ...
<summary> Advanced options for the <see cref="T:Microsoft.ML.Transforms.Text.TextFeaturizingEstimator" />. </summary>

property TextFeaturizingEstimator.Options.CharFeatureExtractor: WordBagEstimator.Options with get, set
<summary> Ngram feature extractor to use for characters (WordBag/WordHashBag). Set to <see langword="null" /> to turn off n-gram generation for characters. </summary>

property TextFeaturizingEstimator.Options.WordFeatureExtractor: WordBagEstimator.Options with get, set
<summary> Ngram feature extractor to use for words (WordBag/WordHashBag). Set to <see langword="null" /> to turn off n-gram generation for words. </summary>

property TextFeaturizingEstimator.Options.StopWordsRemoverOptions: IStopWordsRemoverOptions with get, set
<summary> Option to set type of stop word remover to use. The following options are available <list type="bullet"><item><description>The <see cref="T:Microsoft.ML.Transforms.Text.StopWordsRemovingEstimator.Options" /> removes the language specific list of stop words from the input.</description></item><item><description>The <see cref="T:Microsoft.ML.Transforms.Text.CustomStopWordsRemovingEstimator.Options" /> uses user provided list of stop words.</description></item></list> Setting this to 'null' does not remove stop words from the input. </summary>

val featurizePipelineSimple: TextFeaturizingEstimator

val treeSimple: EstimatorChain<BinaryPredictionTransformer<Calibrators.CalibratedModelParametersBase<Trainers.FastTree.FastTreeBinaryModelParameters,Calibrators.PlattCalibrator>>>

val cvSimple: Collections.Generic.IReadOnlyList<TrainCatalogBase.CrossValidationResult<CalibratedBinaryClassificationMetrics>>

val nq100PreparedSentiment: IDataView

val cvPreparedRemarks: Collections.Generic.IReadOnlyList<TrainCatalogBase.CrossValidationResult<CalibratedBinaryClassificationMetrics>>

val nq100ExtremeSentiment: IDataView

val filter: predicate: ('T -> bool) -> source: 'T seq -> 'T seq

val abs: value: 'T -> 'T (requires member Abs)

val cvExtreme: Collections.Generic.IReadOnlyList<TrainCatalogBase.CrossValidationResult<CalibratedBinaryClassificationMetrics>>

type MulticlassSentimentInput = { Label: string Text: string }

type MulticlassSentimentOutput = { PredictedLabel: string Probability: single Score: single }

val nq100MulticlassSentiment: IDataView

val nq100MulticlassSplits: DataOperationsCatalog.TrainTestData

val multiTrainer: Trainers.SdcaMaximumEntropyMulticlassTrainer

property MLContext.MulticlassClassification: MulticlassClassificationCatalog with get
<summary> Trainers and tasks specific to multiclass classification problems. </summary>

property MulticlassClassificationCatalog.Trainers: MulticlassClassificationCatalog.MulticlassClassificationTrainers with get
<summary> The list of trainers for performing multiclass classification. </summary>

(extension) MulticlassClassificationCatalog.MulticlassClassificationTrainers.SdcaMaximumEntropy(options: Trainers.SdcaMaximumEntropyMulticlassTrainer.Options) : Trainers.SdcaMaximumEntropyMulticlassTrainer
(extension) MulticlassClassificationCatalog.MulticlassClassificationTrainers.SdcaMaximumEntropy(?labelColumnName: string, ?featureColumnName: string, ?exampleWeightColumnName: string, ?l2Regularization: Nullable<float32>, ?l1Regularization: Nullable<float32>, ?maximumNumberOfIterations: Nullable<int>) : Trainers.SdcaMaximumEntropyMulticlassTrainer

val multiPipeline: EstimatorChain<MulticlassPredictionTransformer<Trainers.MaximumEntropyModelParameters>>

Multiple items
type EstimatorChain<'TLastTransformer (requires reference type and 'TLastTransformer :> ITransformer)> = interface IEstimator<TransformerChain<'TLastTransformer>> new: unit -> unit member Append<'TNewTrans (requires reference type and 'TNewTrans :> ITransformer)> : estimator: IEstimator<'TNewTrans> * ?scope: TransformerScope -> EstimatorChain<'TNewTrans> member AppendCacheCheckpoint: env: IHostEnvironment -> EstimatorChain<'TLastTransformer> member Fit: input: IDataView -> TransformerChain<'TLastTransformer> member GetOutputSchema: inputSchema: SchemaShape -> SchemaShape val LastEstimator: IEstimator<'TLastTransformer>
<summary> Represents a chain (potentially empty) of estimators that end with a <typeparamref name="TLastTransformer" />. If the chain is empty, <typeparamref name="TLastTransformer" /> is always <see cref="T:Microsoft.ML.ITransformer" />. </summary>

--------------------
EstimatorChain() : EstimatorChain<'TLastTransformer>

property TransformsCatalog.Conversion: TransformsCatalog.ConversionTransforms with get
<summary> The list of operations for data type conversion. </summary>

(extension) TransformsCatalog.ConversionTransforms.MapValueToKey(columns: InputOutputColumnPair array, ?maximumNumberOfKeys: int, ?keyOrdinality: Transforms.ValueToKeyMappingEstimator.KeyOrdinality, ?addKeyValueAnnotationsAsText: bool, ?keyData: IDataView) : Transforms.ValueToKeyMappingEstimator
(extension) TransformsCatalog.ConversionTransforms.MapValueToKey(outputColumnName: string, ?inputColumnName: string, ?maximumNumberOfKeys: int, ?keyOrdinality: Transforms.ValueToKeyMappingEstimator.KeyOrdinality, ?addKeyValueAnnotationsAsText: bool, ?keyData: IDataView) : Transforms.ValueToKeyMappingEstimator

val multiModel: TransformerChain<MulticlassPredictionTransformer<Trainers.MaximumEntropyModelParameters>>

EstimatorChain.Fit(input: IDataView) : TransformerChain<MulticlassPredictionTransformer<Trainers.MaximumEntropyModelParameters>>

val computeMultiClassMetrics: model: TransformerChain<'a> -> iDataView: IDataView -> MulticlassClassificationMetrics (requires reference type and 'a :> ITransformer)

val printMultiClassClassificationMetrics: name: string -> metrics: MulticlassClassificationMetrics -> unit

val metrics: MulticlassClassificationMetrics

type MulticlassClassificationMetrics = member ConfusionMatrix: ConfusionMatrix member LogLoss: float member LogLossReduction: float member MacroAccuracy: float member MicroAccuracy: float member PerClassLogLoss: IReadOnlyList<float> member TopKAccuracy: float member TopKAccuracyForAllK: IReadOnlyList<float> member TopKPredictionCount: int
<summary> Evaluation results for multi-class classification trainers. </summary>

property MulticlassClassificationMetrics.MacroAccuracy: float with get
<summary> Gets the macro-average accuracy of the model. </summary>
<remarks> The macro-average is the average accuracy at the class level. The accuracy for each class is computed and the macro-accuracy is the average of these accuracies. The macro-average metric gives the same weight to each class, no matter how many instances from that class the dataset contains. </remarks>

property MulticlassClassificationMetrics.LogLoss: float with get
<summary> Gets the average log-loss of the classifier. Log-loss measures the performance of a classifier with respect to how much the predicted probabilities diverge from the true class label. Lower log-loss indicates a better model. A perfect model, which predicts a probability of 1 for the true class, will have a log-loss of 0. </summary>
<remarks><format type="text/markdown"><![CDATA[ The log-loss metric is computed as follows: $LogLoss = - \frac{1}{m} \sum_{i = 1}^m log(p_i)$, where $m$ is the number of instances in the test set and $p_i$ is the probability returned by the classifier of the instance belonging to the true class. ]]></format></remarks>

property MulticlassClassificationMetrics.PerClassLogLoss: Collections.Generic.IReadOnlyList<float> with get
<summary> Gets the log-loss of the classifier for each class. Log-loss measures the performance of a classifier with respect to how much the predicted probabilities diverge from the true class label. Lower log-loss indicates a better model. A perfect model, which predicts a probability of 1 for the true class, will have a log-loss of 0. </summary>
<remarks> The log-loss metric is computed as $-\frac{1}{m} \sum_{i=1}^m \log(p_i)$, where $m$ is the number of instances in the test set. $p_i$ is the probability returned by the classifier if the instance belongs to the class, and 1 minus the probability returned by the classifier if the instance does not belong to the class. </remarks>
<example><format type="text/markdown"><] ]]></format></example>

property MulticlassClassificationMetrics.ConfusionMatrix: ConfusionMatrix with get
<summary> The <a href="https://en.wikipedia.org/wiki/Confusion_matrix">confusion matrix</a> giving the counts of the predicted classes versus the actual classes. </summary>

val binaryTreePredictions: PredictionEngine<BinarySentimentInput,BinarySentimentOutput>

property MLContext.Model: ModelOperationsCatalog with get
<summary> Operations with trained models. </summary>

ModelOperationsCatalog.CreatePredictionEngine<'TSrc,'TDst (requires reference type and default constructor and reference type)>(transformer: ITransformer, options: PredictionEngineOptions) : PredictionEngine<'TSrc,'TDst>
ModelOperationsCatalog.CreatePredictionEngine<'TSrc,'TDst (requires reference type and default constructor and reference type)>(transformer: ITransformer, inputSchema: DataViewSchema) : PredictionEngine<'TSrc,'TDst>
ModelOperationsCatalog.CreatePredictionEngine<'TSrc,'TDst (requires reference type and default constructor and reference type)>(transformer: ITransformer, ?ignoreMissingColumns: bool, ?inputSchemaDefinition: SchemaDefinition, ?outputSchemaDefinition: SchemaDefinition) : PredictionEngine<'TSrc,'TDst>

val sampleNegCall: BinarySentimentInput

PredictionEngineBase.Predict(example: BinarySentimentInput) : BinarySentimentOutput
PredictionEngine.Predict(example: BinarySentimentInput, prediction: byref<BinarySentimentOutput>) : unit

val samplePosCall: BinarySentimentInput