Clean up comments and docs (#335)

Author: DePasqualeOrg

Applications/LLMEval/ContentView.swift

@@ -234,7 +234,7 @@ class LLMEvaluator {
 
             self.prompt = modelConfiguration.defaultPrompt
             self.modelInfo =
-                "Loaded \(modelConfiguration.id).  Weights: \(numParams / (1024*1024))M"
+                "Loaded \(modelConfiguration.id). Weights: \(numParams / (1024*1024))M"
             loadState = .loaded(modelContainer)
             return modelContainer
 

Applications/LLMEval/README.md

@@ -33,19 +33,19 @@ memory.
 
 ### Troubleshooting
 
-If the program crashes with a very deep stack trace you may need to build
-in Release configuration.  This seems to depend on the size of the model.
+If the program crashes with a very deep stack trace, you may need to build
+in Release configuration. This seems to depend on the size of the model.
 
 There are a couple options:
 
-- build Release
-- force the model evaluation to run on the main thread, e.g. using @MainActor
-- build `Cmlx` with optimizations by modifying `mlx/Package.swift` and adding `.unsafeOptions(["-O3"]),` around line 87
+- Build Release
+- Force the model evaluation to run on the main thread, e.g. using @MainActor
+- Build `Cmlx` with optimizations by modifying `mlx/Package.swift` and adding `.unsafeOptions(["-O3"]),` around line 87
 
 See discussion here: https://github.com/ml-explore/mlx-swift-examples/issues/3
 
 ### Performance
 
 Different models have difference performance characteristics. For example Gemma 2B may outperform Phi-2 in terms of tokens / second.
 
-You may also find that running outside the debugger boosts performance.  You can do this in Xcode by pressing cmd-opt-r and unchecking "Debug Executable".
+You may also find that running outside the debugger boosts performance. You can do this in Xcode by pressing cmd-opt-r and unchecking "Debug Executable".

Applications/LoRATrainingExample/README.md

@@ -10,7 +10,7 @@ Example application that:
 This roughly equates to the command line example in [Tools/llm-tool](../../Tools/llm-tool) and
 you can read more about LoRA there.
 
-This evaluates the LoRA adapted model rather than a fused model.  This doesn't persist
+This evaluates the LoRA adapted model rather than a fused model. This doesn't persist
 the LoRA weights or the fused model -- it will retrain it each time the program is launched.
 
 ### Troubleshooting

Applications/StableDiffusionExample/ContentView.swift

@@ -253,18 +253,18 @@ class StableDiffusionEvaluator {
         progress = .init(title: "Preparing", current: 0, limit: 1)
         message = nil
 
-        // the parameters that control the generation of the image.  See
-        // EvaluateParameters for more information.  For example adjusting
+        // The parameters that control the generation of the image. See
+        // EvaluateParameters for more information. For example, adjusting
         // the latentSize parameter will change the size of the generated
-        // image.  imageCount could be used to generate a gallery of
+        // image. `imageCount` could be used to generate a gallery of
         // images at the same time.
         let parameters = {
             var p = modelFactory.configuration.defaultParameters()
             p.prompt = prompt
             p.negativePrompt = negativePrompt
 
-            // per measurement each step consumes memory that we want to conserve.  trade
-            // off steps (quality) for memory
+            // Per measurement each step consumes memory that we want to conserve. Trade
+            // off steps (quality) for memory.
             if modelFactory.conserveMemory {
                 p.steps = 1
             }
@@ -273,33 +273,33 @@ class StableDiffusionEvaluator {
         }()
 
         do {
-            // note: the optionals are used to discard parts of the model
-            // as it runs -- this is used to conserveMemory in devices
-            // with less memory
+            // Note: The optionals are used to discard parts of the model
+            // as it runs. This is used to conserve memory in devices
+            // with less memory.
             let container = try await modelFactory.load(reportProgress: updateProgress)
 
             try await container.performTwoStage { generator in
-                // the parameters that control the generation of the image.  See
-                // EvaluateParameters for more information.  For example adjusting
-                // the latentSize parameter will change the size of the generated
-                // image.  imageCount could be used to generate a gallery of
+                // The parameters that control the generation of the image. See
+                // EvaluateParameters for more information. For example adjusting
+                // the `latentSize` parameter will change the size of the generated
+                // image. `imageCount` could be used to generate a gallery of
                 // images at the same time.
                 var parameters = modelFactory.configuration.defaultParameters()
                 parameters.prompt = prompt
                 parameters.negativePrompt = negativePrompt
 
-                // per measurement each step consumes memory that we want to conserve.  trade
-                // off steps (quality) for memory
+                // Per measurement each step consumes memory that we want to conserve. Trade
+                // off steps (quality) for memory.
                 if modelFactory.conserveMemory {
                     parameters.steps = 1
                 }
 
-                // generate the latent images -- this is fast as it is just generating
-                // the graphs that will be evaluated below
+                // Generate the latent images. This is fast as it is just generating
+                // the graphs that will be evaluated below.
                 let latents: DenoiseIterator? = generator.generateLatents(parameters: parameters)
 
-                // when conserveMemory is true this will discard the first part of
-                // the model and just evaluate the decode portion
+                // When conserveMemory is true this will discard the first part of
+                // the model and just evaluate the decode portion.
                 return (generator.detachedDecoder(), latents)
 
             } second: { decoder, latents in

Applications/StableDiffusionExample/README.md

@@ -23,7 +23,7 @@ If you are interested in adjusting the generated images, look in
 Stable diffusion can run in less that 4G available memory (typically a
 device or computer with 6G of memory or more) in a constrained mode -- it will
 load and unload parts of the model as it runs and it can only perform one step
-of diffusion.  This is configured automatically, see `modelFactory.conserveMemory`
+of diffusion. This is configured automatically, see `modelFactory.conserveMemory`
 in [ContentView.swift](ContentView.swift).
 
 On a device or computer with more memory the model will be kept resident and

Libraries/Embedders/Configuration.swift

@@ -28,8 +28,8 @@ public enum StringOrNumber: Codable, Equatable, Sendable {
 
 private class ModelTypeRegistry: @unchecked Sendable {
 
-    // Note: using NSLock as we have very small (just dictionary get/set)
-    // critical sections and expect no contention.  this allows the methods
+    // Note: Using NSLock as we have very small (just dictionary get/set)
+    // critical sections and expect no contention. This allows the methods
     // to remain synchronous.
     private let lock = NSLock()
 

Libraries/Embedders/EmbeddingModel.swift

@@ -8,7 +8,7 @@ import Tokenizers
 
 /// Container for models that guarantees single threaded access.
 ///
-/// Wrap models used by e.g. the UI in a ModelContainer.  Callers can access
+/// Wrap models used by e.g. the UI in a ModelContainer. Callers can access
 /// the model and/or tokenizer:
 ///
 /// ```swift
@@ -55,7 +55,7 @@ public actor ModelContainer {
         self.pooler = loadPooling(modelDirectory: modelDirectory)  //?? Pooling(strategy: .none)
     }
 
-    /// Perform an action on the model and/or tokenizer.  Callers _must_ eval any `MLXArray` before returning as
+    /// Perform an action on the model and/or tokenizer. Callers _must_ eval any `MLXArray` before returning as
     /// `MLXArray` is not `Sendable`.
     public func perform<R>(_ action: @Sendable (EmbeddingModel, Tokenizer, Pooling) throws -> R)
         rethrows

Libraries/Embedders/Models.swift

@@ -4,9 +4,9 @@ import Foundation
 import Hub
 
 /// Registry of models and any overrides that go with them, e.g. prompt augmentation.
-/// If asked for an unknown configuration this will use the model/tokenizer as-is.
+/// If asked for an unknown configuration this will use the model/tokenizer as is.
 ///
-/// The python tokenizers have a very rich set of implementations and configuration.  The
+/// The Python tokenizers have a very rich set of implementations and configuration. The
 /// swift-tokenizers code handles a good chunk of that and this is a place to augment that
 /// implementation, if needed.
 public struct ModelConfiguration: Sendable {

Libraries/MLXLLM/Documentation.docc/adding-model.md

@@ -30,7 +30,7 @@ public struct YourModelConfiguration: Codable, Sendable {
 
 ## Create the Model Class
 
-Create the model class.  The top-level public class should have a
+Create the model class. The top-level public class should have a
 structure something like this:
 
 ```swift

Libraries/MLXLLM/Documentation.docc/using-model.md

@@ -63,7 +63,7 @@ load models, if needed.
 ## Evaluating a Model
 
 Once a model is loaded you can evaluate a prompt or series of
-messages.  Minimally you need to prepare the user input:
+messages. Minimally you need to prepare the user input:
 
 ```swift
 let prompt = "Describe the image in English"
@@ -72,7 +72,7 @@ input.processing.resize = .init(width: 256, height: 256)
 ```
 
 This example shows adding some images and processing instructions -- if
-model accepts text only then these parts can be omitted.  The inference
+model accepts text only then these parts can be omitted. The inference
 calls are the same.
 
 Assuming you are using a `ModelContainer` (an actor that holds
@@ -90,7 +90,7 @@ let result = try await modelContainer.perform { [input] context in
 ```
 
 Given that `input` we can call `generate()` to produce a stream
-of tokens.  In this example we use a `NaiveStreamingDetokenizer`
+of tokens. In this example we use a `NaiveStreamingDetokenizer`
 to assist in converting a stream of tokens into text and print it.
 The stream is stopped after we hit a maximum number of tokens: