Update README.md

Author: williamFalcon

README.md

@@ -1,113 +1,79 @@
 <div align='center'>
 
-# Effortless Model Management for Your Development ⚡
+# Checkpoint and share AI models Lightning fast ⚡
 
 <img alt="Lightning" src="https://pl-public-data.s3.us-east-1.amazonaws.com/assets_lightning/LitModels.png" width="800px" style="max-width: 100%;">
 
-<strong>Effortless management for your ML models.</strong>
-
-🚀 [Quick start](#quick-start)
-📦 [Examples](#saving-and-loading-models)
-📚 [Documentation](https://lightning.ai/docs/overview/model-registry)
-💬 [Get help on Discord](https://discord.com/invite/XncpTy7DSt)
-📋 [License: Apache 2.0](https://github.com/Lightning-AI/litModels/blob/main/LICENSE)
-
+<div align="center">
+  <div style="text-align: center;">
+    <a target="_blank" href="#quick-start" style="margin: 0 10px;">Quick start</a> •
+    <a target="_blank" href="#examples" style="margin: 0 10px;">Examples</a> •
+    <a target="_blank" href="#features" style="margin: 0 10px;">Features</a> •
+    <a target="_blank" href="#performance" style="margin: 0 10px;">Performance</a> •
+    <a target="_blank" href="#community" style="margin: 0 10px;">Community</a> •
+    <a target="_blank" href="https://lightning.ai/docs/overview/model-registry" style="margin: 0 10px;">Docs</a>
+  </div>
+</div>
 </div>
 
 ______________________________________________________________________
 
-**Lightning Models** is a streamlined toolkit for effortlessly saving, loading, and managing your model checkpoints.
-Designed to simplify the entire model lifecycle—from training and inference to sharing, deployment, and cloud integration—Lightning Models supports any framework that produces model checkpoints, including but not limited to PyTorch Lightning.
+Save, load, host, and share models without slowing down training.    
+**LitModels** minimizes training slowdowns from checkpoint saving. Share public links on Lightning AI or your own cloud with enterprise-grade access controls.
 
 <pre>
-✅ Seamless Model Saving & Loading
-✅ Robust Checkpoint Management
-✅ Cloud Integration Out of the Box
-✅ Versatile Across Frameworks
+✅ Checkpoint without slowing training.    
+✅ Instant model loading anywhere.    
+✅ Share with secure, link-based access.
+✅ Host on Lightning or your own cloud.    
 </pre>
 
 # Quick start
 
-Install Lightning Models via pip (more installation options below):
-
-```bash
-pip install -U litmodels
-```
-
-Or install directly from source:
+Install LitModels via pip:
 
 ```bash
-pip install https://github.com/Lightning-AI/litModels/archive/refs/heads/main.zip
+pip install litmodels
 ```
 
-## Saving and Loading Models
-
-Lightning Models offers a simple API to manage your model checkpoints.
-Train your model using your preferred framework (our fist examples show `scikit-learn`) and then save your best checkpoint with a single function call.
-
-### Train scikit-learn model and save it
-
+Toy example ([see real examples](#examples)):
 ```python
-from sklearn import datasets, model_selection, svm
-from litmodels import upload_model
-
-# Load example dataset
-iris = datasets.load_iris()
-X, y = iris.data, iris.target
-
-# Split dataset into training and test sets
-X_train, X_test, y_train, y_test = model_selection.train_test_split(
-    X, y, test_size=0.2, random_state=42
-)
-
-# Train a simple SVC model
-model = svm.SVC()
-model.fit(X_train, y_train)
-
-# Upload the saved model using litmodels
-upload_model(model=model, name="your_org/your_team/sklearn-svm-model")
-```
-
-### Download and Load the Model for inference
-
-```python
-from litmodels import load_model
+import litmodels as lm
+import torch
 
-# Download and load the model file from cloud storage
-model = load_model(
-    name="your_org/your_team/sklearn-svm-model", download_dir="my_models"
-)
+# save a model
+model = torch.nn.Module()
+upload_model(model=model, name='model-name')
 
-# Example: run inference with the loaded model
-sample_input = [[5.1, 3.5, 1.4, 0.2]]
-prediction = model.predict(sample_input)
-print(f"Prediction: {prediction}")
+# load a model
+model = load_model(name='model-name')
 ```
 
-## Saving and Loading Models with plain Pytorch
+# Examples
 
-Next examples demonstrate seamless PyTorch integration with Lightning Models.
+<details>
+  <summary>PyTorch</summary>
 
+Save model:   
 ```python
 import torch
 from litmodels import load_model, upload_model
 
+model = torch.nn.Module()
+upload_model(model=model, name="your_org/your_team/torch-model")
+```
 
-class SimpleModel(torch.nn.Module): ...
-
-
-# First, simply upload the model object to registry
-upload_model(model=SimpleModel(), name="your_org/your_team/torch-model")
-# Later, you can download the model from the registry
+Load model:
+```python
 model_ = load_model(name="your_org/your_team/torch-model")
 ```
 
-## Saving and Loading Models with Pytorch Lightning
-
-Next examples demonstrate seamless PyTorch Lightning integration with Lightning Models.
+</details>
 
-### Train a simple Lightning model and save it
+<details>
+  <summary>PyTorch Lightning</summary>
 
+Save model:
 ```python
 from lightning import Trainer
 from litmodels import upload_model
@@ -124,8 +90,7 @@ checkpoint_path = getattr(trainer.checkpoint_callback, "best_model_path")
 upload_model(model=checkpoint_path, name="<organization>/<teamspace>/<model-name>")
 ```
 
-### Download and Load the Model for fine-tuning
-
+Load model:
 ```python
 from lightning import Trainer
 from litmodels import download_model
@@ -144,8 +109,53 @@ trainer = Trainer(max_epochs=4)
 trainer.fit(BoringModel(), ckpt_path=checkpoint_path)
 ```
 
+</details>
+
 <details>
-    <summary>Checkpointing Workflow with Lightning</summary>
+  <summary>SKLearn</summary>
+
+Save model: 
+```python
+from sklearn import datasets, model_selection, svm
+from litmodels import upload_model
+
+# Load example dataset
+iris = datasets.load_iris()
+X, y = iris.data, iris.target
+
+# Split dataset into training and test sets
+X_train, X_test, y_train, y_test = model_selection.train_test_split(
+    X, y, test_size=0.2, random_state=42
+)
+
+# Train a simple SVC model
+model = svm.SVC()
+model.fit(X_train, y_train)
+
+# Upload the saved model using litmodels
+upload_model(model=model, name="your_org/your_team/sklearn-svm-model")
+```
+
+Use model:
+```python
+from litmodels import load_model
+
+# Download and load the model file from cloud storage
+model = load_model(
+    name="your_org/your_team/sklearn-svm-model", download_dir="my_models"
+)
+
+# Example: run inference with the loaded model
+sample_input = [[5.1, 3.5, 1.4, 0.2]]
+prediction = model.predict(sample_input)
+print(f"Prediction: {prediction}")
+```
+
+</details>
+
+# Features
+<details>
+    <summary>PyTorch Lightning Callback</summary>
 
 Enhance your training process with an automatic checkpointing callback that uploads the model at the end of each epoch.
 
@@ -177,27 +187,12 @@ trainer.fit(
 
 </details>
 
-## Model Registry Mixins
-
-Lightning Models provides mixin classes that simplify pushing models to and pulling models from the registry.
-These mixins can be integrated directly into the model classes.
-
-### Available Mixins
-
-1. **PickleRegistryMixin**: For serializing any Python class with pickle
-2. **PyTorchRegistryMixin**: For PyTorch models, preserving both weights and constructor arguments
-
-Using these mixins provides several advantages:
-
-- Direct integration into the model classes
-- Simplified save/load workflow
-- Automatic handling of model metadata and constructor arguments
-- Version management support
-
-### Using `PickleRegistryMixin`
+<details>
+    <summary>Save any Python class as a checkpoint</summary>
 
-Add the mixin to a Python class for seamless registry integration:
+Why is this useful???
 
+Save model:
 ```python
 from litmodels.integrations.mixins import PickleRegistryMixin
 
@@ -213,20 +208,25 @@ class MyModel(PickleRegistryMixin):
 # Create and push a model instance
 model = MyModel(param1=42, param2="hello")
 model.upload_model(name="my-org/my-team/my-model")
+```
 
-# Later, pull the model
+Load model:
+```python
 loaded_model = MyModel.download_model(name="my-org/my-team/my-model")
 ```
+    
+</details>
 
-### Using `PyTorchRegistryMixin`
+<details>
+    <summary>Save custom PyTorch models</summary>
 
-This mixin preserves both the model architecture and weights:
+why is this useful? why do i need this?
 
+Save model:
 ```python
 import torch
 from litmodels.integrations.mixins import PyTorchRegistryMixin
 
-
 # Important: PyTorchRegistryMixin must be first in the inheritance order
 class MyTorchModel(PyTorchRegistryMixin, torch.nn.Module):
     def __init__(self, input_size, hidden_size=128):
@@ -237,11 +237,24 @@ class MyTorchModel(PyTorchRegistryMixin, torch.nn.Module):
     def forward(self, x):
         return self.activation(self.linear(x))
 
-
 # Create and push the model
 model = MyTorchModel(input_size=784)
 model.upload_model(name="my-org/my-team/torch-model")
+```
+
+Use the model:
+```python
 
 # Pull the model with the same architecture
 loaded_model = MyTorchModel.download_model(name="my-org/my-team/torch-model")
 ```
+
+</details>
+
+# Performance
+TODO: show the chart between not using this vs using this and the impact on training (the GPU utilization side-by-side)... also, what are tangible speed ups in training and inference.
+
+# Community
+
+💬 [Get help on Discord](https://discord.com/invite/XncpTy7DSt)    
+📋 [License: Apache 2.0](https://github.com/Lightning-AI/litModels/blob/main/LICENSE)