Initial commit for Hugging Face sync (Clean History)

.gitattributes

@@ -0,0 +1,11 @@
+*.ipynb filter=lfs diff=lfs merge=lfs -text
+*.JPG filter=lfs diff=lfs merge=lfs -text
+*.JPEG filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.PNG filter=lfs diff=lfs merge=lfs -text
+/ColorizeVisualization.ipynb filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text

.github/CODEOWNERS

@@ -0,0 +1,4 @@
+# See: https://help.github.com/en/articles/about-code-owners
+#
+# Owners will be requested for review when someone opens a pull request.
+*       @jantic @alexandrevicenzi

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '...'
+3. Scroll down to '...'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Browser [e.g. chrome, safari]
+ - Version [e.g. 22]
+
+**Smartphone (please complete the following information):**
+ - Device: [e.g. iPhone6]
+ - OS: [e.g. iOS8.1]
+ - Browser [e.g. stock browser, safari]
+ - Version [e.g. 22]
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,38 @@
+## Description
+
+Please include a summary of the change and which issue is fixed. Please also include relevant motivation and context. List any dependencies that are required for this change.
+
+Fixes # (issue)
+
+## Type of change
+
+Please delete options that are not relevant.
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] This change requires a documentation update
+
+## How Has This Been Tested?
+
+Please describe the tests that you ran to verify your changes. Provide instructions so we can reproduce. Please also list any relevant details for your test configuration
+
+- [ ] Test A
+- [ ] Test B
+
+**Test Configuration**:
+* Firmware version:
+* Hardware:
+* Toolchain:
+* SDK:
+
+## Checklist:
+
+- [ ] My code follows the style guidelines of this project
+- [ ] I have performed a self-review of my own code
+- [ ] I have commented my code, particularly in hard-to-understand areas
+- [ ] I have made corresponding changes to the documentation
+- [ ] My changes generate no new warnings
+- [ ] I have added tests that prove my fix is effective or that my feature works
+- [ ] New and existing unit tests pass locally with my changes
+- [ ] Any dependent changes have been merged and published in downstream modules

.gitignore

@@ -0,0 +1,153 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+# DeOldify
+data
+*SymbolicLinks.sh
+*.ipynb_checkpoints*
+ColorizeTraining*[0-9]*.ipynb
+*Colorizer[0-9]*.ipynb
+lesson7-superres*.ipynb
+test.py
+result_images
+*.prof
+video
+test_images/*.jpg
+test_images/*.JPG
+test_images/*.PNG
+test_images/*.png
+test_images/*.jpeg
+test_images/*.JPEG 
+deoldify/.ipynb_checkpoints/*-checkpoint.py
+tmp*
+
+# Model weights and checkpoints
+models/*.pth
+models/*.pt
+*.pth
+*.pt
+checkpoints/
+
+# Logs and debugging
+logs/
+*.log
+wandb/
+.tensorboard/
+
+# Output directories
+output/
+results/
+colorized/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db

.pre-commit-config.yaml

@@ -0,0 +1,7 @@
+repos:
+-   repo: https://github.com/ambv/black
+    rev: stable
+    hooks:
+    - id: black
+      args: [-S]
+      language_version: python3.6

.pylintrc

@@ -0,0 +1,579 @@
+[MASTER]
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code.
+extension-pkg-whitelist=
+
+# Add files or directories to the blacklist. They should be base names, not
+# paths.
+ignore=CVS
+
+# Add files or directories matching the regex patterns to the blacklist. The
+# regex matches against base names, not paths.
+ignore-patterns=
+
+# Python code to execute, usually for sys.path manipulation such as
+# pygtk.require().
+#init-hook='import sys; sys.path.append("./venv/lib/python3.7/site-packages")'
+
+# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the
+# number of processors available to use.
+jobs=1
+
+# Control the amount of potential inferred values when inferring a single
+# object. This can help the performance when dealing with large functions or
+# complex, nested conditions.
+limit-inference-results=100
+
+# List of plugins (as comma separated values of python modules names) to load,
+# usually to register additional checkers.
+load-plugins=
+
+# Pickle collected data for later comparisons.
+persistent=yes
+
+# Specify a configuration file.
+#rcfile=
+
+# When enabled, pylint would attempt to guess common misconfiguration and emit
+# user-friendly hints instead of false-positive error messages.
+suggestion-mode=yes
+
+# Allow loading of arbitrary C extensions. Extensions are imported into the
+# active Python interpreter and may run arbitrary code.
+unsafe-load-any-extension=no
+
+
+[MESSAGES CONTROL]
+
+# Only show warnings with the listed confidence levels. Leave empty to show
+# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED.
+confidence=
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifiers separated by comma (,) or put this
+# option multiple times (only on the command line, not in the configuration
+# file where it should appear only once). You can also use "--disable=all" to
+# disable everything first and then reenable specific checks. For example, if
+# you want to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use "--disable=all --enable=classes
+# --disable=W".
+disable=print-statement,
+        parameter-unpacking,
+        unpacking-in-except,
+        old-raise-syntax,
+        backtick,
+        long-suffix,
+        old-ne-operator,
+        old-octal-literal,
+        import-star-module-level,
+        non-ascii-bytes-literal,
+        raw-checker-failed,
+        bad-inline-option,
+        locally-disabled,
+        locally-enabled,
+        file-ignored,
+        suppressed-message,
+        useless-suppression,
+        deprecated-pragma,
+        use-symbolic-message-instead,
+        apply-builtin,
+        basestring-builtin,
+        buffer-builtin,
+        cmp-builtin,
+        coerce-builtin,
+        execfile-builtin,
+        file-builtin,
+        long-builtin,
+        raw_input-builtin,
+        reduce-builtin,
+        standarderror-builtin,
+        unicode-builtin,
+        xrange-builtin,
+        coerce-method,
+        delslice-method,
+        getslice-method,
+        setslice-method,
+        no-absolute-import,
+        old-division,
+        dict-iter-method,
+        dict-view-method,
+        next-method-called,
+        metaclass-assignment,
+        indexing-exception,
+        raising-string,
+        reload-builtin,
+        oct-method,
+        hex-method,
+        nonzero-method,
+        cmp-method,
+        input-builtin,
+        round-builtin,
+        intern-builtin,
+        unichr-builtin,
+        map-builtin-not-iterating,
+        zip-builtin-not-iterating,
+        range-builtin-not-iterating,
+        filter-builtin-not-iterating,
+        using-cmp-argument,
+        eq-without-hash,
+        div-method,
+        idiv-method,
+        rdiv-method,
+        exception-message-attribute,
+        invalid-str-codec,
+        sys-max-int,
+        bad-python3-import,
+        deprecated-string-function,
+        deprecated-str-translate-call,
+        deprecated-itertools-function,
+        deprecated-types-field,
+        next-method-defined,
+        dict-items-not-iterating,
+        dict-keys-not-iterating,
+        dict-values-not-iterating,
+        deprecated-operator-function,
+        deprecated-urllib-function,
+        xreadlines-attribute,
+        deprecated-sys-function,
+        exception-escape,
+        comprehension-escape,
+        # Disabled due Black
+        bad-continuation,
+        bad-whitespace,
+        # We don't care about these
+        redundant-keyword-arg,
+
+# Enable the message, report, category or checker with the given id(s). You can
+# either give multiple identifier separated by comma (,) or put this option
+# multiple time (only on the command line, not in the configuration file where
+# it should appear only once). See also the "--disable" option for examples.
+enable=c-extension-no-member
+
+
+[REPORTS]
+
+# Python expression which should return a note less than 10 (10 is the highest
+# note). You have access to the variables errors warning, statement which
+# respectively contain the number of errors / warnings messages and the total
+# number of statements analyzed. This is used by the global evaluation report
+# (RP0004).
+evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
+
+# Template used to display messages. This is a python new-style format string
+# used to format the message information. See doc for all details.
+#msg-template=
+
+# Set the output format. Available formats are text, parseable, colorized, json
+# and msvs (visual studio). You can also give a reporter class, e.g.
+# mypackage.mymodule.MyReporterClass.
+output-format=text
+
+# Tells whether to display a full report or only the messages.
+reports=no
+
+# Activate the evaluation score.
+score=yes
+
+
+[REFACTORING]
+
+# Maximum number of nested blocks for function / method body
+max-nested-blocks=5
+
+# Complete name of functions that never returns. When checking for
+# inconsistent-return-statements if a never returning function is called then
+# it will be considered as an explicit return statement and no message will be
+# printed.
+never-returning-functions=sys.exit
+
+
+[LOGGING]
+
+# Logging modules to check that the string format arguments are in logging
+# function parameter format.
+logging-modules=logging
+
+
+[SIMILARITIES]
+
+# Ignore comments when computing similarities.
+ignore-comments=yes
+
+# Ignore docstrings when computing similarities.
+ignore-docstrings=yes
+
+# Ignore imports when computing similarities.
+ignore-imports=no
+
+# Minimum lines number of a similarity.
+min-similarity-lines=4
+
+
+[MISCELLANEOUS]
+
+# List of note tags to take in consideration, separated by a comma.
+notes=FIXME,
+      XXX,
+      TODO
+
+
+[FORMAT]
+
+# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
+expected-line-ending-format=
+
+# Regexp for a line that is allowed to be longer than the limit.
+ignore-long-lines=^\s*(# )?<?https?://\S+>?$
+
+# Number of spaces of indent required inside a hanging  or continued line.
+indent-after-paren=4
+
+# String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
+# tab).
+indent-string='    '
+
+# Maximum number of characters on a single line.
+max-line-length=100
+
+# Maximum number of lines in a module.
+max-module-lines=1000
+
+# List of optional constructs for which whitespace checking is disabled. `dict-
+# separator` is used to allow tabulation in dicts, etc.: {1  : 1,\n222: 2}.
+# `trailing-comma` allows a space between comma and closing bracket: (a, ).
+# `empty-line` allows space-only lines.
+no-space-check=trailing-comma,
+               dict-separator
+
+# Allow the body of a class to be on the same line as the declaration if body
+# contains single statement.
+single-line-class-stmt=no
+
+# Allow the body of an if to be on the same line as the test if there is no
+# else.
+single-line-if-stmt=no
+
+
+[BASIC]
+
+# Naming style matching correct argument names.
+argument-naming-style=snake_case
+
+# Regular expression matching correct argument names. Overrides argument-
+# naming-style.
+#argument-rgx=
+
+# Naming style matching correct attribute names.
+attr-naming-style=snake_case
+
+# Regular expression matching correct attribute names. Overrides attr-naming-
+# style.
+#attr-rgx=
+
+# Bad variable names which should always be refused, separated by a comma.
+bad-names=foo,
+          bar,
+          baz,
+          toto,
+          tutu,
+          tata
+
+# Naming style matching correct class attribute names.
+class-attribute-naming-style=any
+
+# Regular expression matching correct class attribute names. Overrides class-
+# attribute-naming-style.
+#class-attribute-rgx=
+
+# Naming style matching correct class names.
+class-naming-style=PascalCase
+
+# Regular expression matching correct class names. Overrides class-naming-
+# style.
+#class-rgx=
+
+# Naming style matching correct constant names.
+const-naming-style=UPPER_CASE
+
+# Regular expression matching correct constant names. Overrides const-naming-
+# style.
+#const-rgx=
+
+# Minimum line length for functions/classes that require docstrings, shorter
+# ones are exempt.
+docstring-min-length=-1
+
+# Naming style matching correct function names.
+function-naming-style=snake_case
+
+# Regular expression matching correct function names. Overrides function-
+# naming-style.
+#function-rgx=
+
+# Good variable names which should always be accepted, separated by a comma.
+good-names=f,
+           i,
+           j,
+           k,
+           s,
+           t,
+           ex,
+           Run,
+           _
+
+# Include a hint for the correct naming format with invalid-name.
+include-naming-hint=no
+
+# Naming style matching correct inline iteration names.
+inlinevar-naming-style=any
+
+# Regular expression matching correct inline iteration names. Overrides
+# inlinevar-naming-style.
+#inlinevar-rgx=
+
+# Naming style matching correct method names.
+method-naming-style=snake_case
+
+# Regular expression matching correct method names. Overrides method-naming-
+# style.
+#method-rgx=
+
+# Naming style matching correct module names.
+module-naming-style=snake_case
+
+# Regular expression matching correct module names. Overrides module-naming-
+# style.
+#module-rgx=
+
+# Colon-delimited sets of names that determine each other's naming style when
+# the name regexes allow several styles.
+name-group=
+
+# Regular expression which should only match function or class names that do
+# not require a docstring.
+no-docstring-rgx=^_
+
+# List of decorators that produce properties, such as abc.abstractproperty. Add
+# to this list to register other decorators that produce valid properties.
+# These decorators are taken in consideration only for invalid-name.
+property-classes=abc.abstractproperty
+
+# Naming style matching correct variable names.
+variable-naming-style=snake_case
+
+# Regular expression matching correct variable names. Overrides variable-
+# naming-style.
+variable-rgx=_?[a-z][A-Za-z0-9_]{0,30}$
+argument-rgx=_?[a-z][A-Za-z0-9_]{0,30}$
+
+
+[TYPECHECK]
+
+# List of decorators that produce context managers, such as
+# contextlib.contextmanager. Add to this list to register other decorators that
+# produce valid context managers.
+contextmanager-decorators=contextlib.contextmanager
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E1101 when accessed. Python regular
+# expressions are accepted.
+generated-members=torch.mm,
+                  torch.diag,
+                  torch.symeig,
+                  torch.sqrt,
+                  torch.cat,
+                  cv2.cvtColor,
+                  cv2.COLOR_BGR2YUV,
+                  cv2.COLOR_YUV2BGR,
+
+# Tells whether missing members accessed in mixin class should be ignored. A
+# mixin class is detected if its name ends with "mixin" (case insensitive).
+ignore-mixin-members=yes
+
+# Tells whether to warn about missing members when the owner of the attribute
+# is inferred to be None.
+ignore-none=yes
+
+# This flag controls whether pylint should warn about no-member and similar
+# checks whenever an opaque object is returned when inferring. The inference
+# can return multiple potential results while evaluating a Python object, but
+# some branches might not be evaluated, which results in partial inference. In
+# that case, it might be useful to still emit no-member and other checks for
+# the rest of the inferred objects.
+ignore-on-opaque-inference=yes
+
+# List of class names for which member attributes should not be checked (useful
+# for classes with dynamically set attributes). This supports the use of
+# qualified names.
+ignored-classes=optparse.Values,thread._local,_thread._local
+
+# List of module names for which member attributes should not be checked
+# (useful for modules/projects where namespaces are manipulated during runtime
+# and thus existing member attributes cannot be deduced by static analysis. It
+# supports qualified module names, as well as Unix pattern matching.
+ignored-modules=
+
+# Show a hint with possible names when a member name was not found. The aspect
+# of finding the hint is based on edit distance.
+missing-member-hint=yes
+
+# The minimum edit distance a name should have in order to be considered a
+# similar match for a missing member name.
+missing-member-hint-distance=1
+
+# The total number of similar names that should be taken in consideration when
+# showing a hint for a missing member.
+missing-member-max-choices=1
+
+
+[VARIABLES]
+
+# List of additional names supposed to be defined in builtins. Remember that
+# you should avoid to define new builtins when possible.
+additional-builtins=
+
+# Tells whether unused global variables should be treated as a violation.
+allow-global-unused-variables=yes
+
+# List of strings which can identify a callback function by name. A callback
+# name must start or end with one of those strings.
+callbacks=cb_,
+          _cb
+
+# A regular expression matching the name of dummy variables (i.e. expected to
+# not be used).
+dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_
+
+# Argument names that match this expression will be ignored. Default to name
+# with leading underscore.
+ignored-argument-names=_.*|^ignored_|^unused_
+
+# Tells whether we should check for unused import in __init__ files.
+init-import=no
+
+# List of qualified module names which can have objects that can redefine
+# builtins.
+redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io
+
+
+[SPELLING]
+
+# Limits count of emitted suggestions for spelling mistakes.
+max-spelling-suggestions=4
+
+# Spelling dictionary name. Available dictionaries: en_IE (myspell), en_ZM
+# (myspell), en_GB (myspell), en_HK (myspell), en_BZ (myspell), en_PH
+# (myspell), en_ZA (myspell), en_MW (myspell), en_AU (myspell), en_CA
+# (myspell), en_JM (myspell), en_GH (myspell), en_TT (myspell), en_SG
+# (myspell), en_BW (myspell), en_US (myspell), en_NZ (myspell), en_AG
+# (myspell), en_ZW (myspell), en_NA (myspell), en_IN (myspell), en_BS
+# (myspell), en_DK (myspell), en_NG (myspell)..
+spelling-dict=
+
+# List of comma separated words that should not be checked.
+spelling-ignore-words=
+
+# A path to a file that contains private dictionary; one word per line.
+spelling-private-dict-file=
+
+# Tells whether to store unknown words to indicated private dictionary in
+# --spelling-private-dict-file option instead of raising a message.
+spelling-store-unknown-words=no
+
+
+[IMPORTS]
+
+# Allow wildcard imports from modules that define __all__.
+allow-wildcard-with-all=no
+
+# Analyse import fallback blocks. This can be used to support both Python 2 and
+# 3 compatible code, which means that the block might have code that exists
+# only in one or another interpreter, leading to false positives when analysed.
+analyse-fallback-blocks=no
+
+# Deprecated modules which should not be used, separated by a comma.
+deprecated-modules=optparse,tkinter.tix
+
+# Create a graph of external dependencies in the given file (report RP0402 must
+# not be disabled).
+ext-import-graph=
+
+# Create a graph of every (i.e. internal and external) dependencies in the
+# given file (report RP0402 must not be disabled).
+import-graph=
+
+# Create a graph of internal dependencies in the given file (report RP0402 must
+# not be disabled).
+int-import-graph=
+
+# Force import order to recognize a module as part of the standard
+# compatibility libraries.
+known-standard-library=
+
+# Force import order to recognize a module as part of a third party library.
+known-third-party=enchant
+
+
+[CLASSES]
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,
+                      __new__,
+                      setUp
+
+# List of member names, which should be excluded from the protected access
+# warning.
+exclude-protected=_asdict,
+                  _fields,
+                  _replace,
+                  _source,
+                  _make
+
+# List of valid names for the first argument in a class method.
+valid-classmethod-first-arg=cls
+
+# List of valid names for the first argument in a metaclass class method.
+valid-metaclass-classmethod-first-arg=cls
+
+
+[DESIGN]
+
+# Maximum number of arguments for function / method.
+max-args=5
+
+# Maximum number of attributes for a class (see R0902).
+max-attributes=7
+
+# Maximum number of boolean expressions in an if statement.
+max-bool-expr=5
+
+# Maximum number of branch for function / method body.
+max-branches=12
+
+# Maximum number of locals for function / method body.
+max-locals=15
+
+# Maximum number of parents for a class (see R0901).
+max-parents=7
+
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=20
+
+# Maximum number of return / yield for function / method body.
+max-returns=6
+
+# Maximum number of statements in function / method body.
+max-statements=50
+
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=2
+
+
+[EXCEPTIONS]
+
+# Exceptions that will emit a warning when being caught. Defaults to
+# "Exception".
+overgeneral-exceptions=Exception

.travis.yml

@@ -0,0 +1,10 @@
+sudo: false
+language: python
+install: pip install tox
+matrix:
+  include:
+  - python: "3.6"
+    env: TOX_ENV=static
+  - python: "3.6"
+    env: TOX_ENV=format
+script: tox -e $TOX_ENV

CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [2.0.0] - 2025-12-01
+
+### Added
+- **Intel GPU Support**: Added support for Intel Arc and Data Center GPUs using Intel Extension for PyTorch (IPEX).
+- **Unified Device Management**: Implemented `deoldify.device` to automatically detect and manage CUDA, XPU (Intel), and CPU devices.
+- **Documentation**:
+    - `docs/nvidia_setup.md`: Comprehensive guide for setting up NVIDIA GPUs with CUDA 12.x.
+    - `docs/intel_gpu_setup.md`: Guide for setting up Intel GPUs.
+- **Verification Script**: Added `verify_refactor.py` to validate environment setup and model instantiation.
+- **Compatibility Layer**: Created `deoldify/fastai_compat.py` to replace the obsolete `fastai` 1.x library, ensuring compatibility with modern PyTorch.
+- **Requirements Files**: Added `requirements.txt` and `requirements_intel.txt` for pip users.
+- **Code Quality**:
+    - Comprehensive module docstring for `fastai_compat.py`.
+    - Type hints throughout compatibility layer.
+    - README badges for Python, PyTorch, CUDA versions, and license.
+
+### Changed
+- **Core Dependencies**:
+    - Removed dependency on `fastai` 1.x.
+    - Upgraded PyTorch to 2.5+.
+    - Upgraded CUDA support to 12.x.
+    - Updated `environment.yml` for modern NVIDIA environments.
+    - Created `environment_intel.yml` for Intel environments.
+- **Refactoring**:
+    - Refactored `visualize.py`, `filters.py`, `generators.py`, `unet.py`, and `layers.py` to use pure PyTorch and the new compatibility layer.
+    - Replaced FastAI-specific image processing with standard `torchvision` transforms.
+- **Device Handling**: Updated `Learner` and `DataBunch` shims to use the new unified device manager.
+- **.gitignore**: Enhanced to exclude model weights in `models/` directory, logs, IDE files, and OS-specific files.
+
+### Removed
+- **Legacy Code**: Removed direct imports of `fastai` throughout the codebase.
+- **Archived Status**: The project is now actively maintained for modern hardware.

CODE_OF_CONDUCT.md

@@ -0,0 +1,125 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex, gender characteristics,
+gender identity and expression, level of experience, education, socio-economic
+status, nationality, personal appearance, race, caste, color, religion, or
+sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity

CONTRIBUTING.md

@@ -0,0 +1,90 @@
+# Contributing to DeOldify
+
+First off, thanks for taking the time to contribute! ❤️
+
+All types of contributions are encouraged and valued. See the [Table of Contents](#table-of-contents) for different ways to help and details about how this project handles them. Please make sure to read the relevant section before making your contribution. It will make it a lot easier for us maintainers and smooth out the experience for all involved. The community looks forward to your contributions. 🎉
+
+> And if you like the project, but just don't have time to contribute, that's fine. There are other easy ways to support the project and show your appreciation, which we would also be very happy about:
+> - Star the project
+> - Tweet about it
+> - Refer this project in your project's readme
+> - Mention the project at local meetups and tell your friends/colleagues
+
+## Table of Contents
+
+- [Code of Conduct](#code-of-conduct)
+- [I Have a Question](#i-have-a-question)
+- [I Want To Contribute](#i-want-to-contribute)
+  - [Reporting Bugs](#reporting-bugs)
+  - [Suggesting Enhancements](#suggesting-enhancements)
+
+## Code of Conduct
+
+This project and everyone participating in it is governed by the
+[DeOldify Code of Conduct](CODE_OF_CONDUCT.md).
+By participating, you are expected to uphold this code. Please report unacceptable behavior
+to the project maintainers.
+
+## I Have a Question
+
+> If you want to ask a question, we assume that you have read the available [Documentation](README.md).
+
+Before you ask a question, it is best to search for existing [Issues](https://github.com/thookham/DeOldify/issues) that might help you. In case you have found a suitable issue and still need clarification, you can write your question in this issue. It is also advisable to search the internet for answers first.
+
+If you then still feel the need to ask a question and need clarification, we recommend the following:
+
+- Open an [Issue](https://github.com/thookham/DeOldify/issues/new).
+- Provide as much context as you can about what you're running into.
+- Provide project and platform versions (Python version, PyTorch version, CUDA version, etc), depending on what seems relevant.
+
+We will then take care of the issue as soon as possible.
+
+## I Want To Contribute
+
+### Reporting Bugs
+
+#### Before Submitting a Bug Report
+
+A good bug report shouldn't leave others needing to chase you up for more information. Therefore, we ask you to investigate carefully, collect information and describe the issue in detail in your report. Please complete the following steps in advance to help us fix any potential bug as fast as possible.
+
+- Make sure that you are using the latest version.
+- Determine if your bug is really a bug and not an error on your side e.g. using incompatible environment components/versions (Make sure that you have read the [documentation](README.md). If you are looking for support, you might want to check [this section](#i-have-a-question)).
+- To see if other users have experienced (and potentially already solved) the same issue you are having, check if there is not already a bug report existing for your bug or error in the [bug tracker](https://github.com/thookham/DeOldify/issues?q=label%3Abug).
+- Also make sure to search the internet (including Stack Overflow) to see if users outside of the GitHub community have discussed the issue.
+- Collect information about the bug:
+  - Stack trace (Traceback)
+  - OS, Platform and Version (Windows, Linux, macOS)
+  - Python version, PyTorch version, CUDA version
+  - GPU model and driver version
+  - Possibly your input and the output
+  - Can you reliably reproduce the issue? And can you also reproduce it with older versions?
+
+#### How to Submit a Good Bug Report
+
+We use GitHub issues to track bugs and errors. If you run into an issue with the project:
+
+- Open an [Issue](https://github.com/thookham/DeOldify/issues/new). (Since we can't be sure at this point whether it is a bug or not, we ask you not to talk about a bug yet and not to label the issue.)
+- Explain the behavior you would expect and the actual behavior.
+- Please provide as much context as possible and describe the *reproduction steps* that someone else can follow to recreate the issue on their own. This usually includes your code. For good bug reports you should isolate the problem and create a reduced test case.
+- Provide the information you collected in the previous section.
+
+### Suggesting Enhancements
+
+This section guides you through submitting an enhancement suggestion for DeOldify, **including completely new features and minor improvements to existing functionality**. Following these guidelines will help maintainers and the community to understand your suggestion and find related suggestions.
+
+#### Before Submitting an Enhancement
+
+- Make sure that you are using the latest version.
+- Read the [documentation](README.md) carefully and find out if the functionality is already covered, maybe by an individual configuration.
+- Perform a [search](https://github.com/thookham/DeOldify/issues) to see if the enhancement has already been suggested. If it has, add a comment to the existing issue instead of opening a new one.
+- Find out whether your idea fits with the scope and aims of the project. It's up to you to make a strong case to convince the project's developers of the merits of this feature. Keep in mind that we want features that will be useful to the majority of our users and not just a small subset. If you're just targeting a minority of users, consider writing an add-on/plugin library.
+
+#### How to Submit a Good Enhancement Suggestion
+
+Enhancement suggestions are tracked as [GitHub issues](https://github.com/thookham/DeOldify/issues).
+
+- Use a **clear and descriptive title** for the issue to identify the suggestion.
+- Provide a **step-by-step description of the suggested enhancement** in as much detail as possible.
+- **Describe the current behavior** and **explain which behavior you expected to see instead** and why. At this point you can also tell which alternatives you do not work for you.
+- You may want to include **screenshots and animated GIFs** which help you demonstrate the steps or point out the part which the suggestion is related to.
+- **Explain why this enhancement would be useful** to most DeOldify users. You may also want to point out the other projects that solved it better and which could serve as inspiration.

ColorFIDBenchmarkArtistic.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:81ff2900f2459c5f9c2a2cd7e6e28369cb47be06456911b95265dfc924c68fd6
+size 7379

ColorizeTrainingArtistic.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04151afd527032964230ea44879e76ab9d62a3b544bcdf01fe56b65e18bf71a9
+size 15025

ColorizeTrainingStable.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8439478243ef7d308267f189b18e6f25073a3c28770265587c37b2aa558a3fe
+size 15033

ColorizeTrainingStableLargeBatch.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2895ec4a822ce541fd73ee58f261c51237b1819135beeb5c9a15ef3ee2d0ca10
+size 18892

ColorizeTrainingVideo.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd9153345bbbd1f032e35d51511e5cc5a60f7aeea0210147a69af2188ab97455
+size 12035

ColorizeTrainingWandb.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70096ddb975b3345850df253aeae4f1a58c2e9bae90c42e681b0b674325de42c
+size 27053

HF_README.md

@@ -0,0 +1,215 @@
+---
+license: mit
+tags:
+- image-colorization
+- gan
+- computer-vision
+- pytorch
+- onnx
+library_name: pytorch
+---
+
+# DeOldify Model Weights
+
+This repository contains pretrained weights for **DeOldify**, a deep learning model for colorizing and restoring old black and white images and videos.
+
+**Original Repository**: [thookham/DeOldify](https://github.com/thookham/DeOldify)  
+**Original Author**: Jason Antic ([jantic/DeOldify](https://github.com/jantic/DeOldify))
+
+## Model Overview
+
+DeOldify uses a Self-Attention Generative Adversarial Network (SAGAN) with a novel **NoGAN** training approach to achieve stable, high-quality colorization without the typical GAN artifacts.
+
+### Three Specialized Models
+
+1. **Artistic** - Highest quality with vibrant colors and interesting details  
+   - Best for: General images, historical photos  
+   - Backbone: ResNet34 U-Net  
+   - Training: 5 NoGAN cycles, 32% ImageNet
+
+2. **Stable** - Best for portraits and landscapes, reduced artifacts  
+   - Best for: Faces, nature scenes  
+   - Backbone: ResNet101 U-Net  
+   - Training: 3 NoGAN cycles, 7% ImageNet
+
+3. **Video** - Optimized for smooth, flicker-free video  
+   - Best for: Video colorization, consistency  
+   - Backbone: ResNet101 U-Net  
+   - Training: Initial cycle only, 2.2% ImageNet
+
+## Available Files
+
+### ONNX Models (Browser/Inference)
+
+| File | Size | Description |
+|------|------|-------------|
+| `deoldify-art.onnx` | 243 MB | Artistic model in ONNX format for browser use |
+| `deoldify-quant.onnx` | 61 MB | Quantized artistic model (75% smaller, slightly lower quality) |
+
+### PyTorch Weights (Training & Inference)
+
+**Generator Weights** (Main):
+- `ColorizeArtistic_gen.pth` (243 MB)
+- `ColorizeStable_gen.pth` (834 MB)
+- `ColorizeVideo_gen.pth` (834 MB)
+
+**Critic Weights** (Main):
+- `ColorizeArtistic_crit.pth` (361 MB)
+- `ColorizeStable_crit.pth` (361 MB)
+- `ColorizeVideo_crit.pth` (361 MB)
+
+**PretrainOnly Weights** (For continued training):
+- `ColorizeArtistic_PretrainOnly_gen.pth` (729 MB)
+- `ColorizeArtistic_PretrainOnly_crit.pth` (1.05 GB)
+- `ColorizeStable_PretrainOnly_crit.pth` (1.05 GB)
+- `ColorizeVideo_PretrainOnly_crit.pth` (1.05 GB)
+
+> **Note**: Stable and Video PretrainOnly generators are split files hosted on [GitHub Releases](https://github.com/thookham/DeOldify/releases/tag/v2.0-models).
+
+## Usage
+
+### Browser (ONNX)
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <script src="https://cdn.jsdelivr.net/npm/onnxruntime-web/dist/ort.min.js"></script>
+</head>
+<body>
+  <script>
+    async function colorize() {
+      // Load model from Hugging Face
+      const session = await ort.InferenceSession.create(
+        "https://huggingface.co/thookham/DeOldify/resolve/main/deoldify-art.onnx"
+      );
+      
+      // Run inference (see full example in GitHub repo)
+      // ...
+    }
+  </script>
+</body>
+</html>
+```
+
+### PyTorch (Python)
+
+```python
+from huggingface_hub import hf_hub_download
+import torch
+
+# Download model weights
+model_path = hf_hub_download(
+    repo_id="thookham/DeOldify",
+    filename="ColorizeArtistic_gen.pth"
+)
+
+# Load weights (requires deoldify package installed)
+# See GitHub repository for full usage examples
+```
+
+### Installation
+
+```bash
+# Clone the main repository
+git clone https://github.com/thookham/DeOldify
+cd DeOldify
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Download a model
+from huggingface_hub import hf_hub_download
+model = hf_hub_download(repo_id="thookham/DeOldify", filename="ColorizeStable_gen.pth")
+```
+
+## Technical Details
+
+### Architecture
+- **Generator**: U-Net with ResNet34/101 backbone, spectral normalization, self-attention layers
+- **Critic**: PatchGAN discriminator
+- **Loss**: Perceptual loss (VGG16) + GAN loss
+
+### NoGAN Training
+A novel training approach that combines:
+1. Generator pretraining with feature loss
+2. Critic pretraining on generated images
+3. Short GAN training (30-60 minutes) at inflection point
+4. Optional cycle repeats for more colorful results
+
+This eliminates typical GAN artifacts while maintaining realistic colorization.
+
+### Training Data
+- Dataset: ImageNet subsets (1-32% depending on model)
+- Resolution: 192px during training
+- Augmentation: Gaussian noise for video stability
+
+## Model Card
+
+### Model Details
+- **Developed by**: Jason Antic (original), Travis Hookham (modernization)
+- **Model type**: Conditional GAN for image-to-image translation
+- **Language(s)**: N/A (computer vision)
+- **License**: MIT
+- **Parent Model**: Based on FastAI U-Net and Self-Attention GAN papers
+
+### Intended Use
+**Primary Use**: Colorizing black and white photographs and videos  
+**Out-of-Scope**: Real-time processing, guaranteed historical accuracy
+
+### Limitations
+- Colors may not be historically accurate  
+- Performance degrades on very low quality/damaged images
+- Artistic model may require render_factor tuning
+- Video model trades some color vibrancy for consistency
+
+## Related Models & Resources
+
+### Similar Colorization Models on Hugging Face
+
+**GAN-based Colorization:**
+- [Hammad712/GAN-Colorization-Model](https://huggingface.co/Hammad712/GAN-Colorization-Model) - GAN model for grayscale to color transformation
+- [jessicanono/filparty_colorization](https://huggingface.co/jessicanono/filparty_colorization) - ResNet-based model for historical photos
+
+**Stable Diffusion-based:**
+- [rsortino/ColorizeNet](https://huggingface.co/rsortino/ColorizeNet) - ControlNet adaptation of SD 2.1 for colorization
+- [AlekseyCalvin/ColorizeTruer_KontextFluxVar6_BySAP](https://huggingface.co/AlekseyCalvin/ColorizeTruer_KontextFluxVar6_BySAP) - Advanced Flux-based colorization
+
+**Interactive Demos (Spaces):**
+- [aryadytm/Photo-Colorization](https://huggingface.co/spaces/aryadytm/Photo-Colorization)
+- [Shashank009/Black-And-White-Image-Colorization](https://huggingface.co/spaces/Shashank009/Black-And-White-Image-Colorization)
+- [CA611/Image-Colorization](https://huggingface.co/spaces/CA611/Image-Colorization)
+
+### Why Choose DeOldify?
+
+DeOldify stands out for:
+- **NoGAN Training**: Unique approach eliminating typical GAN artifacts
+- **Specialized Models**: Three purpose-built models (Artistic, Stable, Video)
+- **Video Support**: Flicker-free temporal consistency
+- **Proven Track Record**: Powers MyHeritage InColor and widely adopted
+- **ONNX Support**: Browser-ready models for offline use
+
+## Citation
+
+If you use these models, please cite:
+
+```bibtex
+@misc{deoldify,
+  author = {Antic, Jason},
+  title = {DeOldify},
+  year = {2019},
+  publisher = {GitHub},
+  url = {https://github.com/jantic/DeOldify}
+}
+```
+
+## Links
+
+- **GitHub Repository**: https://github.com/thookham/DeOldify
+- **Original DeOldify**: https://github.com/jantic/DeOldify
+- **MyHeritage InColor** (Commercial version): https://www.myheritage.com/incolor
+- **Demo (Browser)**: See browser/ folder in GitHub repo
+
+## License
+
+MIT License. See [LICENSE](https://github.com/thookham/DeOldify/blob/master/LICENSE) file.

ImageColorizer.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:becb7dac71eb07d80e0b580c227e45031d5d178fc08487dfb2ecc7348238f557
+size 5670

ImageColorizerArtisticTests.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b031061b6f2b56a3bdb2b26e00d6122b2f9144454e5e62eddcbdb9521145980e
+size 79684

ImageColorizerColab.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39bcb7942400ab7a373b8053ba3df94b9159ac1fd66a6441915cd7661be145ad
+size 8484

ImageColorizerColabStable.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af0f95463e10a9c46ba3f5b1656590f2be552ae8fc90dc2bf6369275f6af4085
+size 8415

ImageColorizerStableTests.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3bb167d6e3751f8ee44eafb90b636b86d299ac7f44940d5adf9be616d43d8194
+size 78929

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Jason Antic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+include requirements.txt

README.md

@@ -0,0 +1,542 @@
+
+# DeOldify (Modernized)
+
+![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)
+![PyTorch 2.5+](https://img.shields.io/badge/PyTorch-2.5+-ee4c2c.svg)
+![CUDA 12.x](https://img.shields.io/badge/CUDA-12.x-76B900.svg)
+![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
+
+# DeOldify (Modernized)
+
+**DeOldify** has been modernized! This fork updates the project to support **PyTorch 2.5+**, **CUDA 12.x**, and **Intel GPUs (Arc/Data Center)**. It removes the dependency on the obsolete FastAI 1.x library, making it easier to run on modern hardware.
+
+**Quick Start**:
+- **NVIDIA GPU**: [Setup Guide](docs/nvidia_setup.md)
+- **Intel GPU**: [Setup Guide](docs/intel_gpu_setup.md)
+
+**Original Project**: The original DeOldify by Jason Antic can be found [here](https://github.com/jantic/DeOldify).
+
+**In Browser (new!)**  
+You can run DeOldify directly in your browser without any installation! We've included a local browser-based implementation in this repository.
+
+**How to use:**
+1. Navigate to the `browser/` folder in this repository.
+2. Open `index.html` in Chrome, Firefox, or Edge.
+3. Choose between the **Artistic** (higher quality) or **Quantized** (faster) model.
+4. Select an image and watch it colorize instantly!
+
+*Note: This implementation uses ONNX models hosted on our GitHub releases and Hugging Face, ensuring privacy and availability.*
+
+Also check out the original browser repo: https://github.com/akbartus/DeOldify-on-Browser
+
+**Hugging Face 🤗**: All models are also available on Hugging Face: [thookham/DeOldify](https://huggingface.co/thookham/DeOldify)
+
+The **most advanced** version of DeOldify image colorization is available here,
+exclusively.  Try a few images for free! [MyHeritage In Color](https://www.myheritage.com/incolor)
+
+**Replicate:** Image: <a href="https://replicate.com/arielreplicate/deoldify_image"><img src="https://replicate.com/arielreplicate/deoldify_image/badge"></a> | Video: <a href="https://replicate.com/arielreplicate/deoldify_video"><img src="https://replicate.com/arielreplicate/deoldify_video/badge"></a>
+
+----------------------------
+
+Image (artistic) [![Colab for images](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/jantic/DeOldify/blob/master/ImageColorizerColab.ipynb)
+| Video [![Colab for video](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/jantic/DeOldify/blob/master/VideoColorizerColab.ipynb)
+
+Having trouble with the default image colorizer, aka "artistic"?  Try the
+"stable" one below.  It generally won't produce colors that are as interesting as
+"artistic", but the glitches are noticeably reduced.
+
+Image (stable) [![Colab for stable model](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/jantic/DeOldify/blob/master/ImageColorizerColabStable.ipynb)
+
+Instructions on how to use the Colabs above have been kindly provided in video
+tutorial form by Old Ireland in Colour's John Breslin.  It's great! Click video
+image below to watch.
+
+[![DeOldify Tutorial](http://img.youtube.com/vi/VaEl0faDw38/0.jpg)](http://www.youtube.com/watch?v=VaEl0faDw38)
+
+Get more updates on [Twitter
+![Twitter logo](resource_images/twitter.svg)](https://twitter.com/DeOldify).
+
+## Table of Contents
+
+- [About DeOldify](#about-deoldify)
+- [Example Videos](#example-videos)
+- [Example Images](#example-images)
+- [Stuff That Should Probably Be In A Paper](#stuff-that-should-probably-be-in-a-paper)
+  - [How to Achieve Stable Video](#how-to-achieve-stable-video)
+  - [What is NoGAN?](#what-is-nogan)
+- [Why Three Models?](#why-three-models)
+- [Technical Details](#the-technical-details)
+- [Going Forward](#this-project-going-forward)
+- [Roadmap](ROADMAP.md)
+- [Getting Started Yourself](#getting-started-yourself)
+  - [Easiest Approach](#easiest-approach)
+  - [Your Own Machine](#your-own-machine-not-as-easy)
+- [Pretrained Weights](#pretrained-weights)
+
+## About DeOldify
+
+Simply put, the mission of this project is to colorize and restore old images and
+film footage. We'll get into the details in a bit, but first let's see some
+pretty pictures and videos!
+
+### New and Exciting Stuff in DeOldify
+
+- Glitches and artifacts are almost entirely eliminated
+- Better skin (less zombies)
+- More highly detailed and photorealistic renders
+- Much less "blue bias"
+- **Video** - it actually looks good!  
+- **NoGAN** - a new and weird but highly effective way to do GAN training for
+  image to image.
+
+## Example Videos
+
+**Note:**  Click images to watch
+
+### Facebook F8 Demo
+
+[![DeOldify Facebook F8 Movie Colorization Demo](http://img.youtube.com/vi/l3UXXid04Ys/0.jpg)](http://www.youtube.com/watch?v=l3UXXid04Ys)
+
+### Silent Movie Examples
+
+[![DeOldify Silent Movie Examples](http://img.youtube.com/vi/EXn-n2iqEjI/0.jpg)](http://www.youtube.com/watch?v=EXn-n2iqEjI)
+
+## Example Images
+
+"Migrant Mother" by Dorothea Lange (1936)
+
+![Migrant Mother](https://i.imgur.com/Bt0vnke.jpg)
+
+Woman relaxing in her livingroom in Sweden (1920)
+
+![Sweden Living Room](https://i.imgur.com/158d0oU.jpg)
+
+"Toffs and Toughs" by Jimmy Sime (1937)
+
+![Class Divide](https://i.imgur.com/VYuav4I.jpg)
+
+Thanksgiving Maskers (1911)
+
+![Thanksgiving Maskers](https://i.imgur.com/n8qVJ5c.jpg)
+
+Glen Echo Madame Careta Gypsy Camp in Maryland (1925)
+
+![Gypsy Camp](https://i.imgur.com/1oYrJRI.jpg)
+
+"Mr. and Mrs. Lemuel Smith and their younger children in their farm house,
+Carroll County, Georgia." (1941)
+
+![Georgia Farmhouse](https://i.imgur.com/I2j8ynm.jpg)
+
+"Building the Golden Gate Bridge" (est 1937)
+
+![Golden Gate Bridge](https://i.imgur.com/6SbFjfq.jpg)
+
+> **Note:**  What you might be wondering is while this render looks cool, are the
+> colors accurate? The original photo certainly makes it look like the towers of
+> the bridge could be white. We looked into this and it turns out the answer is
+> no - the towers were already covered in red primer by this time. So that's
+> something to keep in mind- historical accuracy remains a huge challenge!
+
+"Terrasse de café, Paris" (1925)
+
+![Cafe Paris](https://i.imgur.com/WprQwP5.jpg)
+
+Norwegian Bride (est late 1890s)
+
+![Norwegian Bride](https://i.imgur.com/MmtvrZm.jpg)
+
+Zitkála-Šá (Lakota: Red Bird), also known as Gertrude Simmons Bonnin (1898)
+
+![Native Woman](https://i.imgur.com/zIGM043.jpg)
+
+Chinese Opium Smokers (1880)
+
+![Opium Real](https://i.imgur.com/lVGq8Vq.jpg)
+
+## Stuff That Should Probably Be In A Paper
+
+### How to Achieve Stable Video
+
+NoGAN training is crucial to getting the kind of stable and colorful images seen
+in this iteration of DeOldify. NoGAN training combines the benefits of GAN
+training (wonderful colorization) while eliminating the nasty side effects
+(like flickering objects in video). Believe it or not, video is rendered using
+isolated image generation without any sort of temporal modeling tacked on. The
+process performs 30-60 minutes of the GAN portion of "NoGAN" training, using 1%
+to 3% of imagenet data once.  Then, as with still image colorization, we
+"DeOldify" individual frames before rebuilding the video.
+
+In addition to improved video stability, there is an interesting thing going on
+here worth mentioning. It turns out the models I run, even different ones and
+with different training structures, keep arriving at more or less the same
+solution.  That's even the case for the colorization of things you may think
+would be arbitrary and unknowable, like the color of clothing, cars, and even
+special effects (as seen in "Metropolis").
+
+![Metropolis Special FX](https://thumbs.gfycat.com/HeavyLoneBlowfish-size_restricted.gif)
+
+My best guess is that the models are learning some interesting rules about how to
+colorize based on subtle cues present in the black and white images that I
+certainly wouldn't expect to exist.  This result leads to nicely deterministic and
+consistent results, and that means you don't have track model colorization
+decisions because they're not arbitrary.  Additionally, they seem remarkably
+robust so that even in moving scenes the renders are very consistent.
+
+![Moving Scene Example](https://thumbs.gfycat.com/FamiliarJubilantAsp-size_restricted.gif)
+
+Other ways to stabilize video add up as well. First, generally speaking rendering
+at a higher resolution (higher render_factor) will increase stability of
+colorization decisions.  This stands to reason because the model has higher
+fidelity image information to work with and will have a greater chance of making
+the "right" decision consistently.  Closely related to this is the use of
+resnet101 instead of resnet34 as the backbone of the generator- objects are
+detected more consistently and correctly with this. This is especially important
+for getting good, consistent skin rendering.  It can be particularly visually
+jarring if you wind up with "zombie hands", for example.
+
+![Zombie Hand Example](https://thumbs.gfycat.com/ThriftyInferiorIsabellinewheatear-size_restricted.gif)
+
+Additionally, gaussian noise augmentation during training appears to help but at
+this point the conclusions as to just how much are bit more tenuous (I just
+haven't formally measured this yet).  This is loosely based on work done in style
+transfer video, described here:
+ <https://medium.com/element-ai-research-lab/stabilizing-neural-style-transfer-for-video-62675e203e42>.
+
+Special thanks go to Rani Horev for his contributions in implementing this noise
+augmentation.
+
+### What is NoGAN?
+
+This is a new type of GAN training that I've developed to solve some key problems
+in the previous DeOldify model. It provides the benefits of GAN training while
+spending minimal time doing direct GAN training.  Instead, most of the training
+time is spent pretraining the generator and critic separately with more
+straight-forward, fast and reliable conventional methods.  A key insight here is
+that those more "conventional" methods generally get you most of the results you
+need, and that GANs can be used to close the gap on realism. During the very
+short amount of actual GAN training the generator not only gets the full
+realistic colorization capabilities that used to take days of progressively
+resized GAN training, but it also doesn't accrue nearly as much of the artifacts
+and other ugly baggage of GANs. In fact, you can pretty much eliminate glitches
+and artifacts almost entirely depending on your approach. As far as I know this
+is a new technique. And it's incredibly effective.
+
+#### Original DeOldify Model
+
+![Before Flicker](https://thumbs.gfycat.com/CoordinatedVeneratedHogget-size_restricted.gif)
+
+#### NoGAN-Based DeOldify Model
+
+![After Flicker](https://thumbs.gfycat.com/OilyBlackArctichare-size_restricted.gif)
+
+The steps are as follows: First train the generator in a conventional way by
+itself with just the feature loss. Next, generate images from that, and train
+the critic on distinguishing between those outputs and real images as a basic
+binary classifier. Finally, train the generator and critic together in a GAN
+setting (starting right at the target size of 192px in this case).  Now for
+the weird part:  All the useful GAN training here only takes place within a very
+small window of time.  There's an inflection point where it appears the critic
+has transferred everything it can that is useful to the generator. Past this
+point, image quality oscillates between the best that you can get at the
+inflection point, or bad in a predictable way (orangish skin, overly red lips,
+etc).  There appears to be no productive training after the inflection point.
+And this point lies within training on just 1% to 3% of the Imagenet Data!
+That amounts to about 30-60 minutes of training at 192px.
+
+The hard part is finding this inflection point.  So far, I've accomplished this
+by making a whole bunch of model save checkpoints (every 0.1% of data iterated
+on) and then just looking for the point where images look great before they go
+totally bonkers with orange skin (always the first thing to go). Additionally,
+generator rendering starts immediately getting glitchy and inconsistent at this
+point, which is no good particularly for video. What I'd really like to figure
+out is what the tell-tale sign of the inflection point is that can be easily
+automated as an early stopping point.  Unfortunately, nothing definitive is
+jumping out at me yet.  For one, it's happening in the middle of training loss
+decreasing- not when it flattens out, which would seem more reasonable on the surface.
+
+Another key thing about NoGAN training is you can repeat pretraining the critic
+on generated images after the initial GAN training, then repeat the GAN training
+itself in the same fashion.  This is how I was able to get extra colorful results
+with the "artistic" model.  But this does come at a cost currently- the output of
+the generator becomes increasingly inconsistent and you have to experiment with
+render resolution (render_factor) to get the best result.  But the renders are
+still glitch free and way more consistent than I was ever able to achieve with
+the original DeOldify model. You can do about five of these repeat cycles, give
+or take, before you get diminishing returns, as far as I can tell.
+
+Keep in mind- I haven't been entirely rigorous in figuring out what all is going
+on in NoGAN- I'll save that for a paper. That means there's a good chance I'm
+wrong about something.  But I think it's definitely worth putting out there now
+because I'm finding it very useful- it's solving basically much of my remaining
+problems I had in DeOldify.
+
+This builds upon a technique developed in collaboration with Jeremy Howard and
+Sylvain Gugger for Fast.AI's Lesson 7 in version 3 of Practical Deep Learning
+for Coders Part I. The particular lesson notebook can be found here:
+  <https://github.com/fastai/course-v3/blob/master/nbs/dl1/lesson7-superres-gan.ipynb>
+
+## Why Three Models?
+
+There are now three models to choose from in DeOldify. Each of these has key
+strengths and weaknesses, and so have different use cases.  Video is for video
+of course.  But stable and artistic are both for images, and sometimes one will
+do images better than the other.
+
+More details:
+
+- **Artistic** - This model achieves the highest quality results in image
+coloration, in terms of interesting details and vibrance. The most notable
+drawback however is that it's a bit of a pain to fiddle around with to get the
+best results (you have to adjust the rendering resolution or render_factor to
+achieve this).  Additionally, the model does not do as well as stable in a few
+key common scenarios- nature scenes and portraits.  The model uses a resnet34
+backbone on a UNet with an emphasis on depth of layers on the decoder side.
+This model was trained with 5 critic pretrain/GAN cycle repeats via NoGAN, in
+addition to the initial generator/critic pretrain/GAN NoGAN training, at 192px.
+This adds up to a total of 32% of Imagenet data trained once (12.5 hours of
+direct GAN training).
+
+- **Stable** - This model achieves the best results with landscapes and
+portraits.  Notably, it produces less "zombies"- where faces or limbs stay gray
+rather than being colored in properly.  It generally has less weird
+miscolorations than artistic, but it's also less colorful in general.  This
+model uses a resnet101 backbone on a UNet with an emphasis on width of layers on
+the decoder side.  This model was trained with 3 critic pretrain/GAN cycle
+repeats via NoGAN, in addition to the initial generator/critic pretrain/GAN
+NoGAN training, at 192px.  This adds up to a total of 7% of Imagenet data
+trained once (3 hours of direct GAN training).
+
+- **Video** - This model is optimized for smooth, consistent and flicker-free
+video.  This would definitely be the least colorful of the three models, but
+it's honestly not too far off from "stable". The model is the same as "stable"
+in terms of architecture, but differs in training.  It's trained for a mere 2.2% 
+of Imagenet data once at 192px, using only the initial generator/critic 
+pretrain/GAN NoGAN training (1 hour of direct GAN training).
+
+Because the training of the artistic and stable models was done before the
+"inflection point" of NoGAN training described in "What is NoGAN???" was
+discovered, I believe this amount of training on them can be knocked down
+considerably. As far as I can tell, the models were stopped at "good points"
+that were well beyond where productive training was taking place.  I'll be
+looking into this in the future.
+
+Ideally, eventually these three models will be consolidated into one that has all
+these good desirable unified.  I think there's a path there, but it's going to
+require more work!  So for now, the most practical solution appears to be to
+maintain multiple models.
+
+
+
+
+
+## The Technical Details
+
+This is a deep learning based model. More specifically, what I've done is
+combined the following approaches:
+
+### [Self-Attention Generative Adversarial Network](https://arxiv.org/abs/1805.08318)
+
+Except the generator is a **pretrained U-Net**, and I've just modified it to
+have the spectral normalization and self-attention. It's a pretty
+straightforward translation.
+
+### [Two Time-Scale Update Rule](https://arxiv.org/abs/1706.08500)
+
+This is also very straightforward – it's just one to one generator/critic
+iterations and higher critic learning rate.
+This is modified to incorporate a "threshold" critic loss that makes sure that
+the critic is "caught up" before moving on to generator training.
+This is particularly useful for the "NoGAN" method described below.
+
+### NoGAN
+
+There's no paper here! This is a new type of GAN training that I've developed to
+solve some key problems in the previous DeOldify model.
+The gist is that you get the benefits of GAN training while spending minimal time
+doing direct GAN training.
+More details are in the [What is NoGAN?](#what-is-nogan) section (it's a doozy).
+
+### Generator Loss
+
+Loss during NoGAN learning is two parts: One is a basic Perceptual Loss (or
+Feature Loss) based on VGG16 – this just biases the generator model to replicate
+the input image.
+The second is the loss score from the critic. For the curious – Perceptual Loss
+isn't sufficient by itself to produce good results.
+It tends to just encourage a bunch of brown/green/blue – you know, cheating to
+the test, basically, which neural networks are really good at doing!
+Key thing to realize here is that GANs essentially are learning the loss function
+for you – which is really one big step closer to toward the ideal that we're
+shooting for in machine learning.
+And of course you generally get much better results when you get the machine to
+learn something you were previously hand coding.
+That's certainly the case here.
+
+**Of note:** There's no longer any "Progressive Growing of GANs" type training
+going on here. It's just not needed in lieu of the superior results obtained
+by the "NoGAN" technique described above.
+
+The beauty of this model is that it should be generally useful for all sorts of
+image modification, and it should do it quite well.
+What you're seeing above are the results of the colorization model, but that's
+just one component in a pipeline that I'm developing with the exact same approach.
+
+## This Project, Going Forward
+
+So that's the gist of this project – I'm looking to make old photos and film
+look reeeeaaally good with GANs, and more importantly, make the project *useful*.
+In the meantime though this is going to be my baby and I'll be actively updating
+and improving the code over the foreseeable future.
+I'll try to make this as user-friendly as possible, but I'm sure there's going
+to be hiccups along the way.
+
+Oh and I swear I'll document the code properly...eventually. Admittedly I'm
+*one of those* people who believes in "self documenting code" (LOL).
+
+## Best Practices & Golden Nuggets
+
+Based on extensive community research and the original author's insights, here are the "Golden Nuggets" for getting the best results:
+
+### 1. Video Flicker? Use the "Video" Model!
+If you are experiencing flickering in your video outputs, ensure you are using the **Video** model weights (`ColorizeVideo_gen.pth`). This model was specifically trained with **NoGAN** to prioritize temporal consistency over raw color vibrancy. The "Artistic" model will almost always flicker on video.
+
+### 2. The "NoGAN" Secret
+The core innovation of DeOldify is **NoGAN** training. It pre-trains the generator with a conventional loss function (Perceptual Loss) before introducing the GAN component. This minimizes the "GAN artifacts" (like flicker) while keeping the colorization quality.
+
+### 3. Post-Processing is Key
+Even with the Video model, some flicker may persist. We recommend using **FFmpeg's `deflicker` filter** as a post-processing step.
+*   **New Feature**: We have added a `deflicker=True` option to the `VideoColorizer` to handle this automatically!
+
+### 4. Alternative Implementations
+*   **Anime/Manga**: If you are colorizing anime sketches, check out [AnimeColorDeOldify](https://github.com/Dakini/AnimeColorDeOldify), which uses a model fine-tuned on Danbooru.
+*   **C# / .NET**: For a native C# implementation, see [DeOldify.NET](https://github.com/ColorfulSoft/DeOldify.NET).
+
+## Getting Started Yourself
+have that yet so I'm not going to make it the default instruction here yet.
+
+**Alternative Install:** User daddyparodz has kindly created an installer script
+for Ubuntu, and in particular Ubuntu on WSL, that may make things easier:
+<https://github.com/daddyparodz/AutoDeOldifyLocal>
+
+#### Note on test_images Folder
+
+The images in the `test_images` folder have been removed because they were using
+Git LFS and that costs a lot of money when GitHub actually charges for bandwidth
+on a popular open source project (they had a billing bug for while that was
+recently fixed). The notebooks that use them (the image test ones) still point
+to images in that directory that I (Jason) have personally and I'd like to keep
+it that way because, after all, I'm by far the primary and most active developer.
+But they won't work for you. Still, those notebooks are a convenient template
+for making your own tests if you're so inclined.
+
+#### Typical training
+
+The notebook `ColorizeTrainingWandb` has been created to log and monitor results
+through [Weights & Biases](https://www.wandb.com/). You can find a description of
+typical training by consulting [W&B Report](https://app.wandb.ai/borisd13/DeOldify/reports?view=borisd13%2FDeOldify).
+
+## Pretrained Weights
+
+To start right away on your own machine with your own images or videos without
+training the models yourself, you'll need to download the "Completed Generator
+Weights" listed below and drop them in the /models/ folder.
+
+The colorization inference notebooks should be able to guide you from here. The
+notebooks to use are named ImageColorizerArtistic.ipynb,
+ImageColorizerStable.ipynb, and VideoColorizer.ipynb.
+
+### Completed Generator Weights
+
+- [Artistic](https://github.com/thookham/DeOldify/releases/download/v2.0-models/ColorizeArtistic_gen.pth)
+- [Stable](https://github.com/thookham/DeOldify/releases/download/v2.0-models/ColorizeStable_gen.pth)
+- [Video](https://github.com/thookham/DeOldify/releases/download/v2.0-models/ColorizeVideo_gen.pth)
+
+### Completed Critic Weights
+
+- [Artistic](https://github.com/thookham/DeOldify/releases/download/v2.0-models/ColorizeArtistic_crit.pth)
+- [Stable](https://github.com/thookham/DeOldify/releases/download/v2.0-models/ColorizeStable_crit.pth)
+- [Video](https://github.com/thookham/DeOldify/releases/download/v2.0-models/ColorizeVideo_crit.pth)
+
+### Pretrain Only Generator Weights
+
+> **Note:** The Stable and Video PretrainOnly generator weights are split into multiple parts due to their size. Please download all parts (e.g., `.pth.000`, `.pth.001`) and run `python reassemble_models.py` to join them.
+
+- [Artistic](https://github.com/thookham/DeOldify/releases/download/v2.0-models/ColorizeArtistic_PretrainOnly_gen.pth)
+- [Stable (Part 1)](https://github.com/thookham/DeOldify/releases/download/v2.0-models/ColorizeStable_PretrainOnly_gen.pth.000) | [Stable (Part 2)](https://github.com/thookham/DeOldify/releases/download/v2.0-models/ColorizeStable_PretrainOnly_gen.pth.001)
+- [Video (Part 1)](https://github.com/thookham/DeOldify/releases/download/v2.0-models/ColorizeVideo_PretrainOnly_gen.pth.000) | [Video (Part 2)](https://github.com/thookham/DeOldify/releases/download/v2.0-models/ColorizeVideo_PretrainOnly_gen.pth.001)
+
+### Pretrain Only Critic Weights
+
+- [Artistic](https://github.com/thookham/DeOldify/releases/download/v2.0-models/ColorizeArtistic_PretrainOnly_crit.pth)
+- [Stable](https://github.com/thookham/DeOldify/releases/download/v2.0-models/ColorizeStable_PretrainOnly_crit.pth)
+- [Video](https://github.com/thookham/DeOldify/releases/download/v2.0-models/ColorizeVideo_PretrainOnly_crit.pth)
+
+### Archived Models (Browser / ONNX)
+
+- [Artistic ONNX](https://github.com/thookham/DeOldify/releases/download/v2.0-models/deoldify-art.onnx)
+- [Quantized ONNX](https://github.com/thookham/DeOldify/releases/download/v2.0-models/deoldify-quant.onnx)
+
+## Want the Old DeOldify?
+
+We suspect some of you are going to want access to the original DeOldify model
+for various reasons. We have that archived here: <https://github.com/dana-kelley/DeOldify>
+
+## Want More?
+
+Follow [#DeOldify](https://twitter.com/search?q=%23Deoldify) on Twitter.
+
+## License
+
+All code in this repository is under the MIT license as specified by the LICENSE
+file.
+
+The model weights listed in this readme under the "Pretrained Weights" section
+are trained by ourselves and are released under the MIT license.
+
+## A Statement on Open Source Support
+
+We believe that open source has done a lot of good for the world. After all,
+DeOldify simply wouldn't exist without it. But we also believe that there needs
+to be boundaries on just how much is reasonable to be expected from an open
+source project maintained by just two developers.
+
+Our stance is that we're providing the code and documentation on research that
+we believe is beneficial to the world. What we have provided are novel takes
+on colorization, GANs, and video that are hopefully somewhat friendly for
+developers and researchers to learn from and adopt. This is the culmination of
+well over a year of continuous work, free for you. What wasn't free was
+shouldered by us, the developers. We left our jobs, bought expensive GPUs, and
+had huge electric bills as a result of dedicating ourselves to this.
+
+What we haven't provided here is a ready to use free "product" or "app", and we
+don't ever intend on providing that. It's going to remain a Linux based project
+without Windows support, coded in Python, and requiring people to have some extra
+technical background to be comfortable using it. Others have stepped in with
+their own apps made with DeOldify, some paid and some free, which is what we want!
+We're instead focusing on what we believe we can do best- making better
+commercial models that people will pay for.
+Does that mean you're not getting the very best for free? Of course. We simply
+don't believe that we're obligated to provide that, nor is it feasible! We
+compete on research and sell that. Not a GUI or web service that wraps said
+research- that part isn't something we're going to be great at anyways. We're not
+about to shoot ourselves in the foot by giving away our actual competitive
+advantage for free, quite frankly.
+
+We're also not willing to go down the rabbit hole of providing endless, open
+ended and personalized support on this open source project. Our position is
+this: If you have the proper background and resources, the project provides
+more than enough to get you started. We know this because we've seen plenty of
+people using it and making money off of their own projects with it.
+
+Thus, if you have an issue come up and it happens to be an actual bug that
+having it be fixed will benefit users generally, then great- that's something
+we'll be happy to look into.
+
+
+In contrast, if you're asking about something that really amounts to asking for
+personalized and time consuming support that won't benefit anybody else, we're
+not going to help. It's simply not in our interest to do that. We have bills to
+pay, after all. And if you're asking for help on something that can already be
+derived from the documentation or code? That's simply annoying, and we're not
+going to pretend to be ok with that.

ROADMAP.md

@@ -0,0 +1,189 @@
+# DeOldify Roadmap
+
+This document outlines the development roadmap for DeOldify (Modernized), organized by priority and timeline. The project has successfully completed a major modernization effort and is now focused on expanding hardware support and exploring new deployment options.
+
+## 🎯 Project Vision
+
+Make DeOldify accessible and performant across modern hardware platforms (NVIDIA, Intel, AMD) while maintaining the cutting-edge colorization quality that made it popular. Enable deployment in diverse environments from local machines to cloud infrastructure.
+
+---
+
+## ✅ Recently Completed (v2.0 - November 2025)
+
+### Core Modernization
+- ✅ **PyTorch 2.5+ Migration**: Removed dependency on obsolete FastAI 1.x library
+- ✅ **CUDA 12.x Support**: Full support for modern NVIDIA GPUs
+- ✅ **Intel GPU Support**: Arc and Data Center GPU support via Intel Extension for PyTorch (IPEX)
+- ✅ **Unified Device Management**: Automatic detection and fallback (Intel → NVIDIA → CPU)
+- ✅ **Compatibility Layer**: Created `deoldify.fastai_compat` for seamless PyTorch integration
+
+### Infrastructure & Tooling
+- ✅ **Model Migration**: All weights migrated to GitHub Releases with SHA256 verification
+- ✅ **Verification Scripts**: `verify_models.py` and `verify_refactor.py` for validation
+- ✅ **GitHub Community Standards**: Code of Conduct, Contributing Guidelines, Security Policy
+- ✅ **CI/CD**: Unit tests and automated workflows
+- ✅ **Browser Implementation**: Local ONNX-based colorization in browser
+
+### Documentation
+- ✅ **Setup Guides**: Comprehensive guides for NVIDIA and Intel GPUs
+- ✅ **Hardware Guide**: Benchmarks and requirements
+- ✅ **Deployment Guide**: Local serving instructions
+- ✅ **Modernized Notebooks**: Updated Colab notebooks with file upload widgets
+
+---
+
+## 🔴 High Priority (Q1 2025)
+
+### Intel NPU Support
+**Goal**: Enable Neural Processing Unit acceleration for Intel Core Ultra processors
+
+- [ ] **Research & Investigation**
+  - Investigate OpenVINO toolkit integration
+  - Evaluate Intel Extension for PyTorch NPU capabilities
+  - Benchmark NPU performance vs GPU/CPU inference
+  
+- [ ] **Implementation**
+  - Add NPU device detection to `deoldify.device`
+  - Implement NPU-specific optimizations
+  - Update fallback chain: Intel NPU → Intel GPU → NVIDIA GPU → CPU
+  
+- [ ] **Documentation & Testing**
+  - Create `docs/intel_npu_setup.md`
+  - Add NPU tests to CI/CD pipeline
+  - Update hardware requirements guide
+
+**Expected Impact**: Enable efficient inference on laptops and mobile workstations without discrete GPUs.
+
+---
+
+## 🟠 Medium Priority (Q2 2025)
+
+### AMD GPU Support
+**Goal**: Support Radeon GPUs via ROCm
+
+- [ ] Add ROCm device detection
+- [ ] Create `environment_amd.yml` for ROCm environments
+- [ ] Test on RDNA 2/3 architecture
+- [ ] Document AMD setup process
+
+### Performance Optimizations
+**Goal**: Improve inference speed and memory efficiency
+
+- [ ] **Quantization**: INT8/FP16 inference modes
+- [ ] **Dynamic Batching**: Process multiple images efficiently
+- [ ] **Model Pruning**: Reduce model size without quality loss
+- [ ] **ONNX Runtime**: Evaluate ONNX Runtime for cross-platform inference
+
+### Enhanced Browser Implementation
+**Goal**: Improve browser-based colorization UX
+
+- [ ] Add WebGPU support for hardware acceleration
+- [ ] Implement progressive rendering for large images
+- [ ] Add batch processing capabilities
+- [ ] Create comparison slider UI
+
+---
+
+## 🟡 Low Priority (Q3-Q4 2025)
+
+### Cloud Deployment
+**Goal**: Simplify cloud deployment for production use
+
+- [ ] **Google Cloud Platform**
+  - Vertex AI deployment scripts
+  - Container images for Cloud Run
+  - Example Terraform configurations
+  
+- [ ] **AWS**
+  - SageMaker deployment templates
+  - Lambda@Edge for serverless inference
+  
+- [ ] **Azure**
+  - Azure ML deployment guide
+  - Container Apps examples
+
+### Model Improvements
+**Goal**: Enhance colorization quality and capabilities
+
+- [ ] **Fine-Tuning Tools**
+  - Scripts for domain-specific fine-tuning
+  - Transfer learning examples
+  - Custom dataset preparation guides
+  - **Custom Training Guides**: Documentation for fine-tuning NoGAN on domain-specific footage (e.g., anime, old film)
+
+- [ ] **Post-Processing Tools**
+  - Advanced deflicker integration (FFmpeg)
+  - Temporal smoothing helpers
+  - Comparison tools for different render factors
+  
+- [ ] **New Model Variants**
+  - Lightweight mobile-optimized model
+  - Ultra-high-resolution model (8K+)
+  - Real-time video colorization model
+
+### API & Integration
+**Goal**: Make DeOldify easier to integrate into other applications
+
+- [ ] **REST API**
+  - FastAPI/Flask-based serving
+  - Docker containers with API
+  - OpenAPI/Swagger documentation
+  
+- [ ] **Python Package**
+  - Publish to PyPI
+  - Simplified installation (`pip install deoldify`)
+  - High-level API for common use cases
+
+---
+
+## 🔵 Future Exploration (2026+)
+
+### Advanced Features
+- **Temporal Coherence**: Improved video stability with optical flow
+- **User Guidance**: Interactive colorization with color hints
+- **Style Transfer**: Multiple artistic colorization styles
+- **4K/8K Support**: Native ultra-high-resolution processing
+
+### Research Directions
+- **Diffusion Models**: Explore stable diffusion for colorization
+- **Transformer Architectures**: Evaluate Vision Transformers (ViT)
+- **Few-Shot Learning**: Colorize with minimal reference images
+- **Historical Accuracy**: Training on verified historical color photos
+
+### Community Features
+- **Model Zoo**: User-contributed fine-tuned models
+- **Plugin System**: Extensible architecture for custom filters
+- **Web Service**: Official hosted API (potential paid tier)
+
+---
+
+## 📊 Success Metrics
+
+We measure progress through:
+
+- **Hardware Coverage**: Percentage of modern GPUs supported (Target: 90%+)
+- **Inference Speed**: FPS for 1080p video colorization (Target: 30+ FPS on modern GPU)
+- **Model Quality**: User satisfaction and comparison to commercial solutions
+- **Adoption**: GitHub stars, PyPI downloads, community contributions
+- **Documentation**: Completeness and clarity based on user feedback
+
+---
+
+## 🤝 How to Contribute
+
+We welcome contributions aligned with this roadmap! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+**High-Impact Areas**:
+- Testing on different hardware configurations
+- Documentation improvements and translations
+- Performance benchmarking and optimization
+- Bug reports with reproducible examples
+
+---
+
+## 📝 Roadmap Updates
+
+This roadmap is reviewed and updated quarterly. Last updated: **December 2025**
+
+For detailed technical tasks, see [TODO.md](TODO.md).  
+For recent changes, see [CHANGELOG.md](CHANGELOG.md).

SECURITY.md

@@ -0,0 +1,19 @@
+# Security Policy
+
+## Supported Versions
+
+Use this section to tell people about which versions of your project are
+currently being supported with security updates.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 1.0.x   | :white_check_mark: |
+| < 1.0   | :x:                |
+
+## Reporting a Vulnerability
+
+Use this section to tell people how to report a vulnerability.
+
+Tell them where to go, how often they can expect to get an update on a
+reported vulnerability, what to expect if the vulnerability is accepted or
+declined, etc.

TODO.md

@@ -0,0 +1,52 @@
+# DeOldify Modernization Roadmap
+
+This document tracks the remaining tasks to fully modernize the DeOldify repository, prioritized by user feedback.
+
+## 🔴 Priority 1: Intel GPU Support (A-1)
+*Goal: Ensure robust support for Intel Arc and Data Center GPUs.*
+
+- [x] **Verify `device_id.py`**
+    - Ensure `DeviceId` enum includes Intel/XPU options if necessary.
+- [x] **Verify Integration**
+    - Check if `visualize.py` and other scripts correctly use the `_device.py` manager for Intel hardware.
+    - Ensure fallback logic (Intel -> NVIDIA -> CPU) works as intended.
+- [ ] **Intel NPU Support**
+    - Investigate and implement NPU detection (OpenVINO/IPEX).
+
+## 🔴 Priority 2: NVIDIA GPU Modernization (A-2)
+*Goal: Leverage latest CUDA and PyTorch features while maintaining reasonable backward compatibility.*
+
+- [x] **Verify Optimization**
+    - Ensure `torch.backends.cudnn.benchmark` and other optimizations are correctly applied for modern NVIDIA GPUs.
+    - Double check `environment.yml` against latest PyTorch/CUDA matrix.
+- [x] **Legacy CUDA Support**
+    - Document support for older drivers (last 5 years) where possible, or provide alternative environment files.
+
+## 🟠 Priority 3: Colab Modernization
+*Goal: Fix broken notebooks and improve UX.*
+
+- [x] **Fix `requirements-colab.txt`**
+    - Remove `fastai==1.0.60` (conflicts with new PyTorch).
+    - Add `torch`, `torchvision`, and other modern dependencies.
+- [x] **Update Notebooks**
+    - Remove `import fastai`.
+    - Use `deoldify.fastai_compat`.
+- [x] **UI Improvements**
+    - Drag-and-drop, Gallery, Comparison view.
+
+## 🟡 Priority 4: Documentation & Testing
+*Goal: Comprehensive guides and stability.*
+
+- [x] **Detailed Documentation**
+    - Create `docs/HARDWARE_GUIDE.md` (Benchmarks & Requirements).
+    - Create `docs/DEPLOYMENT_GUIDE.md` (Local serving).
+- [x] **Testing**
+    - Create `tests/` directory with unit tests for device selection and compatibility layer.
+    - Add CI/CD workflow.
+
+## 🔵 Future Work: Cloud Integration
+- [x] **Migrate Pretrained Weights**
+    - Host models on GitHub Releases to ensure longevity.
+    - Update all notebooks and docs to point to new URLs.
+- [ ] **Google Cloud Platform (Vertex AI)**
+    - Deployment scripts and containers.

USAGE_EXAMPLES.md

@@ -0,0 +1,229 @@
+# DeOldify Usage Examples
+
+This guide provides practical examples for using DeOldify models from Hugging Face.
+
+## Quick Start
+
+### Install Dependencies
+
+```bash
+pip install huggingface_hub torch torchvision Pillow numpy
+```
+
+### Download a Model
+
+```python
+from huggingface_hub import hf_hub_download
+
+# Download the Stable model (recommended for portraits)
+model_path = hf_hub_download(
+    repo_id="thookham/DeOldify",
+    filename="ColorizeStable_gen.pth"
+)
+
+print(f"Model downloaded to: {model_path}")
+```
+
+## Using PyTorch Models
+
+> **Note**: The full DeOldify package is required to load and use the PyTorch models. Clone the repository: `git clone https://github.com/thookham/DeOldify`
+
+### Example: Colorize an Image
+
+```python
+from deoldify import device
+from deoldify.visualize import get_image_colorizer
+from PIL import Image
+
+# Initialize colorizer (will download model if needed)
+colorizer = get_image_colorizer(artistic=False)  # Use Stable model
+
+# Colorize an image
+source_path = "old_photo.jpg"
+result_path = colorizer.plot_transformed_image(
+    path=source_path,
+    render_factor=35,  # Higher = better quality, slower
+    compare=True  # Show before/after
+)
+
+print(f"Colorized image saved to: {result_path}")
+```
+
+### Example: Batch Processing
+
+```python
+from pathlib import Path
+from deoldify.visualize import get_image_colorizer
+
+colorizer = get_image_colorizer(artistic=True)  # Use Artistic model
+
+input_dir = Path("black_and_white_photos")
+output_dir = Path("colorized")
+output_dir.mkdir(exist_ok=True)
+
+for img_path in input_dir.glob("*.jpg"):
+    print(f"Processing {img_path.name}...")
+    result = colorizer.get_transformed_image(
+        path=str(img_path),
+        render_factor=30
+    )
+    result.save(output_dir / img_path.name)
+
+print(f"Processed {len(list(input_dir.glob('*.jpg')))} images")
+```
+
+## Using ONNX Models (Browser)
+
+The ONNX models can run directly in web browsers using ONNX Runtime Web.
+
+### Example: HTML Page
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <script src="https://cdn.jsdelivr.net/npm/onnxruntime-web/dist/ort.min.js"></script>
+</head>
+<body>
+  <input type="file" id="imageInput" accept="image/*" />
+  <canvas id="outputCanvas"></canvas>
+
+  <script>
+    async function loadAndColorize() {
+      // Load model from Hugging Face
+      const session = await ort.InferenceSession.create(
+        "https://huggingface.co/thookham/DeOldify/resolve/main/deoldify-quant.onnx"
+      );
+
+      document.getElementById('imageInput').addEventListener('change', async (e) => {
+        const file = e.target.files[0];
+        const image = new Image();
+        image.src = URL.createObjectURL(file);
+        
+        image.onload = async () => {
+          // Preprocessing (resize to 256x256, convert to Float32 tensor)
+          const canvas = document.createElement('canvas');
+          canvas.width = 256;
+          canvas.height = 256;
+          const ctx = canvas.getContext('2d');
+          ctx.drawImage(image, 0, 0, 256, 256);
+          
+          const imageData = ctx.getImageData(0, 0, 256, 256);
+          // ... (preprocessing code)
+          
+          // Run inference
+          const tensor = new ort.Tensor('float32', processedData, [1, 3, 256, 256]);
+          const results = await session.run({ input: tensor });
+          
+          // Display result
+          // ... (postprocessing code)
+        };
+      });
+    }
+
+    loadAndColorize();
+  </script>
+</body>
+</html>
+```
+
+For a complete working example, see the [browser directory](https://github.com/thookham/DeOldify/tree/master/browser) in the GitHub repository.
+
+## Model Selection Guide
+
+### Artistic Model
+- **Best for**: General historical photos, artistic colorization
+- **Pros**: Most vibrant colors, interesting details
+- **Cons**: May require `render_factor` tuning
+- **Files**: `ColorizeArtistic_gen.pth`, `deoldify-art.onnx`
+
+```python
+colorizer = get_image_colorizer(artistic=True)
+```
+
+### Stable Model
+- **Best for**: Portraits, landscapes
+- **Pros**: More consistent, less artifacts
+- **Cons**: Slightly less colorful than Artistic
+- **Files**: `ColorizeStable_gen.pth`
+
+```python
+colorizer = get_image_colorizer(artistic=False)
+```
+
+### Video Model
+- **Best for**: Video colorization
+- **Pros**: Flicker-free, temporally consistent
+- **Cons**: Least colorful of the three
+- **Files**: `ColorizeVideo_gen.pth`
+
+```python
+from deoldify.visualize import get_video_colorizer
+video_colorizer = get_video_colorizer()
+```
+
+## Advanced Usage
+
+### Custom Render Factor
+
+The `render_factor` parameter controls quality vs speed:
+
+```python
+# Low quality, fast (good for testing)
+result = colorizer.get_transformed_image(path="photo.jpg", render_factor=10)
+
+# High quality, slow (best results)
+result = colorizer.get_transformed_image(path="photo.jpg", render_factor=45)
+
+# Recommended range: 20-40
+```
+
+### Using Critic Weights (Training)
+
+If you want to continue training the models:
+
+```python
+from huggingface_hub import hf_hub_download
+
+# Download both generator and critic
+gen_path = hf_hub_download(repo_id="thookham/DeOldify", filename="ColorizeArtistic_gen.pth")
+crit_path = hf_hub_download(repo_id="thookham/DeOldify", filename="ColorizeArtistic_crit.pth")
+
+# Load for training (see full documentation in GitHub repo)
+```
+
+## Troubleshooting
+
+### "CUDA out of memory"
+- Reduce `render_factor`
+- Process smaller images
+- Close other GPU applications
+
+### "Module 'deoldify' not found"
+- Install the DeOldify package: Clone the repo and run `pip install -e .`
+
+### Colors look unrealistic
+- Try the Stable model instead of Artistic
+- Adjust `render_factor` (try values between 20-40)
+- Some images may not colorize well due to damage or low quality
+
+## Additional Resources
+
+- **GitHub Repository**: https://github.com/thookham/DeOldify
+- **Setup Guides**:
+  - [NVIDIA GPU Setup](nvidia_setup.md)
+  - [Intel GPU Setup](intel_gpu_setup.md)
+- **Model Weights**: All available in this HF repository
+- **Browser Demo**: See `browser/` folder in GitHub repo
+
+## Citation
+
+```bibtex
+@misc{deoldify,
+  author = {Antic, Jason},
+  title = {DeOldify},
+  year = {2019},
+  publisher = {GitHub},
+  url = {https://github.com/jantic/DeOldify}
+}
+```

VideoColorizer.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:210afc44086ef08697fdad1aeb6bd5fd526ae5b62c481cacf356fed395291b12
+size 6339

VideoColorizerColab.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:598bf87dac7f678cbefc0da31e7e4c9be1d064d42e69bec39482f5509c755daa
+size 9945

akbartus_tree.json

@@ -0,0 +1 @@
+{"sha":"43107c240f063d559708abc7639cd9f6d844458e","url":"https://api.github.com/repos/akbartus/DeOldify-on-Browser/git/trees/43107c240f063d559708abc7639cd9f6d844458e","tree":[{"path":"LICENSE","mode":"100644","type":"blob","sha":"6d6cdac91b8f30bc0065d6b52437b578aff18b8b","size":1065,"url":"https://api.github.com/repos/akbartus/DeOldify-on-Browser/git/blobs/6d6cdac91b8f30bc0065d6b52437b578aff18b8b"},{"path":"README.md","mode":"100644","type":"blob","sha":"88035e0eaf1d82b0b21fa5e85b151573164aaee5","size":3246,"url":"https://api.github.com/repos/akbartus/DeOldify-on-Browser/git/blobs/88035e0eaf1d82b0b21fa5e85b151573164aaee5"},{"path":"img","mode":"040000","type":"tree","sha":"d3334306495bd32f52658b5997399a34b89d33d6","url":"https://api.github.com/repos/akbartus/DeOldify-on-Browser/git/trees/d3334306495bd32f52658b5997399a34b89d33d6"},{"path":"img/screenshot.jpg","mode":"100644","type":"blob","sha":"3f5d6c0f9bdc3bd5f8090ecc10d86ad7c4519a5f","size":107506,"url":"https://api.github.com/repos/akbartus/DeOldify-on-Browser/git/blobs/3f5d6c0f9bdc3bd5f8090ecc10d86ad7c4519a5f"},{"path":"original","mode":"040000","type":"tree","sha":"4c8d377f4859a977493cf7174755ebcf73953337","url":"https://api.github.com/repos/akbartus/DeOldify-on-Browser/git/trees/4c8d377f4859a977493cf7174755ebcf73953337"},{"path":"original/index.html","mode":"100644","type":"blob","sha":"da12505e7ff992903c4669556188316e9934f393","size":4281,"url":"https://api.github.com/repos/akbartus/DeOldify-on-Browser/git/blobs/da12505e7ff992903c4669556188316e9934f393"},{"path":"quantized","mode":"040000","type":"tree","sha":"c02b79e9adb2e6204d3724812c0e498e544fc778","url":"https://api.github.com/repos/akbartus/DeOldify-on-Browser/git/trees/c02b79e9adb2e6204d3724812c0e498e544fc778"},{"path":"quantized/index.html","mode":"100644","type":"blob","sha":"35582686f88fbc863208251531c9471e295cc50b","size":5855,"url":"https://api.github.com/repos/akbartus/DeOldify-on-Browser/git/blobs/35582686f88fbc863208251531c9471e295cc50b"}],"truncated":false}

assets.txt

@@ -0,0 +1,16 @@
+ColorizeArtistic_crit.pth
+ColorizeArtistic_gen.pth
+ColorizeArtistic_PretrainOnly_crit.pth
+ColorizeArtistic_PretrainOnly_gen.pth
+ColorizeStable_crit.pth
+ColorizeStable_gen.pth
+ColorizeStable_PretrainOnly_crit.pth
+ColorizeStable_PretrainOnly_gen.pth.000
+ColorizeStable_PretrainOnly_gen.pth.001
+ColorizeVideo_crit.pth
+ColorizeVideo_gen.pth
+ColorizeVideo_PretrainOnly_crit.pth
+ColorizeVideo_PretrainOnly_gen.pth.000
+ColorizeVideo_PretrainOnly_gen.pth.001
+deoldify-art.onnx
+deoldify-quant.onnx

browser/README.md

@@ -0,0 +1,39 @@
+# DeOldify Browser Integration
+
+This directory contains a browser-based implementation of DeOldify using ONNX Runtime Web. It allows you to run colorization models directly in your web browser without a backend server (after the model is downloaded).
+
+## ⚠️ Important: How to Run
+
+Due to browser security policies (CORS), **you cannot simply double-click the HTML files** to run them. You must serve them via a local HTTP server.
+
+### Quick Start (Windows/Linux/Mac)
+
+If you have Python installed (which is likely if you're using DeOldify), simply run:
+
+```bash
+# Run this command in your terminal within this directory
+python -m http.server 8000
+```
+
+Then open your browser and visit:
+*   [http://localhost:8000](http://localhost:8000)
+
+### Using the Helper Script (Windows)
+
+We've provided a PowerShell script to make this easy:
+
+1.  Right-click `serve.ps1` and select "Run with PowerShell"
+2.  Or run it from the terminal: `.\serve.ps1`
+
+## Available Models
+
+*   **Artistic Model**: High quality, vibrant colors. Larger download (~243 MB).
+*   **Quantized Model**: Faster, smaller download (~61 MB), slightly lower quality.
+
+## Troubleshooting
+
+**"Failed to fetch" or CORS Errors:**
+If you see an error about CORS or "Failed to fetch" in the status log, it means you are likely trying to open the file directly (`file:///...`). Please use the HTTP server method described above.
+
+**Memory Issues:**
+The artistic model requires a significant amount of RAM. If the tab crashes, try closing other tabs or using the Quantized model.

browser/artistic.html

@@ -0,0 +1,247 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>DeOldify Artistic (Browser)</title>
+    <script src="https://cdn.jsdelivr.net/npm/onnxruntime-web/dist/ort.min.js"></script>
+    <style>
+        body {
+            font-family: sans-serif;
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+
+        h1 {
+            text-align: center;
+        }
+
+        .container {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            gap: 20px;
+        }
+
+        canvas {
+            border: 1px solid #ccc;
+            max-width: 100%;
+        }
+
+        .controls {
+            margin-bottom: 20px;
+        }
+
+        #status {
+            font-weight: bold;
+            margin-top: 10px;
+        }
+    </style>
+</head>
+
+<body>
+    <h1>DeOldify Artistic Model</h1>
+    <div class="container">
+        <div class="controls">
+            <input type="file" id="imageInput" accept="image/*" />
+        </div>
+        <div id="status">Select an image to start...</div>
+        <canvas id="outputCanvas"></canvas>
+    </div>
+
+    <script>
+        const MODEL_URL = "https://huggingface.co/thookham/DeOldify-on-Browser/resolve/main/deoldify-art.onnx";
+        let session = null;
+
+        const preprocess = (input_imageData, width, height) => {
+            const floatArr = new Float32Array(width * height * 3);
+            let j = 0;
+            for (let i = 0; i < input_imageData.data.length; i += 4) {
+                // Normalize to 0-1 range as expected by DeOldify
+                floatArr[j] = input_imageData.data[i] / 255.0;       // red
+                floatArr[j + 1] = input_imageData.data[i + 1] / 255.0; // green
+                floatArr[j + 2] = input_imageData.data[i + 2] / 255.0; // blue
+                j += 3;
+            }
+            return floatArr;
+        };
+
+        const postprocess = (tensor) => {
+            const channels = tensor.dims[1];
+            const height = tensor.dims[2];
+            const width = tensor.dims[3];
+            const imageData = new ImageData(width, height);
+            const data = imageData.data;
+            const tensorData = new Float32Array(tensor.data);
+
+            for (let h = 0; h < height; h++) {
+                for (let w = 0; w < width; w++) {
+                    let rgb = [];
+                    for (let c = 0; c < channels; c++) {
+                        const tensorIndex = (c * height + h) * width + w;
+                        const value = tensorData[tensorIndex];
+                        // Denormalize: multiply by 255 and clamp
+                        let val = value * 255.0;
+                        if (val < 0) val = 0;
+                        if (val > 255) val = 255;
+                        rgb.push(Math.round(val));
+                    }
+                    data[(h * width + w) * 4] = rgb[0];
+                    data[(h * width + w) * 4 + 1] = rgb[1];
+                    data[(h * width + w) * 4 + 2] = rgb[2];
+                    data[(h * width + w) * 4 + 3] = 255;
+                }
+            }
+            return imageData;
+        };
+
+        async function init() {
+            const status = document.getElementById('status');
+            status.innerText = "Checking cache...";
+            try {
+                let buffer;
+                const cacheName = 'deoldify-models-v1';
+
+                // Try to load from cache first
+                try {
+                    const cache = await caches.open(cacheName);
+                    const cachedResponse = await cache.match(MODEL_URL);
+
+                    if (cachedResponse) {
+                        status.innerText = "Loading model from cache...";
+                        const blob = await cachedResponse.blob();
+                        buffer = await blob.arrayBuffer();
+                    }
+                } catch (e) {
+                    console.warn("Cache API not supported or failed:", e);
+                }
+
+                // If not in cache, download it
+                if (!buffer) {
+                    status.innerText = "Downloading model from Hugging Face... 0%";
+                    const response = await fetch(MODEL_URL);
+                    if (!response.ok) throw new Error(`Failed to fetch model: ${response.statusText}`);
+
+                    const contentLength = response.headers.get('content-length');
+                    const total = contentLength ? parseInt(contentLength, 10) : 0;
+                    let loaded = 0;
+
+                    const reader = response.body.getReader();
+                    const chunks = [];
+
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done) break;
+                        chunks.push(value);
+                        loaded += value.length;
+                        if (total) {
+                            const progress = Math.round((loaded / total) * 100);
+                            status.innerText = `Downloading model from Hugging Face... ${progress}%`;
+                        } else {
+                            status.innerText = `Downloading model from Hugging Face... ${(loaded / 1024 / 1024).toFixed(1)} MB`;
+                        }
+                    }
+
+                    const blob = new Blob(chunks);
+                    buffer = await blob.arrayBuffer();
+
+                    // Save to cache for next time
+                    try {
+                        const cache = await caches.open(cacheName);
+                        await cache.put(MODEL_URL, new Response(blob));
+                        console.log("Model saved to cache");
+                    } catch (e) {
+                        console.warn("Failed to save to cache:", e);
+                    }
+                }
+
+                status.innerText = "Initializing session...";
+                session = await ort.InferenceSession.create(buffer);
+
+                status.innerText = "Model loaded! Select an image.";
+                console.log("Session created:", session);
+            } catch (e) {
+                status.innerText = "Error loading model: " + e.message;
+                console.error(e);
+                if (e.message.includes("Failed to fetch")) {
+                    status.innerHTML += "<br><br>⚠️ <b>CORS Error Detected</b>: If you are running this file directly (file://), you must use a local server.<br>Run <code>python -m http.server 8000</code> in the terminal and visit <code>http://localhost:8000/artistic.html</code>";
+                }
+            }
+        }
+
+        document.getElementById('imageInput').addEventListener('change', async function (e) {
+            if (!session) {
+                await init();
+            }
+
+            const file = e.target.files[0];
+            if (!file) return;
+
+            // Validate image type
+            if (!file.type.startsWith('image/')) {
+                alert('Please select a valid image file.');
+                return;
+            }
+
+            const image = new Image();
+            const objectUrl = URL.createObjectURL(file);
+            image.src = objectUrl;
+
+            image.onload = async function () {
+                document.getElementById('status').innerText = "Processing...";
+
+                // Pre-processing canvas (256x256)
+                let canvas = document.createElement("canvas");
+                const size = 256;
+                canvas.width = size;
+                canvas.height = size;
+                let ctx = canvas.getContext("2d");
+                ctx.drawImage(image, 0, 0, size, size);
+
+                const input_img = ctx.getImageData(0, 0, size, size);
+                const test = preprocess(input_img, size, size);
+                const input = new ort.Tensor(new Float32Array(test), [1, 3, size, size]);
+
+                try {
+                    const result = await session.run({ "input": input });
+                    // Handle potential output name differences
+                    const output = result["output"] || result["out"] || Object.values(result)[0];
+
+                    if (!output) throw new Error("No output tensor found in model result");
+
+                    const imgdata = postprocess(output);
+
+                    // Render to output canvas
+                    const outCanvas = document.getElementById('outputCanvas');
+                    outCanvas.width = image.width;
+                    outCanvas.height = image.height;
+                    const outCtx = outCanvas.getContext('2d');
+
+                    // Draw 256x256 result to temp canvas
+                    const tempCanvas = document.createElement('canvas');
+                    tempCanvas.width = size;
+                    tempCanvas.height = size;
+                    tempCanvas.getContext('2d').putImageData(imgdata, 0, 0);
+
+                    // Resize to original
+                    outCtx.drawImage(tempCanvas, 0, 0, image.width, image.height);
+
+                    document.getElementById('status').innerText = "Done!";
+                } catch (err) {
+                    document.getElementById('status').innerText = "Error processing: " + err.message;
+                    console.error(err);
+                } finally {
+                    // Clean up memory
+                    URL.revokeObjectURL(objectUrl);
+                }
+            };
+        });
+
+        // Start loading immediately
+        init();
+    </script>
+</body>
+
+</html>

browser/index.html

@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>DeOldify Browser Integration</title>
+    <style>
+        body {
+            font-family: sans-serif;
+            max-width: 600px;
+            margin: 0 auto;
+            padding: 40px;
+            text-align: center;
+        }
+
+        h1 {
+            margin-bottom: 30px;
+        }
+
+        .card {
+            border: 1px solid #ddd;
+            border-radius: 8px;
+            padding: 20px;
+            margin-bottom: 20px;
+            transition: transform 0.2s;
+            box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
+        }
+
+        .card:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 5px 15px rgba(0, 0, 0, 0.1);
+        }
+
+        a {
+            text-decoration: none;
+            color: inherit;
+            display: block;
+        }
+
+        h2 {
+            margin-top: 0;
+            color: #007bff;
+        }
+
+        p {
+            color: #666;
+        }
+    </style>
+</head>
+
+<body>
+    <h1>DeOldify Browser Integration</h1>
+    <p>Run DeOldify directly in your browser using ONNX models hosted on GitHub.</p>
+
+    <a href="artistic.html">
+        <div class="card">
+            <h2>Artistic Model</h2>
+            <p>High quality, vibrant colors. (243 MB download)</p>
+        </div>
+    </a>
+
+    <a href="quantized.html">
+        <div class="card">
+            <h2>Quantized Model</h2>
+            <p>Faster, lightweight. (61 MB download)</p>
+        </div>
+    </a>
+</body>
+
+</html>

browser/quantized.html

@@ -0,0 +1,248 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>DeOldify Quantized (Browser)</title>
+    <script src="https://cdn.jsdelivr.net/npm/onnxruntime-web/dist/ort.min.js"></script>
+    <style>
+        body {
+            font-family: sans-serif;
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+
+        h1 {
+            text-align: center;
+        }
+
+        .container {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            gap: 20px;
+        }
+
+        canvas {
+            border: 1px solid #ccc;
+            max-width: 100%;
+        }
+
+        .controls {
+            margin-bottom: 20px;
+        }
+
+        #status {
+            font-weight: bold;
+            margin-top: 10px;
+        }
+    </style>
+</head>
+
+<body>
+    <h1>DeOldify Quantized Model</h1>
+    <p style="text-align: center;">Faster, smaller download (61MB), slightly lower quality.</p>
+    <div class="container">
+        <div class="controls">
+            <input type="file" id="imageInput" accept="image/*" />
+        </div>
+        <div id="status">Select an image to start...</div>
+        <canvas id="outputCanvas"></canvas>
+    </div>
+
+    <script>
+        const MODEL_URL = "https://huggingface.co/thookham/DeOldify-on-Browser/resolve/main/deoldify-quant.onnx";
+        let session = null;
+
+        const preprocess = (input_imageData, width, height) => {
+            const floatArr = new Float32Array(width * height * 3);
+            let j = 0;
+            for (let i = 0; i < input_imageData.data.length; i += 4) {
+                // Normalize to 0-1 range as expected by DeOldify
+                floatArr[j] = input_imageData.data[i] / 255.0;       // red
+                floatArr[j + 1] = input_imageData.data[i + 1] / 255.0; // green
+                floatArr[j + 2] = input_imageData.data[i + 2] / 255.0; // blue
+                j += 3;
+            }
+            return floatArr;
+        };
+
+        const postprocess = (tensor) => {
+            const channels = tensor.dims[1];
+            const height = tensor.dims[2];
+            const width = tensor.dims[3];
+            const imageData = new ImageData(width, height);
+            const data = imageData.data;
+            const tensorData = new Float32Array(tensor.data);
+
+            for (let h = 0; h < height; h++) {
+                for (let w = 0; w < width; w++) {
+                    let rgb = [];
+                    for (let c = 0; c < channels; c++) {
+                        const tensorIndex = (c * height + h) * width + w;
+                        const value = tensorData[tensorIndex];
+                        // Denormalize: multiply by 255 and clamp
+                        let val = value * 255.0;
+                        if (val < 0) val = 0;
+                        if (val > 255) val = 255;
+                        rgb.push(Math.round(val));
+                    }
+                    data[(h * width + w) * 4] = rgb[0];
+                    data[(h * width + w) * 4 + 1] = rgb[1];
+                    data[(h * width + w) * 4 + 2] = rgb[2];
+                    data[(h * width + w) * 4 + 3] = 255;
+                }
+            }
+            return imageData;
+        };
+
+        async function init() {
+            const status = document.getElementById('status');
+            status.innerText = "Checking cache...";
+            try {
+                let buffer;
+                const cacheName = 'deoldify-models-v1';
+
+                // Try to load from cache first
+                try {
+                    const cache = await caches.open(cacheName);
+                    const cachedResponse = await cache.match(MODEL_URL);
+
+                    if (cachedResponse) {
+                        status.innerText = "Loading model from cache...";
+                        const blob = await cachedResponse.blob();
+                        buffer = await blob.arrayBuffer();
+                    }
+                } catch (e) {
+                    console.warn("Cache API not supported or failed:", e);
+                }
+
+                // If not in cache, download it
+                if (!buffer) {
+                    status.innerText = "Downloading model from Hugging Face... 0%";
+                    const response = await fetch(MODEL_URL);
+                    if (!response.ok) throw new Error(`Failed to fetch model: ${response.statusText}`);
+
+                    const contentLength = response.headers.get('content-length');
+                    const total = contentLength ? parseInt(contentLength, 10) : 0;
+                    let loaded = 0;
+
+                    const reader = response.body.getReader();
+                    const chunks = [];
+
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done) break;
+                        chunks.push(value);
+                        loaded += value.length;
+                        if (total) {
+                            const progress = Math.round((loaded / total) * 100);
+                            status.innerText = `Downloading model from Hugging Face... ${progress}%`;
+                        } else {
+                            status.innerText = `Downloading model from Hugging Face... ${(loaded / 1024 / 1024).toFixed(1)} MB`;
+                        }
+                    }
+
+                    const blob = new Blob(chunks);
+                    buffer = await blob.arrayBuffer();
+
+                    // Save to cache for next time
+                    try {
+                        const cache = await caches.open(cacheName);
+                        await cache.put(MODEL_URL, new Response(blob));
+                        console.log("Model saved to cache");
+                    } catch (e) {
+                        console.warn("Failed to save to cache:", e);
+                    }
+                }
+
+                status.innerText = "Initializing session...";
+                session = await ort.InferenceSession.create(buffer);
+
+                status.innerText = "Model loaded! Select an image.";
+                console.log("Session created:", session);
+            } catch (e) {
+                status.innerText = "Error loading model: " + e.message;
+                console.error(e);
+                if (e.message.includes("Failed to fetch")) {
+                    status.innerHTML += "<br><br>⚠️ <b>CORS Error Detected</b>: If you are running this file directly (file://), you must use a local server.<br>Run <code>python -m http.server 8000</code> in the terminal and visit <code>http://localhost:8000/quantized.html</code>";
+                }
+            }
+        }
+
+        document.getElementById('imageInput').addEventListener('change', async function (e) {
+            if (!session) {
+                await init();
+            }
+
+            const file = e.target.files[0];
+            if (!file) return;
+
+            // Validate image type
+            if (!file.type.startsWith('image/')) {
+                alert('Please select a valid image file.');
+                return;
+            }
+
+            const image = new Image();
+            const objectUrl = URL.createObjectURL(file);
+            image.src = objectUrl;
+
+            image.onload = async function () {
+                document.getElementById('status').innerText = "Processing...";
+
+                // Pre-processing canvas (256x256)
+                let canvas = document.createElement("canvas");
+                const size = 256;
+                canvas.width = size;
+                canvas.height = size;
+                let ctx = canvas.getContext("2d");
+                ctx.drawImage(image, 0, 0, size, size);
+
+                const input_img = ctx.getImageData(0, 0, size, size);
+                const test = preprocess(input_img, size, size);
+                const input = new ort.Tensor(new Float32Array(test), [1, 3, size, size]);
+
+                try {
+                    const result = await session.run({ "input": input });
+                    // Handle potential output name differences
+                    const output = result["output"] || result["out"] || Object.values(result)[0];
+
+                    if (!output) throw new Error("No output tensor found in model result");
+
+                    const imgdata = postprocess(output);
+
+                    // Render to output canvas
+                    const outCanvas = document.getElementById('outputCanvas');
+                    outCanvas.width = image.width;
+                    outCanvas.height = image.height;
+                    const outCtx = outCanvas.getContext('2d');
+
+                    // Draw 256x256 result to temp canvas
+                    const tempCanvas = document.createElement('canvas');
+                    tempCanvas.width = size;
+                    tempCanvas.height = size;
+                    tempCanvas.getContext('2d').putImageData(imgdata, 0, 0);
+
+                    // Resize to original
+                    outCtx.drawImage(tempCanvas, 0, 0, image.width, image.height);
+
+                    document.getElementById('status').innerText = "Done!";
+                } catch (err) {
+                    document.getElementById('status').innerText = "Error processing: " + err.message;
+                    console.error(err);
+                } finally {
+                    // Clean up memory
+                    URL.revokeObjectURL(objectUrl);
+                }
+            };
+        });
+
+        // Start loading immediately
+        init();
+    </script>
+</body>
+
+</html>

browser/serve.ps1

@@ -0,0 +1,27 @@
+# Simple script to serve the DeOldify project root and open the browser
+Write-Host "Starting local server for DeOldify Browser..." -ForegroundColor Cyan
+Write-Host "Press Ctrl+C to stop the server." -ForegroundColor Yellow
+
+# Get the root directory (parent of the script's directory)
+$scriptPath = $MyInvocation.MyCommand.Path
+$browserDir = Split-Path $scriptPath
+$rootDir = Split-Path $browserDir
+
+# Change to root directory
+Set-Location $rootDir
+Write-Host "Serving from: $rootDir" -ForegroundColor Gray
+
+# Start the server in the background
+$process = Start-Process -FilePath "python" -ArgumentList "-m http.server 8000" -PassThru
+
+# Wait a moment for it to start
+Start-Sleep -Seconds 2
+
+# Open the browser to the artistic page
+Start-Process "http://localhost:8000/browser/artistic.html"
+
+# Wait for the user to close the script
+Read-Host "Server is running. Press Enter to stop server and exit..."
+
+# Stop the server
+Stop-Process -Id $process.Id

check_remote_models.py

@@ -0,0 +1,29 @@
+import subprocess
+import json
+import base64
+import re
+
+def check_repo_file(repo, path):
+    cmd = ["gh", "api", f"repos/{repo}/contents/{path}", "--jq", ".content"]
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        content_b64 = result.stdout.strip()
+        content = base64.b64decode(content_b64).decode('utf-8')
+        
+        print(f"--- Checking {repo}/{path} ---")
+        # Search for .onnx or .pth links
+        urls = re.findall(r'https?://[^\s"\'<>]+(?:\.onnx|\.pth)', content)
+        for url in urls:
+            print(f"Found URL: {url}")
+            
+    except subprocess.CalledProcessError as e:
+        print(f"Error fetching {path}: {e}")
+    except Exception as e:
+        print(f"Error processing {path}: {e}")
+
+repos = ["thookham/DeOldify-on-Browser", "akbartus/DeOldify-on-Browser"]
+files = ["original/index.html", "quantized/index.html"]
+
+for repo in repos:
+    for file in files:
+        check_repo_file(repo, file)

check_remote_models_v2.py

@@ -0,0 +1,30 @@
+import subprocess
+import json
+import base64
+import re
+
+def check_repo_file(repo, path):
+    cmd = ["gh", "api", f"repos/{repo}/contents/{path}", "--jq", ".content"]
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        content_b64 = result.stdout.strip()
+        content = base64.b64decode(content_b64).decode('utf-8')
+        
+        urls = re.findall(r'https?://[^\s"\'<>]+(?:\.onnx|\.pth)', content)
+        return urls
+            
+    except Exception as e:
+        return []
+
+repos = ["thookham/DeOldify-on-Browser"]
+files = ["original/index.html", "quantized/index.html"]
+
+all_urls = []
+for repo in repos:
+    for file in files:
+        urls = check_repo_file(repo, file)
+        all_urls.extend(urls)
+
+with open("found_urls.txt", "w") as f:
+    for url in all_urls:
+        f.write(url + "\n")

compare_models.py

@@ -0,0 +1,44 @@
+import hashlib
+import requests
+import os
+
+def get_file_hash(filepath):
+    sha256_hash = hashlib.sha256()
+    with open(filepath, "rb") as f:
+        for byte_block in iter(lambda: f.read(4096), b""):
+            sha256_hash.update(byte_block)
+    return sha256_hash.hexdigest()
+
+def download_file(url, filename):
+    print(f"Downloading {url}...")
+    r = requests.get(url, stream=True)
+    with open(filename, 'wb') as f:
+        for chunk in r.iter_content(chunk_size=8192):
+            f.write(chunk)
+    return filename
+
+external_urls = {
+    "glitch_art.onnx": "https://huggingface.co/thookham/DeOldify-on-Browser/resolve/main/deoldify-art.onnx",
+    "glitch_quant.onnx": "https://huggingface.co/thookham/DeOldify-on-Browser/resolve/main/deoldify-quant.onnx"
+}
+
+# Local files
+local_files = {
+    "local_art.onnx": "models/deoldify-art.onnx",
+    "local_quant.onnx": "models/deoldify-quant.onnx"
+}
+
+print("--- Local File Hashes ---")
+for name, path in local_files.items():
+    if os.path.exists(path):
+        print(f"{name}: {get_file_hash(path)}")
+    else:
+        print(f"{name}: File not found")
+
+print("\n--- External File Hashes ---")
+for name, url in external_urls.items():
+    try:
+        download_file(url, name)
+        print(f"{name}: {get_file_hash(name)}")
+    except Exception as e:
+        print(f"Error downloading {name}: {e}")

deoldify/__init__.py

@@ -0,0 +1,8 @@
+import sys
+import logging
+logging.getLogger().addHandler(logging.StreamHandler(sys.stdout))
+logging.getLogger().setLevel(logging.INFO)
+
+from deoldify._device import _Device
+
+device = _Device()

deoldify/_device.py

@@ -0,0 +1,69 @@
+import os
+import torch
+from enum import Enum
+from .device_id import DeviceId
+import logging
+
+#NOTE:  This must be called first before any torch imports in order to work properly!
+
+class DeviceException(Exception):
+    pass
+
+class _Device:
+    def __init__(self):
+        self._current_device = DeviceId.CPU
+        self._backend = 'cpu'
+        self._init_device()
+
+    def _init_device(self):
+        # Check for Intel Extension for PyTorch
+        try:
+            import intel_extension_for_pytorch as ipex
+            if torch.xpu.is_available():
+                self._backend = 'xpu'
+                return
+        except ImportError:
+            pass
+
+        # Check for CUDA
+        if torch.cuda.is_available():
+            self._backend = 'cuda'
+            return
+
+        self._backend = 'cpu'
+
+    def is_gpu(self):
+        ''' Returns `True` if the current device is GPU (CUDA or XPU), `False` otherwise. '''
+        return self.current() is not DeviceId.CPU
+  
+    def current(self):
+        return self._current_device
+
+    def set(self, device:DeviceId):     
+        if device == DeviceId.CPU:
+            os.environ['CUDA_VISIBLE_DEVICES']=''
+            self._current_device = DeviceId.CPU
+        else:
+            # Handle GPU selection
+            if self._backend == 'cuda':
+                os.environ['CUDA_VISIBLE_DEVICES']=str(device.value)
+                torch.backends.cudnn.benchmark=True
+            elif self._backend == 'xpu':
+                # For XPU, we might need different env vars or just rely on index
+                # Currently just setting the device ID
+                pass
+            
+            self._current_device = device
+            
+        return device
+
+    def get_torch_device(self):
+        if self._current_device == DeviceId.CPU:
+            return torch.device('cpu')
+        
+        if self._backend == 'cuda':
+            return torch.device('cuda')
+        elif self._backend == 'xpu':
+            return torch.device('xpu')
+        
+        return torch.device('cpu')

deoldify/augs.py

@@ -0,0 +1,29 @@
+import random
+
+from fastai.vision.image import TfmPixel
+
+# Contributed by Rani Horev. Thank you!
+def _noisify(
+    x, pct_pixels_min: float = 0.001, pct_pixels_max: float = 0.4, noise_range: int = 30
+):
+    if noise_range > 255 or noise_range < 0:
+        raise Exception("noise_range must be between 0 and 255, inclusively.")
+
+    h, w = x.shape[1:]
+    img_size = h * w
+    mult = 10000.0
+    pct_pixels = (
+        random.randrange(int(pct_pixels_min * mult), int(pct_pixels_max * mult)) / mult
+    )
+    noise_count = int(img_size * pct_pixels)
+
+    for ii in range(noise_count):
+        yy = random.randrange(h)
+        xx = random.randrange(w)
+        noise = random.randrange(-noise_range, noise_range) / 255.0
+        x[:, yy, xx].add_(noise)
+
+    return x
+
+
+noisify = TfmPixel(_noisify)

deoldify/critics.py

@@ -0,0 +1,47 @@
+from fastai.basic_train import Learner
+from fastai.core import *
+from fastai.layers import NormType, conv_layer
+from fastai.torch_core import *
+from fastai.vision import *
+from fastai.vision.data import ImageDataBunch
+from fastai.vision.gan import AdaptiveLoss, accuracy_thresh_expand
+
+_conv_args = dict(leaky=0.2, norm_type=NormType.Spectral)
+
+
+def _conv(ni: int, nf: int, ks: int = 3, stride: int = 1, **kwargs):
+    return conv_layer(ni, nf, ks=ks, stride=stride, **_conv_args, **kwargs)
+
+
+def custom_gan_critic(
+    n_channels: int = 3, nf: int = 256, n_blocks: int = 3, p: int = 0.15
+):
+    "Critic to train a `GAN`."
+    layers = [_conv(n_channels, nf, ks=4, stride=2), nn.Dropout2d(p / 2)]
+    for i in range(n_blocks):
+        layers += [
+            _conv(nf, nf, ks=3, stride=1),
+            nn.Dropout2d(p),
+            _conv(nf, nf * 2, ks=4, stride=2, self_attention=(i == 0)),
+        ]
+        nf *= 2
+    layers += [
+        _conv(nf, nf, ks=3, stride=1),
+        _conv(nf, 1, ks=4, bias=False, padding=0, use_activ=False),
+        Flatten(),
+    ]
+    return nn.Sequential(*layers)
+
+
+def colorize_crit_learner(
+    data: ImageDataBunch,
+    loss_critic=AdaptiveLoss(nn.BCEWithLogitsLoss()),
+    nf: int = 256,
+) -> Learner:
+    return Learner(
+        data,
+        custom_gan_critic(nf=nf),
+        metrics=accuracy_thresh_expand,
+        loss_func=loss_critic,
+        wd=1e-3,
+    )

deoldify/dataset.py

@@ -0,0 +1,20 @@
+from .fastai_compat import *
+
+# Training data loading logic is currently disabled due to FastAI 1.x deprecation.
+# To restore training support, this module needs to be rewritten using pure PyTorch Datasets/DataLoaders.
+
+def get_colorize_data(
+    sz: int,
+    bs: int,
+    crappy_path: Path,
+    good_path: Path,
+    random_seed: int = None,
+    keep_pct: float = 1.0,
+    num_workers: int = 8,
+    stats: tuple = None,
+    xtra_tfms=[],
+):
+    raise NotImplementedError("Training data loading not supported in this version.")
+
+def get_dummy_databunch():
+    return DataBunch()

deoldify/device_id.py

@@ -0,0 +1,13 @@
+from enum import IntEnum
+
+class DeviceId(IntEnum):
+    GPU0 = 0,
+    GPU1 = 1,
+    GPU2 = 2,
+    GPU3 = 3,
+    GPU4 = 4,
+    GPU5 = 5,
+    GPU6 = 6,
+    GPU7 = 7,
+    XPU = 98,
+    CPU = 99

deoldify/fastai_compat.py

@@ -0,0 +1,268 @@
+    return p
+
+import torchvision.models as models
+
+class NormType(Enum):
+    Batch = 1
+    BatchZero = 2
+    Weight = 3
+    Spectral = 4
+    Instance = 5
+    InstanceZero = 6
+    Pixel = 7
+
+SplitFuncOrIdxList = Optional[Union[Callable, List[int]]]
+
+def to_device(m, device):
+    return m.to(device)
+
+def apply_init(m, init_func):
+    if hasattr(m, 'apply'):
+        m.apply(lambda x: init_func(x.weight) if hasattr(x, 'weight') and hasattr(x.weight, 'data') else None)
+
+ImageDataBunch = DataBunch
+
+
+def camel2snake(name):
+    import re
+    _camel_re1 = re.compile('(.)([A-Z][a-z]+)')
+    _camel_re2 = re.compile('([a-z0-9])([A-Z])')
+    return _camel_re2.sub(r'\1_\2', _camel_re1.sub(r'\1_\2', name)).lower()
+
+class SequentialEx(nn.Module):
+    "Like `nn.Sequential`, but with ModuleList semantics, and can handle `MergeLayer`."
+    def __init__(self, *layers):
+        super().__init__()
+        self.layers = nn.ModuleList(layers)
+
+    def forward(self, x):
+        res = x
+        for l in self.layers:
+            res.orig = x
+            nres = l(res)
+            # We have to remove res.orig to avoid hanging references and therefore memory leaks
+            res.orig = None
+            res = nres
+        return res
+
+    def __getitem__(self, i): return self.layers[i]
+    def append(self, l): return self.layers.append(l)
+    def extend(self, l): return self.layers.extend(l)
+    def insert(self, i, l): return self.layers.insert(i, l)
+
+class MergeLayer(nn.Module):
+    "Merge a shortcut with the result of the module by adding them or concatenating them if `dense=True`."
+    def __init__(self, dense:bool=False):
+        super().__init__()
+        self.dense = dense
+
+    def forward(self, x):
+        return torch.cat([x, x.orig], dim=1) if self.dense else (x+x.orig)
+
+class SigmoidRange(nn.Module):
+    "Sigmoid module with range `(low, x_max)`"
+    def __init__(self, low, high):
+        super().__init__()
+        self.low, self.high = low, high
+
+    def forward(self, x):
+        return torch.sigmoid(x) * (self.high - self.low) + self.low
+
+def conv_layer(ni:int, nf:int, ks:int=3, stride:int=1, padding:int=None, bias:bool=None, is_1d:bool=False,
+               norm_type:Optional[str]=None,  use_activ:bool=True, leaky:float=None,
+               transpose:bool=False, init:Callable=nn.init.kaiming_normal_, self_attention:bool=False):
+    "Create a sequence of convolutional (`ni` to `nf`), ReLU (if `use_activ`) and batchnorm (if `bn`) layers."
+    if padding is None: padding = (ks-1)//2 if not transpose else 0
+    bn = norm_type in ('Batch', 'BatchZero')
+    if bias is None: bias = not bn
+    conv_func = nn.ConvTranspose2d if transpose else nn.Conv1d if is_1d else nn.Conv2d
+    conv = conv_func(ni, nf, kernel_size=ks, bias=bias, stride=stride, padding=padding)
+    
+    if init: init(conv.weight)
+    
+    if norm_type == 'Weight': conv = weight_norm(conv)
+    elif norm_type == 'Spectral': conv = spectral_norm(conv)
+    
+    layers = [conv]
+    if use_activ: layers.append(relu(leaky=leaky))
+    if bn: layers.append((nn.BatchNorm1d if is_1d else nn.BatchNorm2d)(nf))
+    if self_attention: layers.append(SelfAttention(nf))
+    return nn.Sequential(*layers)
+
+def relu(leaky:float=None):
+    return nn.LeakyReLU(ifnone(leaky,0.1), inplace=True) if leaky is not None else nn.ReLU(inplace=True)
+
+def batchnorm_2d(nf:int, norm_type:str='Batch'):
+    return nn.BatchNorm2d(nf)
+
+class SelfAttention(nn.Module):
+    "Self attention layer for nd."
+    def __init__(self, n_channels:int):
+        super().__init__()
+        self.query = conv1d(n_channels, n_channels//8)
+        self.key   = conv1d(n_channels, n_channels//8)
+        self.value = conv1d(n_channels, n_channels)
+        self.gamma = nn.Parameter(tensor([0.]))
+
+    def forward(self, x):
+        #Notation from https://arxiv.org/abs/1805.08318
+        size = x.size()
+        x = x.view(*size[:2],-1)
+        f,g,h = self.query(x),self.key(x),self.value(x)
+        beta = F.softmax(torch.bmm(f.transpose(1,2), g), dim=1)
+        o = self.gamma * torch.bmm(h, beta) + x
+        return o.view(*size)
+
+def conv1d(ni:int, no:int, ks:int=1, stride:int=1, padding:int=0, bias:bool=False):
+    "Create and initialize a `nn.Conv1d` layer with spectral normalization."
+    conv = nn.Conv1d(ni, no, ks, stride=stride, padding=padding, bias=bias)
+    nn.init.kaiming_normal_(conv.weight)
+    if bias: conv.bias.data.zero_()
+    return spectral_norm(conv)
+
+def res_block(nf, dense:bool=False, norm_type:str='Batch', bottle:bool=False, **kwargs):
+    "Resnet block of `nf` features."
+    norm2 = norm_type
+    if not dense and (norm_type=='Batch'): norm2 = 'BatchZero'
+    nf_inner = nf//2 if bottle else nf
+    return SequentialEx(conv_layer(nf, nf_inner, norm_type=norm_type, **kwargs),
+                        conv_layer(nf_inner, nf, norm_type=norm2, **kwargs),
+                        MergeLayer(dense))
+
+# --- Hooks & Model Sizes ---
+
+class Hook():
+    "Create a hook on `m` with `hook_func`."
+    def __init__(self, m:nn.Module, hook_func:Callable, is_forward:bool=True, detach:bool=True):
+        self.hook_func,self.detach,self.stored = hook_func,detach,None
+        f = m.register_forward_hook if is_forward else m.register_backward_hook
+        self.hook = f(self.hook_fn)
+        self.removed = False
+
+    def hook_fn(self, module:nn.Module, input:Tensor, output:Tensor):
+        if self.detach:
+            input = (o.detach() for o in input) if isinstance(input, tuple) else input.detach()
+            output = (o.detach() for o in output) if isinstance(output, tuple) else output.detach()
+        self.stored = self.hook_func(module, input, output)
+
+    def remove(self):
+        if not self.removed:
+            self.hook.remove()
+            self.removed = True
+
+    def __enter__(self, *args): return self
+    def __exit__(self, *args): self.remove()
+
+class Hooks():
+    "Create several hooks on the modules in `ms` with `hook_func`."
+    def __init__(self, ms:List[nn.Module], hook_func:Callable, is_forward:bool=True, detach:bool=True):
+        self.hooks = [Hook(m, hook_func, is_forward, detach) for m in ms]
+
+    def __getitem__(self,i:int)->Hook: return self.hooks[i]
+    def __len__(self)->int: return len(self.hooks)
+    def __iter__(self): return iter(self.hooks)
+    @property
+    def stored(self): return [o.stored for o in self]
+
+    def remove(self):
+        for h in self.hooks: h.remove()
+
+    def __enter__(self, *args): return self
+    def __exit__(self, *args): self.remove()
+
+def _hook_inner(m,i,o): return o if isinstance(o,Tensor) else o if isinstance(o,list) else list(o)
+
+def hook_outputs(modules:List[nn.Module], detach:bool=True, grad:bool=False)->Hooks:
+    "Return `Hooks` that store activations of all `modules` in `self.stored`"
+    return Hooks(modules, _hook_inner, detach=detach, is_forward=not grad)
+
+def dummy_eval(m:nn.Module, size:Tuple=(64,64)):
+    "Evaluate `m` on a dummy input of a certain `size`"
+    ch_in = in_channels(m)
+    x = torch.randn(1,ch_in,*size)
+    if next(m.parameters()).is_cuda: x = x.cuda()
+    return m.eval()(x)
+
+def model_sizes(m:nn.Module, size:Tuple=(64,64)):
+    "Pass a dummy input through the model `m` to get the various sizes of activations."
+    with hook_outputs(m) as hooks:
+        dummy_eval(m, size)
+        return [o.stored.shape for o in hooks]
+
+def in_channels(m:nn.Module) -> int:
+    "Return the shape of the first weight layer in `m`."
+    for l in m.modules():
+        if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Conv3d)):
+            return l.in_channels
+    raise Exception('No weight layer')
+
+# --- Model Creation ---
+
+def create_body(arch:Callable, pretrained:bool=True, cut:Optional[Union[int, Callable]]=None):
+    "Cut off the head of a typically pretrained `arch`."
+    model = arch(pretrained=pretrained)
+    # Most torchvision models have 'fc' or 'classifier' as head
+    # ResNet specific cut
+    if cut is None:
+        ll = list(enumerate(model.children()))
+        cut = next(i for i,o in reversed(ll) if has_pool_type(o))
+    
+    return nn.Sequential(*list(model.children())[:cut])
+
+def has_pool_type(m):
+    if isinstance(m, (nn.AdaptiveAvgPool2d, nn.AdaptiveMaxPool2d, nn.AvgPool2d, nn.MaxPool2d)): return True
+    return False
+
+def cnn_config(arch):
+    "Get the metadata for `arch`."
+    # Simplified config for ResNets
+    return {'split': lambda m: (m[0][6], m[1])} # Split at layer 6 for ResNet
+
+# --- Learner Shim ---
+
+class Learner:
+    "Minimal Learner shim for inference."
+    def __init__(self, data, model, path=None):
+        self.data = data
+        self.model = model
+        self.path = path
+        
+        # Use deoldify.device to get the correct device (CUDA/XPU/CPU)
+        from deoldify import device as device_settings
+        self.device = device_settings.get_torch_device()
+        
+        self.model.to(self.device)
+
+    def load(self, name):
+        # Load state dict
+        if self.path:
+            path = self.path / 'models' / f'{name}.pth'
+        else:
+            path = f'models/{name}.pth'
+        
+        # Handle map_location
+        state = torch.load(path, map_location=self.device)
+        if 'model' in state: state = state['model']
+        self.model.load_state_dict(state, strict=True)
+    
+    def split(self, split_on):
+        pass # Not needed for inference
+    
+    def freeze(self):
+        for p in self.model.parameters(): p.requires_grad = False
+
+class DataBunch:
+    "Minimal DataBunch shim."
+    def __init__(self, c=3, device=None):
+        self.c = c
+        if device:
+            self.device = device
+        else:
+            from deoldify import device as device_settings
+            self.device = device_settings.get_torch_device()
+
+def get_dummy_databunch():
+    return DataBunch()
+
+def tensor(x, *args, **kwargs):
+    return torch.tensor(x, *args, **kwargs)