{"id":20049680,"url":"https://github.com/esmail-ibraheem/nanograd","last_synced_at":"2025-05-05T11:31:04.214Z","repository":{"id":261365959,"uuid":"804713226","full_name":"Esmail-ibraheem/nanograd","owner":"Esmail-ibraheem","description":"nanograd🧠 ML/DL and neural net ecosystem, run models like GPT, llama, stable diffusion, vision transformer, reinforcement learning, autotrainer,  your Unreal Engine, but for AI, essentially making it an AI engine or an AI Ecosystem","archived":false,"fork":false,"pushed_at":"2025-02-07T07:50:47.000Z","size":58784,"stargazers_count":7,"open_issues_count":0,"forks_count":3,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-04-08T21:41:55.241Z","etag":null,"topics":["artificial-intelligence","autotrainer","chatbot","deep-learning","gpt","gradio","large-language-models","llama","pytorch","pytorch-lightning","stable-diffusion","vision-transformer"],"latest_commit_sha":null,"homepage":"https://youtu.be/N8kninEpKTI","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/Esmail-ibraheem.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2024-05-23T05:58:14.000Z","updated_at":"2025-02-18T09:14:19.000Z","dependencies_parsed_at":"2024-11-22T12:36:31.817Z","dependency_job_id":null,"html_url":"https://github.com/Esmail-ibraheem/nanograd","commit_stats":null,"previous_names":["esmail-ibraheem/nanograd"],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Esmail-ibraheem%2Fnanograd","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Esmail-ibraheem%2Fnanograd/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Esmail-ibraheem%2Fnanograd/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Esmail-ibraheem%2Fnanograd/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/Esmail-ibraheem","download_url":"https://codeload.github.com/Esmail-ibraheem/nanograd/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":252488927,"owners_count":21756238,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["artificial-intelligence","autotrainer","chatbot","deep-learning","gpt","gradio","large-language-models","llama","pytorch","pytorch-lightning","stable-diffusion","vision-transformer"],"created_at":"2024-11-13T11:51:44.380Z","updated_at":"2025-05-05T11:30:59.205Z","avatar_url":"https://github.com/Esmail-ibraheem.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"\u003ch1 align=\"center\"\u003eNanograd Engine - AI Ecosystem\u003c/h1\u003e\n\n\n\nnanograd is a neural net engine (**_command line interface and python library_**) inspired by **[micrograd](https://github.com/karpathy/micrograd)** and **[tinygrad](https://github.com/tinygrad/tinygrad)**, built upon a PyTorch-like API. It aims to provide users with easy-to-use tools for creating and utilizing various **neural network architectures**, including `GPT`, `llama`, `stable diffusion`, and `transformers` from scratch in Python. This library also offers `comprehensive data processing capabilities` from model training to providing a robust toolkit for developing and fine-tuning large language models. As the fastest and most efficient repository for continued pre-training and fine-tuning GPTs, nanograd sets a new standard in AI research and development. \n\n\n\n\n                          +----------------------------------------------------------------------------+\n                          |     +----------------------------------------------------------------+     |\n                          |     | Developers: Esmail Gumaan/ ML Engineer.                        |     |\n                          |     | ( your Unreal Engine, but for AI, essentially making it an AI engine)|                \n                          |     |     +----------------------------------------------------+     |     |\n                          |     |     | Contributors: Those who wants to contribute        |     |     |\n                          |     |     | (You make PR to this repo)                         |     |     |\n                          |     |     +----------------------------------------------------+     |     |\n                          |     +----------------------------------------------------------------+     |\n                          +----------------------------------------------------------------------------+\n\n \n## nano Features\n\n| ✔️ | LlAMa                       | ✔️ | GPT                          | ✔️ | Stable diffusion            |\n|---|------------------------------|---|------------------------------|---|------------------------------|\n| ✔️ | Transformers                 | ✔️ | ollama | ✔️ | Dataset generator(ngram model)               |\n| ✔️ | Vision Transformer             | ✔️ | BioGPT | ✔️ | From scratch implementations|\n| ✔️ | Beginner friendly             | ✔️ | No Abstraction                        | ✔️ | pretraining and fine-tuning           |\n   \n\n\n\n\n\n\n**_Key Features highlight_**\n- **`Transformers from Scratch:`**\n  Implement GPT and llama [models](#models-implementation) from the ground up using Pytorch, offering full transparency and flexibility.\n\n- **`Neural Network engine for scalar:`**\n  Implementing mathematical operations similar to PyTorch, from addition to matrix multiplication (matmul), including ReLU and sigmoid activation functions, and training a simple feedforward neural network architecture\n\n- **`Custom Tokenization:`**\n  Implement a Byte Pair Encoding (BPE) tokenizer from scratch, tailored for the specific needs of your model and dataset.\n\n- **`Command-Line Interface:`**\n  Providing a command line interface (CLI) to easily access built-in models without writing any code, making it accessible for both programmers and regular users (:.\n\n- **`nanograd engine:`**\n  An interface using Gradio that allows users to easily use any model they want without writing a single line of code—similar to Unreal Engine, but for AI, essentially making it an AI engine.\n\n- **`Reinforcement Learning with gym environments:`**\n  Currently providing some cool applications such as Carpole, and Mountain car, BipedalWalker with gym environments from OpenAI, and this feature is built upon tinygrad.\n  \n![Windows PowerShell 2024-09-18 09-41-04](https://github.com/user-attachments/assets/11f24f8a-7ed9-4fdc-89b5-eb17e953ec74)\n\n\n\n\n---\n\n## [nano models](https://github.com/Esmail-ibraheem/nanograd/tree/main/nanograd/models):\n\nWhether you're working on text generation, image synthesis, image classification, or any other AI-driven task, nanograd models are designed to help you achieve your goals efficiently and effectively.\n\n### 1. **GPT**\n   The GPT (Generative Pre-trained Transformer) model implementation in nanograd is based on the transformer architecture. This model is designed to generate coherent and contextually relevant text based on a given input. It is a powerful tool for tasks such as text generation, completion, and more.\n\n### 2. **LLaMA**\n   LLaMA (Language Learning Model Architecture) is a sophisticated model designed to handle a variety of natural language processing (NLP) tasks. This implementation within nanograd provides an efficient and scalable way to work with large-scale language models, focusing on ease of use and performance.\n\n### 3. **Stable Diffusion**\n   The Stable Diffusion model in nanograd is tailored for generative tasks, particularly in creating images from textual descriptions. This model is optimized for both creativity and performance, enabling users to generate high-quality images in a streamlined process.\n\n### 4. **Vision Transformer (ViT)**\n   The Vision Transformer (ViT) is an innovative model that applies transformer architecture to image data. Unlike traditional convolutional neural networks (CNNs), ViT treats image patches as sequences, similar to how GPT processes text. This allows for powerful image classification capabilities, particularly in scenarios where large datasets are available for training.\n\n### 5. **Custom Models (Ollama models)**\n   In addition to the predefined models like GPT, LLaMA, Stable Diffusion, and Vision Transformer, this directory also serves as a repository for custom models built using the nanograd framework. Users are encouraged to contribute their models or adapt existing ones to fit their specific use cases.\n\n\n\n\n---\n\n## [nano nn engine](https://github.com/Esmail-ibraheem/nanograd/tree/main/nanograd/nn)\n\nThe `nn` directory in the **nanograd** library provides key components for building, training, and managing neural networks. This module is designed to offer a foundational setup for neural network operations, drawing inspiration from similar modules in established frameworks like PyTorch but tailored for the nanograd engine.\n\n### Key Components\n\n### 1. **Tensor Operations**\n   - **`tensor.py`**: This file includes core functionalities related to tensor operations within the nanograd framework. It defines the data structures and operations for tensors, which are the fundamental building blocks for any neural network model. This component is responsible for handling tensor creation, manipulation, and arithmetic operations, which are crucial for performing forward and backward passes in neural networks.\n\n### 2. **Neural Network Engine**\n   - **`engine.py`**: The `engine.py` file manages the neural network's computational engine, including the implementation of the forward and backward passes. It is responsible for orchestrating the training process, handling gradient calculations, and updating model parameters. This engine provides the infrastructure needed to perform efficient training and evaluation of neural network models, focusing on performance and scalability within the nanograd framework.\n\n### 3. **Training Utilities**\n   - **`train_nn.py`**: This file contains utilities and functions to facilitate the training of neural network models. It includes training loops, evaluation metrics, and optimization routines. `train_nn.py` is designed to simplify the process of training models, making it easier to experiment with different architectures and hyperparameters. It serves as a practical guide for setting up and executing training sessions.\n\n## Comparison to PyTorch\n\nThe `nn` module in nanograd provides similar functionalities to PyTorch’s `torch.nn` but with a streamlined and educational approach. Here’s how they compare:\n\n- **Tensor Operations:** Like PyTorch, nanograd’s `tensor.py` handles the core tensor operations, but it aims to offer a more transparent and simplified implementation for educational purposes.\n\n- **Neural Network Engine:** The `engine.py` file parallels PyTorch's `torch.autograd` and `torch.optim`, handling the essential computations and optimizations needed for training models. Nanograd’s engine focuses on efficiency and integration within the framework.\n\n- **Training Utilities:** `train_nn.py` offers training utilities similar to PyTorch’s training utilities but is designed to be straightforward and easy to understand, making it suitable for learning and experimenting with neural network training processes.\n\n\n-  **[autograd engine](https://github.com/Esmail-ibraheem/nanograd/tree/main/nanograd/nn)** provides a robust backpropagation mechanism over a dynamically constructed Directed Acyclic Graph (DAG). This tiny yet powerful engine mimics a PyTorch-like API, ensuring ease of use for those familiar with PyTorch.\n\n### Key Features\n\n- **Backpropagation over DAG**: The engine dynamically builds a DAG during the forward pass and performs backpropagation through this graph. The DAG operates over scalar values, breaking down each neuron into individual adds and multiplies.\n- **Minimalistic Design**: The autograd engine consists of approximately 100 lines of code, and the accompanying neural network library is around 50 lines, emphasizing simplicity and clarity.\n- **Educational Value**: This implementation, though minimal, is capable of constructing and training entire deep neural networks for tasks like binary classification. It's particularly useful for educational purposes, offering insights into the inner workings of backpropagation and neural networks.\n\n\n---\n\n## Get Started:\n### 1- as a library, And CLI:\n**clone the repo**\n```\ngit clone https://github.com/Esmail-ibraheem/nanograd.git\n```\n\n**installing it on your computer:**\n```\n./install.bat\n```\n\n- **_using it in your main file:_**\n  - **_nano models_**\n  \n  ```python\n  import nanograd\n\n  from nanograd.RL import Cartpole, car # import reinforcement learning package\n  # Cartpole.run()\n  # car.run()\n  \n  ###############################################################\n  from nanograd.models.stable_diffusion import sd_inference\n  sd_inference.run()\n  \n  ##############################################################\n  from nanograd.analysis_lab import sentiment_analysis\n  # sentiment_analysis.run()\n  \n  ############################################################\n  from nanograd import generate_dataset \n  \n  # generate_dataset.tokenize()\n  \n  ###########################################################\n  \n  from nanograd.models.llama import inference_llama \n  from nanograd.models.GPT import inference_gpt\n  from nanograd.models.GPT import tokenizer\n  \n  # inference_gpt.use_model()\n  \n  # inference_llama.use_model()\n  \n  # tokenizer.run_tokenizer()\n  ###########################################################\n  from nanograd.models import ollama\n  from nanograd.models import chat\n  # ollama.run() # test the model. \n  # chat.chat_with_models()\n  # chat.chat_models()\n  ###################################################\n  \n  \n  # if __name__ == \"__main__\":\n  #     from nanograd.nn.engine import Value\n  \n  #     a = Value(-4.0)\n  #     b = Value(2.0)\n  #     c = a + b\n  #     d = a + b + b**3\n  #     c += c + 1\n  #     c += 1 + c + (-a)\n  #     d += d * 2 + (b + a).relu()\n  #     d += 3 * d + (b - a).relu()\n  #     d += 3 * d + (b - a).sigmoid(5)\n  #     e = c - d\n  #     f = e**2\n  #     g = f / 2.0\n  #     g += 10.0 / f\n  #     print(f'{g.data:.4f}') \n  #     g.backward()\n  #     print(f'{a.grad:.4f}') \n  #     print(f'{b.grad:.4f}')  \n  #     print(f'{e.grad:.4f}')  \n  \n  \n  # import nanograd.nn.train_nn\n  ```\n\n   - **_nanograd and Pytorch Comparison:_**\n     \n     - **nanograd**\n  \n     ```python\n     from nanograd.nn.tensor import Tensor\n\n     # Create tensors with gradient tracking enabled\n     a = Tensor([[1.0, 2.0], [3.0, 4.0]], requires_grad=True)\n     b = Tensor([[5.0, 6.0], [7.0, 8.0]], requires_grad=True)\n     \n     # Perform some tensor operations\n     c = a + b  # Element-wise addition\n     d = a * b  # Element-wise multiplication\n     e = c.sum()  # Sum all elements of the result of addition\n     \n     # Compute gradients\n     e.backward()\n     \n     # Print the results and gradients\n     print(\"Tensor a:\")\n     print(a.numpy())\n     print(\"Tensor b:\")\n     print(b.numpy())\n     print(\"Result of a + b:\")\n     print(c.numpy())\n     print(\"Result of a * b:\")\n     print(d.numpy())\n     print(\"Gradient of a:\")\n     print(a.grad.numpy())\n     print(\"Gradient of b:\")\n     print(b.grad.numpy())\n\n     ```\n     - **Pytorch**\n     \n     ```python\n     import torch\n\n     # Create tensors with gradient tracking enabled\n     a = torch.tensor([[1.0, 2.0], [3.0, 4.0]], requires_grad=True)\n     b = torch.tensor([[5.0, 6.0], [7.0, 8.0]], requires_grad=True)\n     \n     # Perform some tensor operations\n     c = a + b  # Element-wise addition\n     d = a * b  # Element-wise multiplication\n     e = c.sum()  # Sum all elements of the result of addition\n     \n     # Compute gradients\n     e.backward()\n     \n     # Print the results and gradients\n     print(\"Tensor a:\")\n     print(a)\n     print(\"Tensor b:\")\n     print(b)\n     print(\"Result of a + b:\")\n     print(c)\n     print(\"Result of a * b:\")\n     print(d)\n     print(\"Gradient of a:\")\n     print(a.grad)\n     print(\"Gradient of b:\")\n     print(b.grad)\n\n     ```   \n\n\n- **_using it in your terminal:_**\n\n**then type this command on your terminal: `nanograd`**\n**_the output should be something like this_**\n```\n██     ██     ███     ██      ██  ████████     ██████   ████████       ███       ████████\n███    ██   ██   ██   ███     ██ ██      ██   ██   ██   ██     ██    ██   ██     ██      ██\n████   ██  ██     ██  ████    ██ ██      ██  ██         ██     ██   ██      ██   ██       ██\n██ ██  ██ ██       ██ ██  ██  ██ ██      ██  ██  ████   ████████   ██        ██  ██       ██\n██   ████ ███████████ ██    ████ ██      ██  ██    ██   ██    ██   ████████████  ██       ██\n██    ███ ██       ██ ██      ██ ██      ██  ██    ██   ██    ██   ██        ██  ██      ██\n██     ██ ██       ██ ██      ██  ████████    ██████    ██     ██  ██        ██  ████████\n+----------------------------------------------------------------------------+\n|     +----------------------------------------------------------------+     |\n|     | Developers: Esmail Gumaan/ ML Engineer.                        |     |\n|     | ( your Unreal Engine, but for AI, essentially making it an AI engine)|\n|     |     +----------------------------------------------------+     |     |\n|     |     | Contributors: Those who wants to contribute        |     |     |\n|     |     | (You make PR to this repo)                         |     |     |\n|     |     +----------------------------------------------------+     |     |\n|     +----------------------------------------------------------------+     |\n+----------------------------------------------------------------------------+\nNanograd-Engine🧠 Creator: Esmail Gumaan (The Mozart of AI and Mathematics (: ))\nusage: nanograd [-h] {install,generate,download,pretrain,run_gpt,run_llama,run_engine,run_diffusion,run} ...\n\nNanograd CLI\n\npositional arguments:\n  {install,generate,download,pretrain,run_gpt,run_llama,run_engine,run_diffusion,run}\n                        Sub-commands\n    install             Install dependencies\n    generate            Generate datasets\n    download            Download checkpoints or llama\n    pretrain            Pretrain a model\n    run_gpt             Run GPT inference\n    run_llama           Run LLaMA inference\n    run_engine          Run engine interface\n    run_diffusion       Run Stable Diffusion\n    run                 Run model inference\n\noptions:\n  -h, --help            show this help message and exit\n```\n\n\n\n\u003e [!NOTE]\n\u003e You can use the nanograd library in your CLI, after installing it on your computer using `pip install -e`. then you can run any model you want,\n\u003e here are some commands to run in the terminal\n\n| command | Sub-command | type this |\n|---------|-------------|-----------|\n| install | install dependencies | `nanograd install ollama` |\n| download | download checkpoints or llama | `nanograd download checkpoint micorosoft/phi-2` or `nanograd download llama` | \n| run_gpt | run gpt inference | `nanograd run_gpt` | \n| run_llama | run llama inference | `nanograd run_llama` |\n| run | run model inference (ollama models) | `nanograd run llama3.1` |\n| run_diffusion | run stable diffusion | `nanograd run_diffusion stable_diffusion` |\n| run_engine | run engine interface | `nanograd run_engine` |\n\n\n## 2- [as an engine](https://github.com/Esmail-ibraheem/nanograd-engine/blob/main/nano_engine.py):\nin this feature you can do all you can do in the CLI feature but with an interface, you do not need to type anything just some clicks.\n- run stable diffusion\n- run ollama models\n- blueprints to generate different stories each time for the LLMs and stable diffusion\n- download checkpoints using litgpt\n- install ollama\n  run this command\\\n   `python nano_engine.py`\n- generating story themes from pre-made blueprints\n![image](https://github.com/user-attachments/assets/1f27cc7c-c7d6-4290-8aa4-3798aafa99dc)\n\n\n- multimodal chatbot\n    - prompted-chatbot \n    - run BPE tokenizer\n    - RAG chatbot\n    - vision transformer\n\n![image](https://github.com/user-attachments/assets/830d2961-f5b1-4633-acc2-97372055740e)\n![image](https://github.com/user-attachments/assets/7084e557-fb84-4732-ab7e-83de4d8f9887)\n\n\n\n\n- AutoTrainer (**`LLama-Factory`**) with bilingual supported languages: Arabic and English\n  ![image](https://github.com/user-attachments/assets/30a696c8-501f-47ed-9f78-a0c0a5a217ee)\n\n- AutoCoder (**Copilot**) code editor with AI for helping in coding\n  ![image](https://github.com/user-attachments/assets/a99932d2-1107-4567-9eac-95c74f84c7bd)\n\n\n\n\n### 3- as an API:**still in developing process**\nrun this command `python nanograd_API.py`;.;.\n\n\u003e [!IMPORTANT]\n\u003e you can't run any of this unless you do downloaded the checkpoints before, for the litgpt you can download their models(Checkpoints) after you installed the library run this `nanograd download checkpoints`, for the ollama models also the same, for the stable diffusion download them from huggingface.  \n\n---\n\n## ToDo:\n\n- [ ] Path Management for other OSs.\n- [ ] Parallelization: multiprocessing.\n- [ ] Cuda Support.\n     - [ ] rebuild the engine using C++. \n- [ ] vision transformer.\n- [ ] 3D Tobia XL.\n- [ ] memory efficient weight loading.\n- [ ] AI Mathematician.\n- [ ] Gamengen: games generation.\n- [x] stable diffusion.\n- [x] ollama models support.\n- [x] llama.\n     - [x] transformer architecture \n- [x] GPT.\n     - [x] litGPT checkpoints installation\n     - [x] GPT Architecture\n     - [x] transformer architecture   \n- [x] AutoTrainer.\n- [x] AutoCoder (**Copilot**).\n\n\n\n---\n\n## Contributing\nWe welcome contributions from the community. if you want to contribute just by:\n- adding models built from scratch to make them accessible without the internet needed (offline).\n- Fix some issues, if there are any, or fix something you discovered, and explain what you are trying to fix and why.\n- solving or building one of the ToDos list \n\n## License\nThis project is licensed under the MIT License. See the [LICENSE file](https://github.com/Esmail-ibraheem/omniGPT?tab=MIT-1-ov-file#) for more details.\n\n---\n\n## Citations\n```BibTex \n@misc{Gumaan2024-nanograd,\n  title   = \"nanograd\",\n  author  = \"Gumaan, Esmail\",\n  howpublished = {\\url{https://github.com/Esmail-ibraheem/nanograd}},\n  year    = \"2024\",\n  month   = \"May\",\n  note    = \"[Online; accessed 2024-05-24]\",\n}\n```\n\n\n---\n\n## Notes and Acknowledgments\n- [Hugging-Face Transformers](https://github.com/huggingface/transformers)\n- [Lightning AI](https://github.com/Lightning-AI)\n- [Karpathy's miniGPT](https://github.com/karpathy/minGPT)\n- [GeoHotz's tinygrad](https://github.com/tinygrad/tinygrad)\n- [OpenAI for pioneering the GPT architecture](https://www.bing.com/ck/a?!\u0026\u0026p=9a9de5d499443c51JmltdHM9MTcyNzkxMzYwMCZpZ3VpZD0zMWRiYzRjZS1mZDI5LTY0Y2QtMmIxNy1kNTM1ZmM3YjY1ZjYmaW5zaWQ9NTQ4MQ\u0026ptn=3\u0026ver=2\u0026hsh=3\u0026fclid=31dbc4ce-fd29-64cd-2b17-d535fc7b65f6\u0026psq=gpt+model+paper\u0026u=a1aHR0cHM6Ly9jZG4ub3BlbmFpLmNvbS9yZXNlYXJjaC1jb3ZlcnMvbGFuZ3VhZ2UtdW5zdXBlcnZpc2VkL2xhbmd1YWdlX3VuZGVyc3RhbmRpbmdfcGFwZXIucGRm\u0026ntb=1)\n- [Meta for pioneering the Llama architecture](https://www.bing.com/ck/a?!\u0026\u0026p=a6ef05b712210c58JmltdHM9MTcyNzkxMzYwMCZpZ3VpZD0zMWRiYzRjZS1mZDI5LTY0Y2QtMmIxNy1kNTM1ZmM3YjY1ZjYmaW5zaWQ9NTIwNQ\u0026ptn=3\u0026ver=2\u0026hsh=3\u0026fclid=31dbc4ce-fd29-64cd-2b17-d535fc7b65f6\u0026psq=llama+paper\u0026u=a1aHR0cHM6Ly9hcnhpdi5vcmcvYWJzLzIzMDIuMTM5NzE\u0026ntb=1)\n- [hiyouga-PhD](https://github.com/hiyouga)\n\n\u003e [!NOTE]\n\u003e **nanograd** was developed with a specific vision and purpose in mind. This section provides insight into the motivations behind its creation and the approach taken during its development. The primary motivation for developing nanograd was to create a framework that emphasizes simplicity and transparency in neural network design and training. While many existing frameworks, such as PyTorch and TensorFlow, offer extensive features and optimizations, they can also be complex and challenging to fully understand, particularly for those new to deep learning or for educational purposes. nanograd aims to simplify access to models like GPT, LLaMA, Stable Diffusion, and others, making these technologies more approachable and easier to work with.\n\n---\n\n## Contact\nFor any inquiries or feedback, please open an issue on GitHub or reach out to the project maintainer at esm.agumaan@gmail.com.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fesmail-ibraheem%2Fnanograd","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fesmail-ibraheem%2Fnanograd","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fesmail-ibraheem%2Fnanograd/lists"}