id int64 0 190k | prompt stringlengths 21 13.4M | docstring stringlengths 1 12k ⌀ |
|---|---|---|
157,403 | import collections
import datetime
import os
import re
import shlex
import time
from google.cloud import ndb
from clusterfuzz._internal import fuzzing
from clusterfuzz._internal.base import dates
from clusterfuzz._internal.base import errors
from clusterfuzz._internal.base import memoize
from clusterfuzz._internal.base import persistent_cache
from clusterfuzz._internal.base import retry
from clusterfuzz._internal.base import tasks
from clusterfuzz._internal.base import utils
from clusterfuzz._internal.config import db_config
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.crash_analysis import crash_analyzer
from clusterfuzz._internal.crash_analysis import severity_analyzer
from clusterfuzz._internal.datastore import data_types
from clusterfuzz._internal.datastore import ndb_utils
from clusterfuzz._internal.google_cloud_utils import blobs
from clusterfuzz._internal.google_cloud_utils import storage
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
from clusterfuzz._internal.system import shell
The provided code snippet includes necessary dependencies for implementing the `get_all_project_names` function. Write a Python function `def get_all_project_names()` to solve the following problem:
Return all project names.
Here is the function:
def get_all_project_names():
"""Return all project names."""
query = data_types.Job.query(
projection=[data_types.Job.project], distinct=True)
return sorted([job.project for job in query]) | Return all project names. |
157,404 | import collections
import datetime
import os
import re
import shlex
import time
from google.cloud import ndb
from clusterfuzz._internal import fuzzing
from clusterfuzz._internal.base import dates
from clusterfuzz._internal.base import errors
from clusterfuzz._internal.base import memoize
from clusterfuzz._internal.base import persistent_cache
from clusterfuzz._internal.base import retry
from clusterfuzz._internal.base import tasks
from clusterfuzz._internal.base import utils
from clusterfuzz._internal.config import db_config
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.crash_analysis import crash_analyzer
from clusterfuzz._internal.crash_analysis import severity_analyzer
from clusterfuzz._internal.datastore import data_types
from clusterfuzz._internal.datastore import ndb_utils
from clusterfuzz._internal.google_cloud_utils import blobs
from clusterfuzz._internal.google_cloud_utils import storage
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
from clusterfuzz._internal.system import shell
The provided code snippet includes necessary dependencies for implementing the `get_build_state` function. Write a Python function `def get_build_state(job_type, crash_revision)` to solve the following problem:
Return whether a build is unmarked, good or bad.
Here is the function:
def get_build_state(job_type, crash_revision):
"""Return whether a build is unmarked, good or bad."""
build = data_types.BuildMetadata.query(
data_types.BuildMetadata.job_type == job_type,
data_types.BuildMetadata.revision == crash_revision).get()
if not build:
return data_types.BuildState.UNMARKED
if build.bad_build:
return data_types.BuildState.BAD
return data_types.BuildState.GOOD | Return whether a build is unmarked, good or bad. |
157,405 | import collections
import datetime
import os
import re
import shlex
import time
from google.cloud import ndb
from clusterfuzz._internal import fuzzing
from clusterfuzz._internal.base import dates
from clusterfuzz._internal.base import errors
from clusterfuzz._internal.base import memoize
from clusterfuzz._internal.base import persistent_cache
from clusterfuzz._internal.base import retry
from clusterfuzz._internal.base import tasks
from clusterfuzz._internal.base import utils
from clusterfuzz._internal.config import db_config
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.crash_analysis import crash_analyzer
from clusterfuzz._internal.crash_analysis import severity_analyzer
from clusterfuzz._internal.datastore import data_types
from clusterfuzz._internal.datastore import ndb_utils
from clusterfuzz._internal.google_cloud_utils import blobs
from clusterfuzz._internal.google_cloud_utils import storage
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
from clusterfuzz._internal.system import shell
def filter_stacktrace(stacktrace, blob_name=None, signed_upload_url=None):
"""Filters stacktrace and returns content appropriate for storage as an
appengine entity."""
unicode_stacktrace = utils.decode_to_unicode(stacktrace)
if len(unicode_stacktrace) <= data_types.STACKTRACE_LENGTH_LIMIT:
return unicode_stacktrace
# TODO(alhijazi): Once the migration is done, callers are expected to
# always pass a `blob_name` and a `signed_upload_url`.
if signed_upload_url:
try:
storage.upload_signed_url(
unicode_stacktrace.encode('utf-8'), signed_upload_url)
logs.log('Uploaded stacktrace using signed url.')
except Exception:
print("uplaod failed")
logs.log_error('Unable to upload crash stacktrace to signed url.')
return unicode_stacktrace[(-1 * data_types.STACKTRACE_LENGTH_LIMIT):]
return '%s%s' % (data_types.BLOBSTORE_STACK_PREFIX, blob_name)
tmpdir = environment.get_value('BOT_TMPDIR')
tmp_stacktrace_file = os.path.join(tmpdir, 'stacktrace.tmp')
try:
with open(tmp_stacktrace_file, 'wb') as handle:
handle.write(unicode_stacktrace.encode('utf-8'))
with open(tmp_stacktrace_file, 'rb') as handle:
key = blobs.write_blob(handle)
except Exception:
logs.log_error('Unable to write crash stacktrace to temporary file.')
shell.remove_file(tmp_stacktrace_file)
return unicode_stacktrace[(-1 * data_types.STACKTRACE_LENGTH_LIMIT):]
shell.remove_file(tmp_stacktrace_file)
return '%s%s' % (data_types.BLOBSTORE_STACK_PREFIX, key)
The provided code snippet includes necessary dependencies for implementing the `add_build_metadata` function. Write a Python function `def add_build_metadata(job_type, crash_revision, is_bad_build, console_output=None)` to solve the following problem:
Add build metadata.
Here is the function:
def add_build_metadata(job_type,
crash_revision,
is_bad_build,
console_output=None):
"""Add build metadata."""
build = data_types.BuildMetadata()
build.bad_build = is_bad_build
build.bot_name = environment.get_value('BOT_NAME')
build.console_output = filter_stacktrace(console_output)
build.job_type = job_type
build.revision = crash_revision
build.timestamp = datetime.datetime.utcnow()
build.put()
if is_bad_build:
logs.log_error(
'Bad build %s.' % job_type,
revision=crash_revision,
job_type=job_type,
output=console_output)
else:
logs.log(
'Good build %s.' % job_type, revision=crash_revision, job_type=job_type)
return build | Add build metadata. |
157,406 | import collections
import datetime
import os
import re
import shlex
import time
from google.cloud import ndb
from clusterfuzz._internal import fuzzing
from clusterfuzz._internal.base import dates
from clusterfuzz._internal.base import errors
from clusterfuzz._internal.base import memoize
from clusterfuzz._internal.base import persistent_cache
from clusterfuzz._internal.base import retry
from clusterfuzz._internal.base import tasks
from clusterfuzz._internal.base import utils
from clusterfuzz._internal.config import db_config
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.crash_analysis import crash_analyzer
from clusterfuzz._internal.crash_analysis import severity_analyzer
from clusterfuzz._internal.datastore import data_types
from clusterfuzz._internal.datastore import ndb_utils
from clusterfuzz._internal.google_cloud_utils import blobs
from clusterfuzz._internal.google_cloud_utils import storage
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
from clusterfuzz._internal.system import shell
DATA_BUNDLE_DEFAULT_BUCKET_IAM_ROLE = 'roles/storage.objectAdmin'
def get_data_bundle_bucket_name(data_bundle_name):
"""Return data bundle bucket name on GCS."""
domain = bucket_domain_suffix()
return '%s-corpus.%s' % (data_bundle_name, domain)
The provided code snippet includes necessary dependencies for implementing the `create_data_bundle_bucket_and_iams` function. Write a Python function `def create_data_bundle_bucket_and_iams(data_bundle_name, emails)` to solve the following problem:
Creates a data bundle bucket and adds iams for access.
Here is the function:
def create_data_bundle_bucket_and_iams(data_bundle_name, emails):
"""Creates a data bundle bucket and adds iams for access."""
bucket_name = get_data_bundle_bucket_name(data_bundle_name)
if not storage.create_bucket_if_needed(bucket_name):
return False
client = storage.create_discovery_storage_client()
iam_policy = storage.get_bucket_iam_policy(client, bucket_name)
if not iam_policy:
return False
members = []
# Add access for the domains allowed in project.
domains = local_config.AuthConfig().get('whitelisted_domains', default=[])
for domain in domains:
members.append('domain:%s' % domain)
# Add access for the emails provided in function arguments.
for email in emails:
members.append('user:%s' % email)
if not members:
# No members to add, bail out.
return True
binding = storage.get_bucket_iam_binding(iam_policy,
DATA_BUNDLE_DEFAULT_BUCKET_IAM_ROLE)
if binding:
binding['members'] = members
else:
binding = {
'role': DATA_BUNDLE_DEFAULT_BUCKET_IAM_ROLE,
'members': members,
}
iam_policy['bindings'].append(binding)
return bool(storage.set_bucket_iam_policy(client, bucket_name, iam_policy)) | Creates a data bundle bucket and adds iams for access. |
157,407 | import collections
import datetime
import os
import re
import shlex
import time
from google.cloud import ndb
from clusterfuzz._internal import fuzzing
from clusterfuzz._internal.base import dates
from clusterfuzz._internal.base import errors
from clusterfuzz._internal.base import memoize
from clusterfuzz._internal.base import persistent_cache
from clusterfuzz._internal.base import retry
from clusterfuzz._internal.base import tasks
from clusterfuzz._internal.base import utils
from clusterfuzz._internal.config import db_config
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.crash_analysis import crash_analyzer
from clusterfuzz._internal.crash_analysis import severity_analyzer
from clusterfuzz._internal.datastore import data_types
from clusterfuzz._internal.datastore import ndb_utils
from clusterfuzz._internal.google_cloud_utils import blobs
from clusterfuzz._internal.google_cloud_utils import storage
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
from clusterfuzz._internal.system import shell
The provided code snippet includes necessary dependencies for implementing the `is_fuzzing_engine` function. Write a Python function `def is_fuzzing_engine(name)` to solve the following problem:
Return whether or not |name| is a fuzzing engine.
Here is the function:
def is_fuzzing_engine(name):
"""Return whether or not |name| is a fuzzing engine."""
query = data_types.FuzzTarget.query(data_types.FuzzTarget.engine == name)
return bool(query.count(limit=1)) | Return whether or not |name| is a fuzzing engine. |
157,408 | import collections
import functools
import json
import threading
from clusterfuzz._internal.base import persistent_cache
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
from clusterfuzz._internal.system.environment import appengine_noop
from clusterfuzz._internal.system.environment import if_redis_available
from clusterfuzz._internal.system.environment import local_noop
_local = threading.local()
_DEFAULT_REDIS_HOST = 'localhost'
_DEFAULT_REDIS_PORT = 6379
The provided code snippet includes necessary dependencies for implementing the `_redis_client` function. Write a Python function `def _redis_client()` to solve the following problem:
Get the redis client.
Here is the function:
def _redis_client():
"""Get the redis client."""
import redis
if hasattr(_local, 'redis'):
return _local.redis
host = environment.get_value('REDIS_HOST', _DEFAULT_REDIS_HOST)
port = environment.get_value('REDIS_PORT', _DEFAULT_REDIS_PORT)
_local.redis = redis.Redis(host=host, port=port)
return _local.redis | Get the redis client. |
157,409 | import collections
import functools
import json
import threading
from clusterfuzz._internal.base import persistent_cache
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
from clusterfuzz._internal.system.environment import appengine_noop
from clusterfuzz._internal.system.environment import if_redis_available
from clusterfuzz._internal.system.environment import local_noop
The provided code snippet includes necessary dependencies for implementing the `_default_key` function. Write a Python function `def _default_key(func, args, kwargs)` to solve the following problem:
Get a key name based on function, arguments and keyword arguments.
Here is the function:
def _default_key(func, args, kwargs):
"""Get a key name based on function, arguments and keyword arguments."""
# Use unicode instead of str where possible. This makes it less likely to
# have false misses.
args = tuple(arg if not isinstance(arg, str) else str(arg) for arg in args)
kwargs = {
key: value if not isinstance(value, str) else str(value)
for key, value in kwargs.items()
}
return 'memoize:%s' % [func.__name__, args, sorted(kwargs.items())] | Get a key name based on function, arguments and keyword arguments. |
157,410 | import ast
import datetime
import functools
import gc
import hashlib
import inspect
import os
import random
import sys
import time
import urllib.parse
import urllib.request
import weakref
import requests
from clusterfuzz._internal.base import errors
from clusterfuzz._internal.base import memoize
from clusterfuzz._internal.base import retry
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
The provided code snippet includes necessary dependencies for implementing the `encode_as_unicode` function. Write a Python function `def encode_as_unicode(obj)` to solve the following problem:
Encode a string as unicode, or leave bytes as they are.
Here is the function:
def encode_as_unicode(obj):
"""Encode a string as unicode, or leave bytes as they are."""
if not hasattr(obj, 'encode'):
return obj
return obj.encode('utf-8') | Encode a string as unicode, or leave bytes as they are. |
157,411 | import ast
import datetime
import functools
import gc
import hashlib
import inspect
import os
import random
import sys
import time
import urllib.parse
import urllib.request
import weakref
import requests
from clusterfuzz._internal.base import errors
from clusterfuzz._internal.base import memoize
from clusterfuzz._internal.base import retry
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
WINDOWS_PREFIX_PATH = '\\\\?\\'
The provided code snippet includes necessary dependencies for implementing the `file_path_to_file_url` function. Write a Python function `def file_path_to_file_url(path)` to solve the following problem:
Return a path as a file scheme url.
Here is the function:
def file_path_to_file_url(path):
"""Return a path as a file scheme url."""
if not path:
return ''
path = path.lstrip(WINDOWS_PREFIX_PATH)
return urllib.parse.urljoin('file:', urllib.request.pathname2url(path)) | Return a path as a file scheme url. |
157,412 | import ast
import datetime
import functools
import gc
import hashlib
import inspect
import os
import random
import sys
import time
import urllib.parse
import urllib.request
import weakref
import requests
from clusterfuzz._internal.base import errors
from clusterfuzz._internal.base import memoize
from clusterfuzz._internal.base import retry
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
def remove_prefix(string, prefix):
"""Strips the prefix from a string."""
if string.startswith(prefix):
return string[len(prefix):]
return string
def string_hash(obj):
"""Returns a SHA-1 hash of the object. Not used for security purposes."""
return hashlib.sha1(str(obj).encode('utf-8')).hexdigest()
The provided code snippet includes necessary dependencies for implementing the `get_directory_hash_for_path` function. Write a Python function `def get_directory_hash_for_path(file_path)` to solve the following problem:
Return the directory hash for a file path (excludes file name).
Here is the function:
def get_directory_hash_for_path(file_path):
"""Return the directory hash for a file path (excludes file name)."""
root_directory = environment.get_value('ROOT_DIR')
directory_path = os.path.dirname(file_path)
normalized_directory_path = remove_prefix(directory_path,
root_directory + os.sep)
normalized_directory_path = normalized_directory_path.replace('\\', '/')
return string_hash(normalized_directory_path) | Return the directory hash for a file path (excludes file name). |
157,413 | import ast
import datetime
import functools
import gc
import hashlib
import inspect
import os
import random
import sys
import time
import urllib.parse
import urllib.request
import weakref
import requests
from clusterfuzz._internal.base import errors
from clusterfuzz._internal.base import memoize
from clusterfuzz._internal.base import retry
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
The provided code snippet includes necessary dependencies for implementing the `get_path_without_ext` function. Write a Python function `def get_path_without_ext(path)` to solve the following problem:
Return a path excluding the extension.
Here is the function:
def get_path_without_ext(path):
"""Return a path excluding the extension."""
return os.path.splitext(path)[0] | Return a path excluding the extension. |
157,414 | import ast
import datetime
import functools
import gc
import hashlib
import inspect
import os
import random
import sys
import time
import urllib.parse
import urllib.request
import weakref
import requests
from clusterfuzz._internal.base import errors
from clusterfuzz._internal.base import memoize
from clusterfuzz._internal.base import retry
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
The provided code snippet includes necessary dependencies for implementing the `get_line_count_string` function. Write a Python function `def get_line_count_string(line_count)` to solve the following problem:
Return string representation for size.
Here is the function:
def get_line_count_string(line_count):
"""Return string representation for size."""
if line_count == 0:
return 'empty'
if line_count == 1:
return '1 line'
return '%d lines' % line_count | Return string representation for size. |
157,415 | import ast
import datetime
import functools
import gc
import hashlib
import inspect
import os
import random
import sys
import time
import urllib.parse
import urllib.request
import weakref
import requests
from clusterfuzz._internal.base import errors
from clusterfuzz._internal.base import memoize
from clusterfuzz._internal.base import retry
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
The provided code snippet includes necessary dependencies for implementing the `get_size_string` function. Write a Python function `def get_size_string(size)` to solve the following problem:
Return string representation for size.
Here is the function:
def get_size_string(size):
"""Return string representation for size."""
if size < 1 << 10:
return '%d B' % size
if size < 1 << 20:
return '%d KB' % (size >> 10)
if size < 1 << 30:
return '%d MB' % (size >> 20)
return '%d GB' % (size >> 30) | Return string representation for size. |
157,416 | import ast
import datetime
import functools
import gc
import hashlib
import inspect
import os
import random
import sys
import time
import urllib.parse
import urllib.request
import weakref
import requests
from clusterfuzz._internal.base import errors
from clusterfuzz._internal.base import memoize
from clusterfuzz._internal.base import retry
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
FUZZ_PREFIX = 'fuzz-'
The provided code snippet includes necessary dependencies for implementing the `is_valid_testcase_file` function. Write a Python function `def is_valid_testcase_file(file_path, check_if_exists=True, size_limit=None, allowed_extensions=None)` to solve the following problem:
Return true if the file looks like a testcase file.
Here is the function:
def is_valid_testcase_file(file_path,
check_if_exists=True,
size_limit=None,
allowed_extensions=None):
"""Return true if the file looks like a testcase file."""
filename = os.path.basename(file_path)
if filename.startswith('.') or filename.startswith(FUZZ_PREFIX):
return False
if allowed_extensions:
file_extension = os.path.splitext(file_path)[1].lower()
if file_extension not in allowed_extensions:
return False
directories_to_ignore = ['.git', '.hg', '.svn']
for directory_to_ignore in directories_to_ignore:
directory_string = '%s%s%s' % (os.sep, directory_to_ignore, os.sep)
if directory_string in file_path:
return False
if (check_if_exists or size_limit) and not os.path.exists(file_path):
return False
if size_limit and os.path.getsize(file_path) > size_limit:
return False
return True | Return true if the file looks like a testcase file. |
157,417 | import ast
import datetime
import functools
import gc
import hashlib
import inspect
import os
import random
import sys
import time
import urllib.parse
import urllib.request
import weakref
import requests
from clusterfuzz._internal.base import errors
from clusterfuzz._internal.base import memoize
from clusterfuzz._internal.base import retry
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
The provided code snippet includes necessary dependencies for implementing the `entity_hash` function. Write a Python function `def entity_hash(obj)` to solve the following problem:
Returns a deterministic hash of a ndb entity. If an entity has been recently modified, put() must be called on it before this function will pick up the changes.
Here is the function:
def entity_hash(obj):
"""Returns a deterministic hash of a ndb entity.
If an entity has been recently modified, put() must be called on it before
this function will pick up the changes.
"""
hasher = hashlib.sha1()
entity_dict = obj.to_dict()
for key in sorted(entity_dict.keys()):
hasher.update(str(entity_dict[key]).encode('utf-8'))
return hasher.hexdigest() | Returns a deterministic hash of a ndb entity. If an entity has been recently modified, put() must be called on it before this function will pick up the changes. |
157,418 | import ast
import datetime
import functools
import gc
import hashlib
import inspect
import os
import random
import sys
import time
import urllib.parse
import urllib.request
import weakref
import requests
from clusterfuzz._internal.base import errors
from clusterfuzz._internal.base import memoize
from clusterfuzz._internal.base import retry
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
def utcnow():
"""Return datetime.datetime.utcnow(). We need this method because we can't
mock built-in methods."""
return datetime.datetime.utcnow() # pragma: no cover.
The provided code snippet includes necessary dependencies for implementing the `time_difference_string` function. Write a Python function `def time_difference_string(timestamp)` to solve the following problem:
Return time difference as a string.
Here is the function:
def time_difference_string(timestamp):
"""Return time difference as a string."""
if not timestamp:
return ''
delta = int((datetime.datetime.utcnow() - timestamp).total_seconds())
d_minutes = delta // 60
d_hours = d_minutes // 60
d_days = d_hours // 24
if d_days > 6:
return '%s' % str(timestamp).split()[0]
if d_days > 1:
return '%s days ago' % d_days # starts at 2 days.
if d_hours > 1:
return '%s hours ago' % d_hours # starts at 2 hours.
if d_minutes > 1:
return '%s minutes ago' % d_minutes
if d_minutes > 0:
return '1 minute ago'
if delta > -30:
return 'moments ago'
# Only say something is in the future if it is more than just clock skew.
return 'in the future' | Return time difference as a string. |
157,419 | import ast
import datetime
import functools
import gc
import hashlib
import inspect
import os
import random
import sys
import time
import urllib.parse
import urllib.request
import weakref
import requests
from clusterfuzz._internal.base import errors
from clusterfuzz._internal.base import memoize
from clusterfuzz._internal.base import retry
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
The provided code snippet includes necessary dependencies for implementing the `wait_until_timeout` function. Write a Python function `def wait_until_timeout(threads, thread_timeout)` to solve the following problem:
Wait for all threads to finish unless the given timeout is reached. If no thread is alive, it waits much shorter than the given timeout. Return True if timeout is exceeded, and return False otherwise.
Here is the function:
def wait_until_timeout(threads, thread_timeout):
"""Wait for all threads to finish unless the given timeout is reached.
If no thread is alive, it waits much shorter than the given timeout.
Return True if timeout is exceeded, and return False otherwise.
"""
thread_alive_check_interval = environment.get_value(
'THREAD_ALIVE_CHECK_INTERVAL')
if not thread_alive_check_interval:
time.sleep(thread_timeout)
return False
wait_timeout = time.time() + thread_timeout
while time.time() < wait_timeout:
time.sleep(thread_alive_check_interval)
thread_alive = False
for thread in threads:
if thread.is_alive():
thread_alive = True
break
if not thread_alive:
return False
return True | Wait for all threads to finish unless the given timeout is reached. If no thread is alive, it waits much shorter than the given timeout. Return True if timeout is exceeded, and return False otherwise. |
157,420 | import functools
import inspect
import sys
import time
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
def sleep(seconds):
"""Invoke time.sleep. This is to avoid the flakiness of time.sleep. See:
crbug.com/770375"""
time.sleep(seconds)
def get_delay(num_try, delay, backoff):
"""Compute backoff delay."""
delay = delay * (backoff**(num_try - 1))
if _should_ignore_delay_for_testing():
# Don't sleep for long during tests. Flake is better.
return min(delay, 3)
return delay
The provided code snippet includes necessary dependencies for implementing the `wrap` function. Write a Python function `def wrap(retries, delay, function, backoff=2, exception_types=None, retry_on_false=False)` to solve the following problem:
Retry decorator for a function.
Here is the function:
def wrap(retries,
delay,
function,
backoff=2,
exception_types=None,
retry_on_false=False):
"""Retry decorator for a function."""
assert delay > 0
assert backoff >= 1
assert retries >= 0
if exception_types is None:
exception_types = [Exception]
def is_exception_type(exception):
return any(
isinstance(exception, exception_type)
for exception_type in exception_types)
def decorator(func):
"""Decorator for the given function."""
tries = retries + 1
is_generator = inspect.isgeneratorfunction(func)
function_with_type = function
if is_generator:
function_with_type += ' (generator)'
def handle_retry(num_try, exception=None):
"""Handle retry."""
from clusterfuzz._internal.metrics import monitoring_metrics
if (exception is None or
is_exception_type(exception)) and num_try < tries:
logs.log(
'Retrying on %s failed with %s. Retrying again.' %
(function_with_type, sys.exc_info()[1]),
num=num_try,
total=tries)
sleep(get_delay(num_try, delay, backoff))
return True
monitoring_metrics.TRY_COUNT.increment({
'function': function,
'is_succeeded': False
})
logs.log_error(
'Retrying on %s failed with %s. Raise.' % (function_with_type,
sys.exc_info()[1]),
total=tries)
return False
@functools.wraps(func)
def _wrapper(*args, **kwargs):
"""Regular function wrapper."""
from clusterfuzz._internal.metrics import monitoring_metrics
for num_try in range(1, tries + 1):
try:
result = func(*args, **kwargs)
if retry_on_false and not result:
if not handle_retry(num_try):
return result
continue
monitoring_metrics.TRY_COUNT.increment({
'function': function,
'is_succeeded': True
})
return result
except Exception as e:
if not handle_retry(num_try, exception=e):
raise
return None
@functools.wraps(func)
def _generator_wrapper(*args, **kwargs):
"""Generator function wrapper."""
# This argument is not applicable for generator functions.
assert not retry_on_false
from clusterfuzz._internal.metrics import monitoring_metrics
already_yielded_element_count = 0
for num_try in range(1, tries + 1):
try:
for index, result in enumerate(func(*args, **kwargs)):
if index >= already_yielded_element_count:
yield result
already_yielded_element_count += 1
monitoring_metrics.TRY_COUNT.increment({
'function': function,
'is_succeeded': True
})
break
except Exception as e:
if not handle_retry(num_try, exception=e):
raise
if is_generator:
return _generator_wrapper
return _wrapper
return decorator | Retry decorator for a function. |
157,421 | import hashlib
import os
from clusterfuzz._internal.base import json_utils
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
def clear_values(clear_all=False):
"""Remove all values."""
cache_directory_path = environment.get_value('CACHE_DIR')
if not os.path.exists(cache_directory_path):
return
for root_directory, _, filenames in os.walk(cache_directory_path):
for filename in filenames:
if filename.endswith(PERSIST_FILE_EXTENSION) and not clear_all:
continue
file_path = os.path.join(root_directory, filename)
persist_file_path = file_path + PERSIST_FILE_EXTENSION
if os.path.exists(persist_file_path) and not clear_all:
continue
os.remove(file_path)
def get_value(key, default_value=None, constructor=None):
"""Get the value for a key."""
value_path = get_value_file_path(key)
if not os.path.exists(value_path):
return default_value
try:
with open(value_path, 'rb') as f:
value_str = f.read()
except OSError:
logs.log_error('Failed to read %s from persistent cache.' % key)
return default_value
try:
value = json_utils.loads(value_str)
except Exception:
logs.log_warn('Non-serializable value read from cache key %s: "%s"' %
(key, value_str))
return default_value
if constructor:
try:
value = constructor(value)
except Exception:
logs.log_warn('Failed to construct value "%s" using %s '
'and key "%s" in persistent cache. Using default value %s.'
% (value, constructor, key, default_value))
return default_value
return value
The provided code snippet includes necessary dependencies for implementing the `initialize` function. Write a Python function `def initialize()` to solve the following problem:
Initialize the persistent cache, creating the directory used to store the values.
Here is the function:
def initialize():
"""Initialize the persistent cache, creating the directory used to store the
values."""
cache_directory_path = environment.get_value('CACHE_DIR')
if os.path.exists(cache_directory_path):
clear_values()
else:
os.makedirs(cache_directory_path) | Initialize the persistent cache, creating the directory used to store the values. |
157,422 | import time
from clusterfuzz._internal.base import utils
from clusterfuzz._internal.system import environment
The provided code snippet includes necessary dependencies for implementing the `initialize_timezone_from_environment` function. Write a Python function `def initialize_timezone_from_environment()` to solve the following problem:
Initializes timezone for date functions based on environment.
Here is the function:
def initialize_timezone_from_environment():
"""Initializes timezone for date functions based on environment."""
plt = environment.platform()
if plt == 'WINDOWS':
return
# Only available on Unix platforms.
time.tzset() | Initializes timezone for date functions based on environment. |
157,423 |
The provided code snippet includes necessary dependencies for implementing the `error_in_list` function. Write a Python function `def error_in_list(error_stacktrace, error_list)` to solve the following problem:
Returns if the error exists in the error list.
Here is the function:
def error_in_list(error_stacktrace, error_list):
"""Returns if the error exists in the error list."""
# Change all strings to lowercase for comparison.
error_stacktrace = error_stacktrace.lower()
error_list = [error.lower() for error in error_list]
for error in error_list:
if error in error_stacktrace:
return True
return False | Returns if the error exists in the error list. |
157,424 | import contextlib
import datetime
import json
import random
import threading
import time
from typing import List
from typing import Optional
from clusterfuzz._internal.base import external_tasks
from clusterfuzz._internal.base import persistent_cache
from clusterfuzz._internal.base import task_utils
from clusterfuzz._internal.base import utils
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.datastore import data_types
from clusterfuzz._internal.datastore import ndb_utils
from clusterfuzz._internal.fuzzing import fuzzer_selection
from clusterfuzz._internal.google_cloud_utils import pubsub
from clusterfuzz._internal.google_cloud_utils import storage
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
JOBS_PREFIX = 'jobs'
HIGH_END_JOBS_PREFIX = 'high-end-jobs'
def get_machine_templates():
"""Returns machine templates."""
# TODO(metzman): Cache this.
clusters_config = local_config.Config(local_config.GCE_CLUSTERS_PATH).get()
project = utils.get_application_id()
conf = clusters_config[project]
return conf['instance_templates']
The provided code snippet includes necessary dependencies for implementing the `get_machine_template_for_queue` function. Write a Python function `def get_machine_template_for_queue(queue_name)` to solve the following problem:
Gets the machine template for the instance used to execute a task from |queue_name|. This will be used by tworkers to schedule the appropriate machine using batch to execute the utask_main part of a utask.
Here is the function:
def get_machine_template_for_queue(queue_name):
"""Gets the machine template for the instance used to execute a task from
|queue_name|. This will be used by tworkers to schedule the appropriate
machine using batch to execute the utask_main part of a utask."""
initial_queue_name = queue_name
# Handle it being high-end (preemptible) or not.
if queue_name.startswith(JOBS_PREFIX):
is_high_end = False
prefix = JOBS_PREFIX
else:
assert queue_name.startswith(HIGH_END_JOBS_PREFIX)
is_high_end = True
prefix = HIGH_END_JOBS_PREFIX
# Add 1 for hyphen.
queue_name = queue_name[len(prefix) + 1:]
template_name = f'clusterfuzz-{queue_name}'
if not is_high_end:
template_name = f'{template_name}-pre'
templates = get_machine_templates()
for template in templates:
if template['name'] == template_name:
logs.log(
f'Found machine template for {initial_queue_name}',
machine_template=template)
return template
return None | Gets the machine template for the instance used to execute a task from |queue_name|. This will be used by tworkers to schedule the appropriate machine using batch to execute the utask_main part of a utask. |
157,425 | import contextlib
import datetime
import json
import random
import threading
import time
from typing import List
from typing import Optional
from clusterfuzz._internal.base import external_tasks
from clusterfuzz._internal.base import persistent_cache
from clusterfuzz._internal.base import task_utils
from clusterfuzz._internal.base import utils
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.datastore import data_types
from clusterfuzz._internal.datastore import ndb_utils
from clusterfuzz._internal.fuzzing import fuzzer_selection
from clusterfuzz._internal.google_cloud_utils import pubsub
from clusterfuzz._internal.google_cloud_utils import storage
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
UTASK_MAINS_QUEUE = 'utask_main'
def add_task(command,
argument,
job_type,
queue=None,
wait_time=None,
extra_info=None):
"""Add a new task to the job queue."""
# Old testcases may pass in queue=None explicitly,
# so we must check this here.
if not queue:
queue = default_queue()
if wait_time is None:
wait_time = random.randint(1, TASK_CREATION_WAIT_INTERVAL)
if job_type != 'none':
job = data_types.Job.query(data_types.Job.name == job_type).get()
if not job:
raise Error(f'Job {job_type} not found.')
if job.is_external():
external_tasks.add_external_task(command, argument, job)
return
# Add the task.
eta = utils.utcnow() + datetime.timedelta(seconds=wait_time)
task = Task(command, argument, job_type, eta=eta, extra_info=extra_info)
pubsub_client = pubsub.PubSubClient()
pubsub_client.publish(
pubsub.topic_name(utils.get_application_id(), queue),
[task.to_pubsub_message()])
The provided code snippet includes necessary dependencies for implementing the `add_utask_main` function. Write a Python function `def add_utask_main(command, input_url, job_type, wait_time=None)` to solve the following problem:
Adds the utask_main portion of a utask to the utasks queue for scheduling on batch. This should only be done after preprocessing.
Here is the function:
def add_utask_main(command, input_url, job_type, wait_time=None):
"""Adds the utask_main portion of a utask to the utasks queue for scheduling
on batch. This should only be done after preprocessing."""
initial_command = environment.get_value('TASK_PAYLOAD')
add_task(
command,
input_url,
job_type,
queue=UTASK_MAINS_QUEUE,
wait_time=wait_time,
extra_info={'initial_command': initial_command}) | Adds the utask_main portion of a utask to the utasks queue for scheduling on batch. This should only be done after preprocessing. |
157,426 | import contextlib
import datetime
import json
import random
import threading
import time
from typing import List
from typing import Optional
from clusterfuzz._internal.base import external_tasks
from clusterfuzz._internal.base import persistent_cache
from clusterfuzz._internal.base import task_utils
from clusterfuzz._internal.base import utils
from clusterfuzz._internal.config import local_config
from clusterfuzz._internal.datastore import data_types
from clusterfuzz._internal.datastore import ndb_utils
from clusterfuzz._internal.fuzzing import fuzzer_selection
from clusterfuzz._internal.google_cloud_utils import pubsub
from clusterfuzz._internal.google_cloud_utils import storage
from clusterfuzz._internal.metrics import logs
from clusterfuzz._internal.system import environment
VALID_REDO_TASKS = ['minimize', 'regression', 'progression', 'impact', 'blame']
class InvalidRedoTask(Error):
def __init__(self, task):
super().__init__("The task '%s' is invalid." % task)
def add_task(command,
argument,
job_type,
queue=None,
wait_time=None,
extra_info=None):
"""Add a new task to the job queue."""
# Old testcases may pass in queue=None explicitly,
# so we must check this here.
if not queue:
queue = default_queue()
if wait_time is None:
wait_time = random.randint(1, TASK_CREATION_WAIT_INTERVAL)
if job_type != 'none':
job = data_types.Job.query(data_types.Job.name == job_type).get()
if not job:
raise Error(f'Job {job_type} not found.')
if job.is_external():
external_tasks.add_external_task(command, argument, job)
return
# Add the task.
eta = utils.utcnow() + datetime.timedelta(seconds=wait_time)
task = Task(command, argument, job_type, eta=eta, extra_info=extra_info)
pubsub_client = pubsub.PubSubClient()
pubsub_client.publish(
pubsub.topic_name(utils.get_application_id(), queue),
[task.to_pubsub_message()])
def queue_for_testcase(testcase):
"""Return the right queue for the testcase."""
is_high_end = (
testcase.queue and testcase.queue.startswith(HIGH_END_JOBS_PREFIX))
return queue_for_job(testcase.job_type, is_high_end=is_high_end)
The provided code snippet includes necessary dependencies for implementing the `redo_testcase` function. Write a Python function `def redo_testcase(testcase, tasks, user_email)` to solve the following problem:
Redo specific tasks for a testcase. This is requested by the user from the web interface.
Here is the function:
def redo_testcase(testcase, tasks, user_email):
"""Redo specific tasks for a testcase. This is requested by the user from the
web interface."""
for task in tasks:
if task not in VALID_REDO_TASKS:
raise InvalidRedoTask(task)
minimize = 'minimize' in tasks
regression = 'regression' in tasks
progression = 'progression' in tasks
impact = 'impact' in tasks
blame = 'blame' in tasks
task_list = []
testcase_id = testcase.key.id()
# Metadata keys to clear based on which redo tasks were selected.
metadata_keys_to_clear = ['potentially_flaky']
if minimize:
task_list.append('minimize')
testcase.minimized_keys = ''
testcase.set_metadata('redo_minimize', True, update_testcase=False)
metadata_keys_to_clear += [
'env', 'current_minimization_phase_attempts', 'minimization_phase'
]
# If this testcase was archived during minimization, update the state.
testcase.archive_state &= ~data_types.ArchiveStatus.MINIMIZED
if regression:
task_list.append('regression')
testcase.regression = ''
metadata_keys_to_clear += ['last_regression_min', 'last_regression_max']
if progression:
task_list.append('progression')
testcase.fixed = ''
testcase.open = True
testcase.last_tested_crash_stacktrace = None
testcase.triaged = False
testcase.set_metadata('progression_pending', True, update_testcase=False)
metadata_keys_to_clear += [
'last_progression_min', 'last_progression_max', 'last_tested_revision'
]
if impact:
task_list.append('impact')
testcase.is_impact_set_flag = False
if blame:
task_list.append('blame')
testcase.set_metadata('blame_pending', True, update_testcase=False)
testcase.set_metadata('predator_result', None, update_testcase=False)
for key in metadata_keys_to_clear:
testcase.delete_metadata(key, update_testcase=False)
testcase.comments += '[%s] %s: Redo task(s): %s\n' % (
utils.current_date_time(), user_email, ', '.join(sorted(task_list)))
testcase.one_time_crasher_flag = False
testcase.put()
# Allow new notifications to be sent for this testcase.
notifications = ndb_utils.get_all_from_query(
data_types.Notification.query(
data_types.Notification.testcase_id == testcase.key.id()),
keys_only=True)
ndb_utils.delete_multi(notifications)
# Use wait_time=0 to execute the task ASAP, since it is user-facing.
wait_time = 0
# If we are re-doing minimization, other tasks will be done automatically
# after minimization completes. So, don't add those tasks.
if minimize:
add_task(
'minimize',
testcase_id,
testcase.job_type,
queue_for_testcase(testcase),
wait_time=wait_time)
return
if regression:
add_task(
'regression',
testcase_id,
testcase.job_type,
queue_for_testcase(testcase),
wait_time=wait_time)
if progression:
add_task(
'progression',
testcase_id,
testcase.job_type,
queue_for_testcase(testcase),
wait_time=wait_time)
if impact:
add_task(
'impact',
testcase_id,
testcase.job_type,
queue_for_testcase(testcase),
wait_time=wait_time)
if blame:
add_task(
'blame',
testcase_id,
testcase.job_type,
queue_for_testcase(testcase),
wait_time=wait_time) | Redo specific tasks for a testcase. This is requested by the user from the web interface. |
157,427 | from clusterfuzz._internal.base import memoize
from clusterfuzz._internal.base import utils
from clusterfuzz._internal.datastore import data_handler
from clusterfuzz._internal.datastore import data_types
from clusterfuzz._internal.datastore import fuzz_target_utils
from clusterfuzz._internal.datastore import ndb_utils
def _allowed_users_for_entity(name, entity_kind, auto_cc=None):
"""Return a list of users that have permissions for the given entity.
Args:
name: The name of the entity.
entity_kind: The type (data_types.PermissionEntityKind) of the entity.
auto_cc: The Auto CC type (data_types.AutoCCType) to filter on, or None.
Returns:
A list of user emails that have permission to access the given entity.
"""
if not name:
return []
# Easy case: direct matches.
direct_match_permissions = data_types.ExternalUserPermission.query(
data_types.ExternalUserPermission.entity_kind == entity_kind,
data_types.ExternalUserPermission.entity_name == name,
ndb_utils.is_false(data_types.ExternalUserPermission.is_prefix),
projection=[data_types.ExternalUserPermission.email])
if auto_cc is not None:
direct_match_permissions = direct_match_permissions.filter(
data_types.ExternalUserPermission.auto_cc == auto_cc)
allowed_users = [permission.email for permission in direct_match_permissions]
# Find all permissions where the prefix matches the fuzzer_name.
# Unfortunately, Datastore doesn't give us an easy way of doing so. To iterate
# through a smaller set than every single permission, get all permissions that
# contain a prefix string <= than the actual fuzzer name and >= the first
# character.
prefix_match_permissions = data_types.ExternalUserPermission.query(
data_types.ExternalUserPermission.entity_kind == entity_kind,
data_types.ExternalUserPermission.entity_name <= name,
data_types.ExternalUserPermission.entity_name >= name[0],
ndb_utils.is_true(data_types.ExternalUserPermission.is_prefix),
projection=[
data_types.ExternalUserPermission.email,
data_types.ExternalUserPermission.entity_name
])
if auto_cc is not None:
prefix_match_permissions = prefix_match_permissions.filter(
data_types.ExternalUserPermission.auto_cc == auto_cc)
for permission in prefix_match_permissions:
if not permission.entity_name:
# No external user should have an empty prefix (access to all
# fuzzers/jobs).
continue
if name.startswith(permission.entity_name):
allowed_users.append(permission.email)
return sorted(allowed_users)
The provided code snippet includes necessary dependencies for implementing the `allowed_users_for_fuzzer` function. Write a Python function `def allowed_users_for_fuzzer(fuzzer_name)` to solve the following problem:
Return allowed external users for the given fuzzer. Args: fuzzer_name: The name of the fuzzer. Returns: A list of user emails that are allowed to view information relating to this fuzzer.
Here is the function:
def allowed_users_for_fuzzer(fuzzer_name):
"""Return allowed external users for the given fuzzer.
Args:
fuzzer_name: The name of the fuzzer.
Returns:
A list of user emails that are allowed to view information relating to this
fuzzer.
"""
# TODO(ochang): Once we support jobs, take that into account.
return _allowed_users_for_entity(fuzzer_name,
data_types.PermissionEntityKind.FUZZER) | Return allowed external users for the given fuzzer. Args: fuzzer_name: The name of the fuzzer. Returns: A list of user emails that are allowed to view information relating to this fuzzer. |
157,428 | from clusterfuzz._internal.base import memoize
from clusterfuzz._internal.base import utils
from clusterfuzz._internal.datastore import data_handler
from clusterfuzz._internal.datastore import data_types
from clusterfuzz._internal.datastore import fuzz_target_utils
from clusterfuzz._internal.datastore import ndb_utils
def _get_permissions_query_for_user(user_email, entity_kind=None):
"""Get a permissions query for a given user.
Args:
user_email: The email of the user.
entity_kind: The type (data_types.PermissionEntityKind) of the permission to
filter by, or None.
Returns:
A ndb.Query giving the permissions for the given parameters.
"""
permissions_for_user = data_types.ExternalUserPermission.query(
data_types.ExternalUserPermission.email == utils.normalize_email(
user_email))
if entity_kind is not None:
permissions_for_user = permissions_for_user.filter(
data_types.ExternalUserPermission.entity_kind == entity_kind)
return permissions_for_user
The provided code snippet includes necessary dependencies for implementing the `is_upload_allowed_for_user` function. Write a Python function `def is_upload_allowed_for_user(user_email)` to solve the following problem:
Return whether if the given user has upload permissions. Args: user_email: The email of the user. Returns: A bool indicating whether the given user has upload permissions.
Here is the function:
def is_upload_allowed_for_user(user_email):
"""Return whether if the given user has upload permissions.
Args:
user_email: The email of the user.
Returns:
A bool indicating whether the given user has upload permissions.
"""
permissions = _get_permissions_query_for_user(
user_email, data_types.PermissionEntityKind.UPLOADER)
return bool(permissions.get()) | Return whether if the given user has upload permissions. Args: user_email: The email of the user. Returns: A bool indicating whether the given user has upload permissions. |
157,429 | import functools
from clusterfuzz._internal.base import tasks
from clusterfuzz._internal.base import utils
from clusterfuzz._internal.system import environment
The provided code snippet includes necessary dependencies for implementing the `untrusted_noop` function. Write a Python function `def untrusted_noop(return_value=None)` to solve the following problem:
Return a decorator that turns functions into no-ops if the bot is untrusted.
Here is the function:
def untrusted_noop(return_value=None):
"""Return a decorator that turns functions into no-ops if the bot is
untrusted."""
def decorator(func):
"""Decorator function."""
@functools.wraps(func)
def wrapped(*args, **kwargs):
if environment.is_untrusted_worker():
return return_value
return func(*args, **kwargs)
return wrapped
return decorator | Return a decorator that turns functions into no-ops if the bot is untrusted. |
157,430 | import argparse
import datetime
import random
import subprocess
import sys
import time
GSUTIL_CMD = 'gsutil'
def _run_command(command):
"""Runs a command and prints it."""
print(
'Running command [{time}]:'.format(
time=datetime.datetime.now().strftime('%H:%M:%S')),
' '.join(command))
for _ in range(RETRY_COUNT):
try:
return subprocess.check_output(command, stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as e:
print('Command failed with non-zero exit code. Output:\n%s' % e.output)
print('Sleeping a few seconds before retrying.')
time.sleep(random.randint(0, SLEEP_WAIT))
print('Failed to run command, exiting.')
sys.exit(-1)
The provided code snippet includes necessary dependencies for implementing the `_copy_corpus` function. Write a Python function `def _copy_corpus(source_bucket, source_project, target_bucket, target_project)` to solve the following problem:
Copy corpus from a source bucket to target bucket, keeping their project names into account.
Here is the function:
def _copy_corpus(source_bucket, source_project, target_bucket, target_project):
"""Copy corpus from a source bucket to target bucket, keeping their project
names into account."""
# Ensure that gsutil is installed.
subprocess.check_call([GSUTIL_CMD, '-v'])
source_urls_fetch_command = [
GSUTIL_CMD, 'ls', 'gs://{bucket}/*/'.format(bucket=source_bucket)
]
source_urls = _run_command(source_urls_fetch_command).splitlines()
filtered_source_urls = [
s.rstrip('/') for s in source_urls if s.strip() and not s.endswith(':')
]
assert filtered_source_urls, 'No matching items found in source corpus.'
for source_url in filtered_source_urls:
url_part, fuzz_target = source_url.rsplit('/', 1)
# Strip source project prefix and add target project prefix (if exists).
if source_project and fuzz_target.startswith(source_project + '_'):
fuzz_target = fuzz_target[len(source_project) + 1:]
if target_project:
fuzz_target = '%s_%s' % (target_project, fuzz_target)
# Replace source bucket with target bucket for target url.
url_part = url_part.replace('gs://%s' % source_bucket,
'gs://%s' % target_bucket)
target_url = '%s/%s' % (url_part, fuzz_target)
_run_command(
[GSUTIL_CMD, '-m', 'rsync', '-d', '-r', source_url, target_url])
print('Copy corpus finished successfully.') | Copy corpus from a source bucket to target bucket, keeping their project names into account. |
157,431 | import os
import signal
from local.butler import appengine
from local.butler import common
from local.butler import constants
def _setup_bot_directory(args):
"""Set up the bot directory."""
appengine.symlink_config_dir()
src_root_dir = os.path.abspath('.')
if os.path.exists(args.directory):
print('Bot directory already exists. Re-using...')
else:
print('Creating new CF bot directory...')
os.makedirs(args.directory)
clusterfuzz_dir = os.path.join(args.directory, 'clusterfuzz')
bot_src_dir = os.path.join(clusterfuzz_dir, 'src')
if not os.path.exists(clusterfuzz_dir):
os.makedirs(clusterfuzz_dir)
os.mkdir(bot_src_dir)
common.update_dir(
os.path.join(src_root_dir, 'src', 'appengine'),
os.path.join(bot_src_dir, 'appengine'))
common.update_dir(
os.path.join(src_root_dir, 'src', 'python'),
os.path.join(bot_src_dir, 'python'))
common.update_dir(
os.path.join(src_root_dir, 'src', 'clusterfuzz'),
os.path.join(bot_src_dir, 'clusterfuzz'))
common.update_dir(
os.path.join(src_root_dir, 'src', 'third_party'),
os.path.join(bot_src_dir, 'third_party'))
common.update_dir(
os.path.join(src_root_dir, 'resources'),
os.path.join(clusterfuzz_dir, 'resources'))
common.update_dir(
os.path.join(src_root_dir, 'bot'), os.path.join(clusterfuzz_dir, 'bot'))
def _setup_environment_and_configs(args, appengine_path):
"""Set up environment variables and configuration files."""
clusterfuzz_dir = os.path.abspath(os.path.join(args.directory, 'clusterfuzz'))
# Matches startup scripts.
os.environ['PYTHONPATH'] = ':'.join([
os.getenv('PYTHONPATH', ''),
appengine_path,
os.path.join(clusterfuzz_dir, 'src'),
])
os.environ['ROOT_DIR'] = clusterfuzz_dir
if not os.getenv('BOT_NAME'):
os.environ['BOT_NAME'] = args.name
os.environ['LD_LIBRARY_PATH'] = '{0}:{1}'.format(
os.path.join(clusterfuzz_dir, 'src', 'clusterfuzz', '_internal',
'scripts'), os.getenv('LD_LIBRARY_PATH', ''))
tmpdir = os.path.join(clusterfuzz_dir, 'bot_tmpdir')
if not os.path.exists(tmpdir):
os.mkdir(tmpdir)
os.environ['TMPDIR'] = tmpdir
os.environ['BOT_TMPDIR'] = tmpdir
os.environ['KILL_STALE_INSTANCES'] = 'False'
os.environ['LOCAL_DEVELOPMENT'] = 'True'
os.environ['DATASTORE_EMULATOR_HOST'] = constants.DATASTORE_EMULATOR_HOST
os.environ['PUBSUB_EMULATOR_HOST'] = constants.PUBSUB_EMULATOR_HOST
os.environ['APPLICATION_ID'] = constants.TEST_APP_ID
if not os.getenv('UNTRUSTED_WORKER'):
local_gcs_buckets_path = os.path.abspath(
os.path.join(args.server_storage_path, 'local_gcs'))
assert os.path.exists(local_gcs_buckets_path), (
'Server storage path not found, make sure to start run_server with '
'the same storage path.')
os.environ['LOCAL_GCS_BUCKETS_PATH'] = local_gcs_buckets_path
if args.android_serial:
if not os.getenv('OS_OVERRIDE'):
os.environ['OS_OVERRIDE'] = 'ANDROID'
os.environ['ANDROID_SERIAL'] = args.android_serial
The provided code snippet includes necessary dependencies for implementing the `execute` function. Write a Python function `def execute(args)` to solve the following problem:
Run the bot.
Here is the function:
def execute(args):
"""Run the bot."""
appengine_path = appengine.find_sdk_path()
_setup_bot_directory(args)
_setup_environment_and_configs(args, appengine_path)
exit_code = 0
try:
os.chdir(os.path.join(args.directory, 'clusterfuzz'))
proc = common.execute_async('python src/python/bot/startup/run_bot.py')
def _stop_handler(*_):
print('Bot has been stopped. Exit.')
proc.kill()
signal.signal(signal.SIGTERM, _stop_handler)
common.process_proc_output(proc)
exit_code = proc.wait()
except KeyboardInterrupt:
_stop_handler()
# exit_code should be 0 when Ctrl-Ced.
return exit_code | Run the bot. |
157,432 | from local.butler import appengine
from local.butler import common
The provided code snippet includes necessary dependencies for implementing the `execute` function. Write a Python function `def execute(args)` to solve the following problem:
Install all required dependencies for running tests, the appengine, and the bot.
Here is the function:
def execute(args):
"""Install all required dependencies for running tests, the appengine,
and the bot."""
del args
common.install_dependencies()
appengine.symlink_dirs()
print('Bootstrap successfully finished.') | Install all required dependencies for running tests, the appengine, and the bot. |
157,433 | import importlib
import os
import sys
from local.butler import constants
from src.clusterfuzz._internal.config import local_config
from src.clusterfuzz._internal.datastore import ndb_init
import sys
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
The provided code snippet includes necessary dependencies for implementing the `execute` function. Write a Python function `def execute(args)` to solve the following problem:
Run Python unit tests under v2. For unittests involved appengine, sys.path needs certain modification.
Here is the function:
def execute(args):
"""Run Python unit tests under v2. For unittests involved appengine, sys.path
needs certain modification."""
print(args.script_args)
sys.path.insert(0, os.path.abspath(os.path.join('src', 'appengine')))
sys.path.insert(
0, os.path.abspath(os.path.join('src', 'appengine', 'third_party')))
os.environ['CONFIG_DIR_OVERRIDE'] = args.config_dir
local_config.ProjectConfig().set_environment()
if args.local:
os.environ['DATASTORE_EMULATOR_HOST'] = constants.DATASTORE_EMULATOR_HOST
os.environ['PUBSUB_EMULATOR_HOST'] = constants.PUBSUB_EMULATOR_HOST
os.environ['DATASTORE_USE_PROJECT_ID_AS_APP_ID'] = 'true'
os.environ['LOCAL_DEVELOPMENT'] = 'True'
if not args.non_dry_run:
print('Running in dry-run mode, no datastore writes are committed. '
'For permanent modifications, re-run with --non-dry-run.')
with ndb_init.context():
script = importlib.import_module(f'local.butler.scripts.{args.script_name}')
script.execute(args)
if not args.local:
print()
print('Please remember to run the migration individually on all projects.')
print() | Run Python unit tests under v2. For unittests involved appengine, sys.path needs certain modification. |
157,434 | import os
import sys
def check_virtualenv():
"""Check that we're in a virtualenv."""
if sys.version_info.major != 3:
raise RuntimeError('Python 2 is no longer supported!')
is_in_virtualenv = bool(os.getenv('VIRTUAL_ENV'))
if not is_in_virtualenv:
raise RuntimeError(
'You are not in a virtual env environment. Please install it with'
' `./local/install_deps.bash` or load it with'
' `pipenv shell`. Then, you can re-run this command.')
The provided code snippet includes necessary dependencies for implementing the `check` function. Write a Python function `def check()` to solve the following problem:
Check if we are in virtualenv and dev requirements are installed.
Here is the function:
def check():
"""Check if we are in virtualenv and dev requirements are installed."""
if os.getenv('TEST_BOT_ENVIRONMENT'):
# Don't need to do these checks if we're in the bot environment.
return
check_virtualenv() | Check if we are in virtualenv and dev requirements are installed. |
157,435 | import inspect
from fabric import api
import paramiko
from local.remote.handlers import android_chrome_lab
from local.remote.handlers import linux
from local.remote.handlers import mac
from local.remote.handlers import windows
def _get_handler_ctor(args):
"""Get a Handler class given arguments."""
if 'linux' in args.instance_name:
return linux.Handler
if 'windows' in args.instance_name:
return windows.Handler
if 'golo' in args.instance_name:
return mac.Handler
if 'android-build' in args.instance_name:
return android_chrome_lab.Handler
raise NotImplementedError('Unsupported platform.')
def _args_to_dict(args, method):
"""Convert args to dict that is compatible with the method's argument."""
arg_names = inspect.getfullargspec(method).args[1:]
args_dict = {
k: v for k, v in vars(args.items()) if k in arg_names and v is not None
}
return args_dict
The provided code snippet includes necessary dependencies for implementing the `execute` function. Write a Python function `def execute(args)` to solve the following problem:
Run command-line tasks on a remote bot.
Here is the function:
def execute(args):
"""Run command-line tasks on a remote bot."""
handler_ctor = _get_handler_ctor(args)
handler = handler_ctor(**_args_to_dict(args, handler_ctor.__init__))
method = getattr(handler, args.remote)
method(**_args_to_dict(args, method)) | Run command-line tasks on a remote bot. |
157,436 | import datetime
from distutils import dir_util
import io
import os
import platform
import shlex
import shutil
import stat
import subprocess
import sys
import tempfile
import urllib.request
import zipfile
from local.butler import constants
The provided code snippet includes necessary dependencies for implementing the `_run_and_handle_exception` function. Write a Python function `def _run_and_handle_exception(arguments, exception_class)` to solve the following problem:
Run a command and handle its error output.
Here is the function:
def _run_and_handle_exception(arguments, exception_class):
"""Run a command and handle its error output."""
print('Running:', ' '.join(shlex.quote(arg) for arg in arguments))
try:
return subprocess.check_output(arguments)
except subprocess.CalledProcessError as e:
raise exception_class(e.output) | Run a command and handle its error output. |
157,437 | import datetime
from distutils import dir_util
import io
import os
import platform
import shlex
import shutil
import stat
import subprocess
import sys
import tempfile
import urllib.request
import zipfile
from local.butler import constants
The provided code snippet includes necessary dependencies for implementing the `copy_dir` function. Write a Python function `def copy_dir(src, target)` to solve the following problem:
Copy directory.
Here is the function:
def copy_dir(src, target):
"""Copy directory."""
if os.path.exists(target):
shutil.rmtree(target, ignore_errors=True)
shutil.copytree(src, target) | Copy directory. |
157,438 | import datetime
from distutils import dir_util
import io
import os
import platform
import shlex
import shutil
import stat
import subprocess
import sys
import tempfile
import urllib.request
import zipfile
from local.butler import constants
The provided code snippet includes necessary dependencies for implementing the `test_bucket` function. Write a Python function `def test_bucket(env_var)` to solve the following problem:
Get the integration test bucket.
Here is the function:
def test_bucket(env_var):
"""Get the integration test bucket."""
bucket = os.getenv(env_var)
if not bucket:
raise RuntimeError(f'You need to specify {env_var} for integration testing')
return bucket | Get the integration test bucket. |
157,439 | import datetime
from distutils import dir_util
import io
import os
import platform
import shlex
import shutil
import stat
import subprocess
import sys
import tempfile
import urllib.request
import zipfile
from local.butler import constants
def is_newer(src, dst):
if not os.path.exists(dst):
return True
src_time = get_modified_time(src)
dst_time = get_modified_time(dst)
return src_time > dst_time
def copy_if_newer(src, dst):
if is_newer(src, dst):
return shutil.copy2(src, dst)
return False | null |
157,440 | import json
import os
import shutil
import subprocess
import sys
import google_auth_httplib2
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient import discovery
import httplib2
from local.butler import appengine
from local.butler import common
class DomainVerifier:
"""Domain verifier."""
def __init__(self, oauth_client_secrets_path):
flow = InstalledAppFlow.from_client_secrets_file(
oauth_client_secrets_path,
scopes=['https://www.googleapis.com/auth/siteverification'])
credentials = flow.run_local_server()
http = google_auth_httplib2.AuthorizedHttp(
credentials, http=httplib2.Http())
self.api = discovery.build('siteVerification', 'v1', http=http)
def get_domain_verification_tag(self, domain):
"""Get the domain verification meta tag."""
response = self.api.webResource().getToken(
body={
'verificationMethod': 'FILE',
'site': {
'identifier': domain,
'type': 'SITE',
}
}).execute(num_retries=_NUM_RETRIES)
return response['token']
def verify(self, domain):
"""Verify the domain verification meta tag."""
self.api.webResource().insert(
body={
'site': {
'identifier': domain,
'type': 'SITE',
}
},
verificationMethod='FILE').execute(num_retries=_NUM_RETRIES)
def add_owner(self, domain, email):
"""Add a new domain owner."""
response = self.api.webResource().get(id=domain).execute(
num_retries=_NUM_RETRIES)
if email not in response['owners']:
response['owners'].append(email)
self.api.webResource().update(
id=domain, body=response).execute(num_retries=_NUM_RETRIES)
def app_engine_service_account(project_id):
"""Get the default App Engine service account."""
return project_id + '@appspot.gserviceaccount.com'
def enable_services(gcloud):
"""Enable required services."""
for i in range(0, len(_REQUIRED_SERVICES), _ENABLE_SERVICE_BATCH_SIZE):
end = i + _ENABLE_SERVICE_BATCH_SIZE
gcloud.run('services', 'enable', *_REQUIRED_SERVICES[i:i + end])
def project_bucket(project_id, bucket_name):
"""Return a project-specific bucket name."""
return f'{bucket_name}.{project_id}.appspot.com'
def create_new_config(gcloud, project_id, new_config_dir,
domain_verification_tag, bucket_replacements,
gae_location, gce_zone, firebase_api_key):
"""Create a new config directory."""
if os.path.exists(new_config_dir):
print('Overwriting existing directory.')
shutil.rmtree(new_config_dir)
gae_region = appengine.region_from_location(gae_location)
replacements = [
('test-clusterfuzz-service-account-email',
compute_engine_service_account(gcloud, project_id)),
('test-clusterfuzz', project_id),
('test-project', project_id),
('domain-verification-tag', domain_verification_tag),
('gae-region', gae_region),
('gce-zone', gce_zone),
('firebase-api-key', firebase_api_key),
]
replacements.extend(bucket_replacements)
shutil.copytree(os.path.join('configs', 'test'), new_config_dir)
for root_dir, _, filenames in os.walk(new_config_dir):
for filename in filenames:
file_path = os.path.join(root_dir, filename)
replace_file_contents(file_path, replacements)
def deploy_appengine(gcloud, config_dir, appengine_location):
"""Deploy to App Engine."""
try:
gcloud.run('app', 'describe')
except common.GcloudError:
# Create new App Engine app if it does not exist.
gcloud.run('app', 'create', '--region=' + appengine_location)
subprocess.check_call([
'python', 'butler.py', 'deploy', '--force', '--targets', 'appengine',
'--prod', '--config-dir', config_dir
])
def deploy_zips(config_dir):
"""Deploy source zips."""
subprocess.check_call([
'python', 'butler.py', 'deploy', '--force', '--targets', 'zips', '--prod',
'--config-dir', config_dir
])
def create_buckets(project_id, buckets):
"""Create buckets."""
gsutil = common.Gsutil()
for bucket in buckets:
try:
gsutil.run('defstorageclass', 'get', 'gs://' + bucket)
except common.GsutilError:
# Create the bucket if it does not exist.
gsutil.run('mb', '-p', project_id, 'gs://' + bucket)
def set_cors(config_dir, buckets):
"""Sets cors settings."""
gsutil = common.Gsutil()
cors_file_path = os.path.join(config_dir, 'gae', 'cors.json')
for bucket in buckets:
gsutil.run('cors', 'set', cors_file_path, 'gs://' + bucket)
def add_service_account_role(gcloud, project_id, service_account, role):
"""Add an IAM role to a service account."""
gcloud.run('projects', 'add-iam-policy-binding', project_id, '--member',
'serviceAccount:' + service_account, '--role', role)
import sys
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
The provided code snippet includes necessary dependencies for implementing the `execute` function. Write a Python function `def execute(args)` to solve the following problem:
Create a new config directory and deployment.
Here is the function:
def execute(args):
"""Create a new config directory and deployment."""
# Check this early on, as the deployment at the end would fail otherwise.
if common.is_git_dirty():
print('Your checkout contains uncommitted changes. Cannot proceed.')
sys.exit(1)
verifier = DomainVerifier(args.oauth_client_secrets_path)
gcloud = common.Gcloud(args.project_id)
enable_services(gcloud)
# Get tag for domain verification.
appspot_domain = 'https://' + args.project_id + '.appspot.com/'
domain_verification_tag = verifier.get_domain_verification_tag(appspot_domain)
blobs_bucket = project_bucket(args.project_id, 'blobs')
deployment_bucket = project_bucket(args.project_id, 'deployment')
bucket_replacements = (
('test-blobs-bucket', blobs_bucket),
('test-deployment-bucket', deployment_bucket),
('test-bigquery-bucket', project_bucket(args.project_id, 'bigquery')),
('test-backup-bucket', project_bucket(args.project_id, 'backup')),
('test-coverage-bucket', project_bucket(args.project_id, 'coverage')),
('test-fuzzer-logs-bucket', project_bucket(args.project_id,
'fuzzer-logs')),
('test-corpus-bucket', project_bucket(args.project_id, 'corpus')),
('test-quarantine-bucket', project_bucket(args.project_id, 'quarantine')),
('test-shared-corpus-bucket',
project_bucket(args.project_id, 'shared-corpus')),
('test-fuzz-logs-bucket', project_bucket(args.project_id, 'fuzz-logs')),
)
# Write new configs.
create_new_config(gcloud, args.project_id, args.new_config_dir,
domain_verification_tag, bucket_replacements,
args.appengine_location, args.gce_zone,
args.firebase_api_key)
prev_dir = os.getcwd()
os.chdir(args.new_config_dir)
# Deploy App Engine and finish verification of domain.
os.chdir(prev_dir)
deploy_appengine(
gcloud, args.new_config_dir, appengine_location=args.appengine_location)
verifier.verify(appspot_domain)
# App Engine service account requires:
# - Domain ownership to create domain namespaced GCS buckets
# - Datastore export permission for periodic backups.
# - Service account signing permission for GCS uploads.
service_account = app_engine_service_account(args.project_id)
verifier.add_owner(appspot_domain, service_account)
add_service_account_role(gcloud, args.project_id, service_account,
'roles/datastore.importExportAdmin')
add_service_account_role(gcloud, args.project_id, service_account,
'roles/iam.serviceAccountTokenCreator')
# Create buckets now that domain is verified.
create_buckets(args.project_id, [bucket for _, bucket in bucket_replacements])
# Set CORS settings on the buckets.
set_cors(args.new_config_dir, [blobs_bucket])
# Set deployment bucket for the cloud project.
gcloud.run('compute', 'project-info', 'add-metadata',
'--metadata=deployment-bucket=' + deployment_bucket)
# Deploy source zips.
deploy_zips(args.new_config_dir) | Create a new config directory and deployment. |
157,441 | from clusterfuzz._internal.datastore import data_types
from clusterfuzz._internal.datastore import ndb_utils
from clusterfuzz._internal.issue_management import oss_fuzz_github
The provided code snippet includes necessary dependencies for implementing the `execute` function. Write a Python function `def execute(args)` to solve the following problem:
Query Testcases of the given projects, and conditionally file them to the corresponding GitHub repo.
Here is the function:
def execute(args):
"""Query Testcases of the given projects,
and conditionally file them to the corresponding GitHub repo."""
if not args.script_args:
print('Need at least one project name (with -p) '
'when running the backfiler.')
return
for project_name in args.script_args:
print(f'Back filing project {project_name}')
for testcase in data_types.Testcase.query(
ndb_utils.is_true(data_types.Testcase.open),
ndb_utils.is_false(data_types.Testcase.one_time_crasher_flag),
data_types.Testcase.status == 'Processed',
data_types.Testcase.project_name == project_name,
):
if not testcase.bug_information:
print(f'Skip testcase without bugs: {testcase.key.id()}')
continue
print(f'Back filing testcase id: {testcase.key.id()}')
if args.non_dry_run:
oss_fuzz_github.file_issue(testcase)
testcase.put() | Query Testcases of the given projects, and conditionally file them to the corresponding GitHub repo. |
157,442 | from clusterfuzz._internal.datastore import data_types
from clusterfuzz._internal.issue_management import issue_tracker_utils
from clusterfuzz._internal.issue_management import oss_fuzz_github
def _get_testcase(bug_information):
"""Retrieve testcase based on its bug information."""
candidates = list(
data_types.Testcase.query(
data_types.Testcase.bug_information == bug_information))
if not candidates:
print('No candidate found when '
'querying bug information {bug_information}\n')
elif len(candidates) > 1:
print('Multiple candidates found when '
f'querying bug information {bug_information}:\n')
for testcase in candidates:
print(f' {testcase.key.id()}')
else:
return candidates[0]
return None
def _get_bug_information(issue):
"""Given a GitHub issue, parse its corresponding bug information."""
bug_information = issue.title[len(oss_fuzz_github.ISSUE_TITTLE_TEXT_PREFIX) +
1:]
if bug_information.isdigit():
return bug_information
return None
def _testcase_information_verified(testcase, issue):
"""Verify if a testcase correctly stores its GitHub issue information."""
if testcase.github_repo_id == issue.repository.id and \
testcase.github_issue_num == issue.number:
print(f'Testcase {testcase.bug_information} was properly stored.')
return True
if testcase.github_repo_id is None and testcase.github_issue_num is None:
print(f'Testcase {testcase.bug_information} was not stored.')
else:
print(f'Testcase {testcase.bug_information} stored '
f'is inconsistent with GitHub:\n'
f' Issue number (Storage) {testcase.github_issue_num} '
f'!= {issue.number} (GitHub)\n'
f' Repository ID (Storage) {testcase.github_repo_id} '
f'!= {issue.repository.id} (GitHub).')
return False
The provided code snippet includes necessary dependencies for implementing the `execute` function. Write a Python function `def execute(args)` to solve the following problem:
Backtrack GitHub issues filed in the past, update their information in gcloud, and close them when necessary.
Here is the function:
def execute(args):
"""Backtrack GitHub issues filed in the past,
update their information in gcloud, and close them when necessary."""
issue_tracker = issue_tracker_utils.get_issue_tracker('oss-fuzz')
for issue in oss_fuzz_github.get_my_issues():
print('========================================')
# Track testcase.
bug_information = _get_bug_information(issue)
if not bug_information:
print('Unable to extract bug information: '
f'Repo {issue.repository.id} Issue {issue.number}.\n'
f'Issue title: {issue.title}.\n'
f'Issue url: {issue.url}.')
continue
testcase = _get_testcase(bug_information)
# Update testcase.
if not _testcase_information_verified(testcase, issue):
print(
f'Updating testcase (bug information: {testcase.bug_information}):\n'
f' Issue number {issue.number}\n'
f' Repository ID {issue.repository.id}\n')
if args.non_dry_run:
oss_fuzz_github.update_testcase_properties(testcase, issue.repository,
issue)
testcase.put()
# Backclose issues.
if issue.state == 'closed':
continue
monorail_issue = issue_tracker.get_original_issue(bug_information)
if monorail_issue.is_open:
continue
print(f'Closing testcase (bug information: {testcase.bug_information}):\n'
f' Issue number {issue.number}\n'
f' Repository ID {issue.repository.id}\n')
if args.non_dry_run:
oss_fuzz_github.close_issue(testcase) | Backtrack GitHub issues filed in the past, update their information in gcloud, and close them when necessary. |
157,443 | from google.api_core import exceptions
from google.cloud import monitoring_v3
from clusterfuzz._internal.base import utils
from clusterfuzz._internal.datastore import data_types
from clusterfuzz._internal.metrics import monitor
from clusterfuzz._internal.metrics import monitoring_metrics
def setup_config(non_dry_run):
"""Set up configuration."""
config = data_types.Config.query().get()
if not config:
config = data_types.Config()
if non_dry_run:
print('Creating config')
config.put()
else:
print('Skip creating config (dry-run mode)')
def setup_fuzzers(non_dry_run):
"""Set up fuzzers."""
for fuzzer_defaults in [
AflDefaults(),
LibFuzzerDefaults(),
HonggfuzzDefaults(),
GoogleFuzzTestDefaults(),
SyzkallerDefaults(),
CentipedeDefaults(),
]:
fuzzer = data_types.Fuzzer.query(
data_types.Fuzzer.name == fuzzer_defaults.name).get()
if fuzzer:
print(fuzzer_defaults.name, 'fuzzer already exists')
if non_dry_run:
print('Updating stats metrics.')
fuzzer.stats_columns = fuzzer_defaults.stats_columns
fuzzer.stats_column_descriptions = (
fuzzer_defaults.stats_column_descriptions)
fuzzer.put()
continue
if non_dry_run:
print('Creating fuzzer', fuzzer_defaults.name)
fuzzer_defaults.create_fuzzer().put()
else:
print('Skip creating fuzzer', fuzzer_defaults.name, '(dry-run mode)')
def setup_templates(non_dry_run):
"""Set up templates."""
for name, template in TEMPLATES.items():
job = data_types.JobTemplate.query(
data_types.JobTemplate.name == name).get()
if job:
print('Template with name', name, 'already exists.')
continue
if non_dry_run:
print('Creating template', name)
data_types.JobTemplate(name=name, environment_string=template).put()
else:
print('Skip creating template', name, '(dry-run mode)')
def setup_metrics(non_dry_run):
"""Set up metrics."""
client = monitoring_v3.MetricServiceClient()
project_name = utils.get_application_id()
project_path = client.project_path(project_name)
for name in dir(monitoring_metrics):
metric = getattr(monitoring_metrics, name)
if not isinstance(metric, monitor.Metric):
continue
descriptor = monitoring_v3.types.MetricDescriptor() # pylint: disable=no-member
metric.monitoring_v3_metric_descriptor(descriptor)
if non_dry_run:
print('Creating metric', descriptor)
try:
client.create_metric_descriptor(project_path, descriptor)
except exceptions.AlreadyExists:
client.delete_metric_descriptor(name=project_path +
'/metricDescriptors/' + descriptor.type)
client.create_metric_descriptor(project_path, descriptor)
else:
print('Skip creating metric', descriptor, '(dry-run mode)')
The provided code snippet includes necessary dependencies for implementing the `execute` function. Write a Python function `def execute(args)` to solve the following problem:
Set up initial Datastore models.
Here is the function:
def execute(args):
"""Set up initial Datastore models."""
setup_config(args.non_dry_run)
setup_fuzzers(args.non_dry_run)
setup_templates(args.non_dry_run)
if not args.local:
setup_metrics(args.non_dry_run)
print('Done') | Set up initial Datastore models. |
157,444 | import datetime
import sys
from clusterfuzz._internal.base import utils
from clusterfuzz._internal.datastore import data_types
from clusterfuzz._internal.datastore import ndb_utils
from local.butler.scripts import attribute_builder
from local.butler.scripts import batcher
BATCH_SIZE = 500
def to_dict(entity):
"""Convert a db.Model instance to a dict."""
entity_dict = entity.to_dict()
entity_dict['id'] = entity.key.id()
for k, v in entity_dict.items():
if isinstance(v, datetime.datetime):
entity_dict[k] = utils.utc_datetime_to_timestamp(v)
return entity_dict
def get_diff(before, after):
"""Return differences in string between the two dicts, before and after."""
diffs = []
for k, v in before.items():
if k in after:
if v != after[k]:
diffs.append((k, (v, after[k])))
else:
diffs.append((k, (v, '<MISSING>')))
for k, v in after.items():
if k not in before:
diffs.append((k, ('<MISSING>', v)))
diffs.sort()
s = ''
for (key, (before_value, after_value)) in diffs:
s += '%s:\n' % key
s += '-%s\n' % before_value
s += '+%s\n\n' % after_value
return s
The provided code snippet includes necessary dependencies for implementing the `execute` function. Write a Python function `def execute(args)` to solve the following problem:
Build keywords.
Here is the function:
def execute(args):
"""Build keywords."""
count_diff = 0
query = data_types.Testcase.query().order(-data_types.Testcase.timestamp)
for testcases in batcher.iterate(query, BATCH_SIZE):
for testcase in testcases:
before_testcase = to_dict(testcase)
attribute_builder.populate(testcase)
after_testcase = to_dict(testcase)
diff = get_diff(before_testcase, after_testcase)
if (count_diff % 10) == 0 and diff:
print('Migrate (dry=%s) id:%s\n%s' % (not args.non_dry_run,
testcase.key.id(), diff))
if diff:
count_diff += 1
if args.non_dry_run:
try:
ndb_utils.put_multi(testcases)
except Exception:
for testcase in testcases:
try:
testcase.put()
except Exception:
print('Error: %s %s' % (testcase.key.id(), sys.exc_info()))
print('Done (count_diff=%d)' % count_diff) | Build keywords. |
157,445 | from google.cloud import ndb
from clusterfuzz._internal.datastore import data_types
The provided code snippet includes necessary dependencies for implementing the `execute` function. Write a Python function `def execute(args)` to solve the following problem:
Build keywords for jobs.
Here is the function:
def execute(args):
"""Build keywords for jobs."""
jobs = list(data_types.Job.query())
if args.non_dry_run:
ndb.put_multi(jobs)
print("Done building keywords for jobs.") | Build keywords for jobs. |
157,446 | import csv
import os
from google.cloud import ndb
from clusterfuzz._internal.datastore import data_types
DEFAULT_BATCH_SIZE = 100
def put_multi(testcases):
"""Attempts to batch put the specified slice of testcases.
If there is a 'payload size exceeds the limit' error then it will halve the
testcases and try again. If that does not work then will go into a debugger.
"""
try:
ndb.put_multi(testcases)
except Exception as e:
if PAYLOAD_SIZE_ERROR in str(e) and len(testcases) > 1:
half_batch_size = len(testcases) // 2
print('Reached payload size limit. Retrying batch put with half the '
f'specified batch size: {half_batch_size}')
try:
ndb.put_multi(testcases[:half_batch_size])
ndb.put_multi(testcases[half_batch_size:])
except Exception as ie:
if PAYLOAD_SIZE_ERROR in str(ie):
print(f'Got exception: {e}')
print('Opening debugger to investigate further:')
# pylint: disable=forgotten-debug-statement
import pdb
pdb.set_trace()
else:
raise
def get_monorail_issuetracker_issue_id_dictionary(file_loc, roll_back):
"""Creates a mapping of monorail/issuetracker issue ids."""
issue_id_dictionary = {}
# csv should be structured with no headers and contain two columns:
# a monorail issue id, and a issuetracker issue id
# (ex. row: "600469, 40003765")
with open(file_loc, 'r') as csvfile:
reader = csv.reader(csvfile)
for monorail_id, issuetracker_id in reader:
if roll_back:
issue_id_dictionary[issuetracker_id] = monorail_id
else:
issue_id_dictionary[monorail_id] = issuetracker_id
return issue_id_dictionary
The provided code snippet includes necessary dependencies for implementing the `execute` function. Write a Python function `def execute(args)` to solve the following problem:
Query Testcases of a project, and update the bug_information and/or group_bug_information fields to reflect the Issue Tracker issue id rather than the Monorail issue id.
Here is the function:
def execute(args):
"""Query Testcases of a project, and update the bug_information
and/or group_bug_information fields to reflect the Issue Tracker issue
id rather than the Monorail issue id."""
# Read the required enviroment variables.
file_loc = os.environ.get('FILE_LOC')
if not file_loc:
raise ValueError('Must specify FILE_LOC env variable')
project_name = os.environ.get('PROJECT_NAME')
if not project_name:
raise ValueError('Must specify PROJECT_NAME env variable')
batch_size = int(os.environ.get('BATCH_SIZE', DEFAULT_BATCH_SIZE))
roll_back = os.environ.get('ROLL_BACK') == 'True'
issue_id_dict = get_monorail_issuetracker_issue_id_dictionary(
file_loc, roll_back)
print(f'Size of issue_id_dict: {len(issue_id_dict)}')
testcases = []
count_of_updated = 0
for testcase in data_types.Testcase.query(
# only target testcases in single project
data_types.Testcase.project_name == project_name,):
testcase_updated = False
if testcase.bug_information and issue_id_dict.get(testcase.bug_information):
testcase.bug_information = issue_id_dict[testcase.bug_information]
testcase_updated = True
if testcase.group_bug_information and issue_id_dict.get(
str(testcase.group_bug_information)):
# group_bug_information is an int unlike bug_information which is a str.
testcase.group_bug_information = int(issue_id_dict[str(
testcase.group_bug_information)])
testcase_updated = True
if testcase_updated:
print(f'We will update testcase id: {testcase.key.id()}')
testcases.append(testcase)
if args.non_dry_run and len(testcases) >= batch_size:
put_multi(testcases)
count_of_updated += len(testcases)
print(f'Updated {len(testcases)}. Total {count_of_updated}')
testcases = []
if args.non_dry_run and len(testcases) > 0:
put_multi(testcases)
count_of_updated += len(testcases)
print(f'Updated {len(testcases)}. Total {count_of_updated}') | Query Testcases of a project, and update the bug_information and/or group_bug_information fields to reflect the Issue Tracker issue id rather than the Monorail issue id. |
157,447 | import os
import sys
import yaml
from local.butler import common
from local.butler import format as formatter
def _error(message=None):
"""Print error and track state via a global."""
if message:
print(message)
global _error_occurred
_error_occurred = True
The provided code snippet includes necessary dependencies for implementing the `py_import_order` function. Write a Python function `def py_import_order(file_path)` to solve the following problem:
Validate that python imports are alphabetized.
Here is the function:
def py_import_order(file_path):
"""Validate that python imports are alphabetized."""
def _validate_block(import_block):
"""Ensure that a single block is ordered properly."""
if not import_block:
return []
sorted_import_block = sorted(import_block, key=lambda i: i.lower())
if sorted_import_block == import_block:
return []
return ['\n'.join(sorted_import_block)]
with open(file_path) as f:
file_content = f.read()
imports = []
corrected_import_blocks = []
for line in file_content.splitlines():
if line.startswith('import ') or line.startswith('from '):
imports.append(line)
else:
corrected_import_blocks += _validate_block(imports)
imports = []
# Though rare, if a file ends with an import we must still validate them.
corrected_import_blocks += _validate_block(imports)
if not corrected_import_blocks:
return
suggestions = '\n\n--------\n\n'.join(corrected_import_blocks)
_error(('Failed: File {filename} has non-alphabetized import blocks. '
'Suggested order:\n\n{suggestions}').format(
filename=file_path, suggestions=suggestions)) | Validate that python imports are alphabetized. |
157,448 | import os
import re
from fabric import api
The provided code snippet includes necessary dependencies for implementing the `get_host_user_and_ssh_key_path` function. Write a Python function `def get_host_user_and_ssh_key_path(instance_name, project, zone)` to solve the following problem:
Return a tuple of (hostname, username and ssh_key_path).
Here is the function:
def get_host_user_and_ssh_key_path(instance_name, project, zone):
"""Return a tuple of (hostname, username and ssh_key_path)."""
output = api.local(
f'gcloud compute ssh --project "{project}" --zone "{zone}" '
f'{instance_name} --dry-run',
capture=True)
print(output)
m = re.match('/usr/bin/ssh .*-i ([^ ]+)(?: -o [^ ]+)* ([^ ]+)@([^ ]+)',
output)
return (m.group(3), m.group(2), m.group(1)) | Return a tuple of (hostname, username and ssh_key_path). |
157,449 | import os
import re
from fabric import api
def get_file_content(file_path):
"""Return content of a file."""
return open(file_path).read().strip()
The provided code snippet includes necessary dependencies for implementing the `get_password` function. Write a Python function `def get_password()` to solve the following problem:
Return password from |PASSWORD_FILE_PATH| environment variable.
Here is the function:
def get_password():
"""Return password from |PASSWORD_FILE_PATH| environment variable."""
password_file_path = os.getenv('PASSWORD_FILE_PATH')
if not password_file_path:
raise RuntimeError('Please set PASSWORD_FILE_PATH in environment.')
return get_file_content(password_file_path) | Return password from |PASSWORD_FILE_PATH| environment variable. |
157,450 | import multiprocessing
import os
import sys
The provided code snippet includes necessary dependencies for implementing the `get_file_modified_times` function. Write a Python function `def get_file_modified_times(directory)` to solve the following problem:
Return a list of last modified times for the files in a directory.
Here is the function:
def get_file_modified_times(directory):
"""Return a list of last modified times for the files in a directory."""
modified_times = []
for root, _, filenames in os.walk(directory):
for filename in filenames:
modified_times.append(os.path.getmtime(os.path.join(root, filename)))
return modified_times | Return a list of last modified times for the files in a directory. |
157,451 | import multiprocessing
import os
import sys
The provided code snippet includes necessary dependencies for implementing the `build_file` function. Write a Python function `def build_file(filename)` to solve the following problem:
Build a single file using polymer-bundler.
Here is the function:
def build_file(filename):
"""Build a single file using polymer-bundler."""
input_filename = os.path.join('private', 'templates', filename)
output_filename = os.path.join('templates', filename)
os.system('polymer-bundler --inline-scripts --inline-css --strip-comments '
'--out-file={output_filename} {input_filename}'.format(
output_filename=output_filename, input_filename=input_filename))
if os.path.exists(output_filename) and os.path.getsize(output_filename):
return True
print('Failed to build template: ' + output_filename)
return False | Build a single file using polymer-bundler. |
157,452 | import os
import shutil
import socket
import subprocess
import sys
import threading
import time
MNT_DIR = '/mnt/scratch0'
BOT_BASEDIR = os.path.join(MNT_DIR, 'bots')
The provided code snippet includes necessary dependencies for implementing the `setup_environment` function. Write a Python function `def setup_environment()` to solve the following problem:
Set up host environment.
Here is the function:
def setup_environment():
"""Set up host environment."""
os.environ['QUEUE_OVERRIDE'] = 'LINUX_UNTRUSTED'
os.environ['WORKER_ROOT_DIR'] = os.path.join(MNT_DIR, 'clusterfuzz')
os.environ['WORKER_BOT_TMPDIR'] = os.path.join(MNT_DIR, 'tmp')
if not os.path.exists(BOT_BASEDIR):
os.mkdir(BOT_BASEDIR) | Set up host environment. |
157,453 | import os
import shutil
import socket
import subprocess
import sys
import threading
import time
SRC_DIR = os.path.join(MNT_DIR, 'clusterfuzz')
BOT_BASEDIR = os.path.join(MNT_DIR, 'bots')
The provided code snippet includes necessary dependencies for implementing the `start_bot_instance` function. Write a Python function `def start_bot_instance(instance_num)` to solve the following problem:
Set up bot directory.
Here is the function:
def start_bot_instance(instance_num):
"""Set up bot directory."""
env = os.environ.copy()
host_name = os.getenv('HOSTNAME', socket.gethostname())
bot_name = '%s-%d' % (host_name, instance_num)
env['BOT_NAME'] = bot_name
env['HOST_INSTANCE_NAME'] = host_name
env['HOST_INSTANCE_NUM'] = str(instance_num)
bot_directory = os.path.join(BOT_BASEDIR, bot_name)
bot_root_directory = os.path.join(bot_directory, 'clusterfuzz')
tmp_directory = os.path.join(bot_directory, 'tmp')
if not os.path.exists(bot_directory):
os.mkdir(bot_directory)
os.mkdir(tmp_directory)
env['ROOT_DIR'] = bot_root_directory
env['BOT_TMPDIR'] = tmp_directory
env['PYTHONPATH'] = os.path.join(bot_root_directory, 'src')
if os.path.exists(bot_root_directory):
shutil.rmtree(bot_root_directory)
shutil.copytree(SRC_DIR, bot_root_directory)
while True:
bot_proc = subprocess.Popen(
sys.executable + ' src/python/bot/startup/run.py 2>&1 > console.txt',
shell=True,
env=env,
cwd=bot_root_directory)
bot_proc.wait()
print('Instance %i exited.' % instance_num, file=sys.stderr) | Set up bot directory. |
157,454 | import argparse
import importlib
import os
import sys
from local.butler import guard
The provided code snippet includes necessary dependencies for implementing the `_setup_args_for_remote` function. Write a Python function `def _setup_args_for_remote(parser)` to solve the following problem:
Setup sub-parsers for the remote command.
Here is the function:
def _setup_args_for_remote(parser):
"""Setup sub-parsers for the remote command."""
parser.add_argument(
'-i',
'--instance-name',
required=True,
help='The instance name (e.g. clusterfuzz-linux-0005).')
parser.add_argument('--project', help='The Project ID.')
parser.add_argument('--zone', help='The Project Zone.')
subparsers = parser.add_subparsers(dest='remote')
parser_tail = subparsers.add_parser(
'tail', help='Print the last `size` lines of log_name.')
parser_tail.add_argument('log_name', help='The log file name (without .log).')
parser_tail.add_argument(
'line_count', type=int, help='The number of lines to be showed.')
parser_tailf = subparsers.add_parser(
'tailf',
help=('Print the last lines of logs and wait for more. '
'This is equivalent to tail -f.'))
parser_tailf.add_argument(
'log_names', nargs='+', help='The log file names (without .log).')
stage = subparsers.add_parser(
'stage',
help=('Stage a zip file by'
' (1) Build a zip with `butler.py package`'
' (2) Send the zip to the instance,'
' (3) Unzip it to the clusterfuzz path, and'
' (4) Restart run_bot.py.'))
stage.add_argument(
'-c', '--config-dir', required=True, help='Path to application config.')
parser_rdp = subparsers.add_parser(
'rdp',
help=('Launch Remmina with correct configuration (e.g. IP address for the'
' instance).'))
parser_rdp.add_argument(
'--share-path',
help=('The share path that is mounted on the remote instance.'
'It is convenient for sending files to the remote instance.'))
subparsers.add_parser('restart', help='Restart a bot by killing run_bot.py.')
subparsers.add_parser('reboot', help='Reboot with `sudo reboot`.') | Setup sub-parsers for the remote command. |
157,455 | import argparse
import importlib
import os
import sys
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
from local.butler import guard
import os
if not os.getenv('ROOT_DIR') and not os.getenv('GAE_ENV'):
# If ROOT_DIR isn't set by the time we import this and we're not on GAE,
# assume we're libClusterFuzz.
# Actual value does not matter, it just needs to be set.
os.environ['ROOT_DIR'] = '/tmp'
os.environ['LIB_CF'] = 'True'
this_dir = os.path.dirname(os.path.abspath(__file__))
os.environ['CONFIG_DIR_OVERRIDE'] = os.path.join(this_dir, 'lib-config')
# Other necessary env vars.
os.environ['FAIL_RETRIES'] = '1'
os.environ['FAIL_WAIT'] = '10'
The provided code snippet includes necessary dependencies for implementing the `_setup` function. Write a Python function `def _setup()` to solve the following problem:
Set up configs and import paths.
Here is the function:
def _setup():
"""Set up configs and import paths."""
os.environ['ROOT_DIR'] = os.path.abspath('.')
os.environ['PYTHONIOENCODING'] = 'UTF-8'
sys.path.insert(0, os.path.abspath(os.path.join('src')))
from clusterfuzz._internal.base import modules
modules.fix_module_search_paths() | Set up configs and import paths. |
157,456 | import torch
import torch.nn.functional as F
from einops import rearrange, repeat
from torch import einsum, nn
from flamingo_pytorch.flamingo_pytorch import GatedCrossAttentionBlock, PerceiverResampler
def exists(val):
return val is not None | null |
157,457 | import torch
import torch.nn.functional as F
from einops import rearrange, repeat
from torch import einsum, nn
from flamingo_pytorch.flamingo_pytorch import GatedCrossAttentionBlock, PerceiverResampler
def set_module_requires_grad_(module, requires_grad):
for param in module.parameters():
param.requires_grad = requires_grad
def unfreeze_all_layers_(module):
set_module_requires_grad_(module, True) | null |
157,458 | import torch
import torch.nn.functional as F
from einops import rearrange, repeat
from torch import einsum, nn
from flamingo_pytorch.flamingo_pytorch import GatedCrossAttentionBlock, PerceiverResampler
def freeze_all_layers_(module):
set_module_requires_grad_(module, False)
def freeze_model_and_make_eval_(model):
model.eval()
freeze_all_layers_(model) | null |
157,459 | import torch
import torch.nn.functional as F
from einops import rearrange, repeat
from torch import einsum, nn
from flamingo_pytorch.flamingo_pytorch import GatedCrossAttentionBlock, PerceiverResampler
def rotate_half(x):
x = rearrange(x, "... (j d) -> ... j d", j=2)
x1, x2 = x.unbind(dim=-2)
return torch.cat((-x2, x1), dim=-1)
def apply_rotary_pos_emb(pos, t):
return (t * pos.cos()) + (rotate_half(t) * pos.sin()) | null |
157,460 | import torch
from torch import nn, einsum
import torch.nn.functional as F
from einops import rearrange, repeat
from einops_exts import rearrange_many, repeat_many
def exists(val):
return val is not None | null |
157,461 | import torch
from torch import nn, einsum
import torch.nn.functional as F
from einops import rearrange, repeat
from einops_exts import rearrange_many, repeat_many
def FeedForward(dim, mult = 4):
inner_dim = int(dim * mult)
return nn.Sequential(
nn.LayerNorm(dim),
nn.Linear(dim, inner_dim, bias = False),
nn.GELU(),
nn.Linear(inner_dim, dim, bias = False)
) | null |
157,462 | import os
import subprocess
import sys
from tqdm import tqdm
import urllib.request
def download(url, path):
request = urllib.request.urlopen(url)
total = int(request.headers.get('Content-Length', 0))
with tqdm(total=total, desc='Downloading', unit='B', unit_scale=True, unit_divisor=1024) as progress:
urllib.request.urlretrieve(url, path, reporthook=lambda count, block_size, total_size: progress.update(block_size)) | null |
157,463 | from fastapi import FastAPI, Body
from modules.api.models import *
from modules import scripts, shared
from modules.api import api
from modules import paths_internal
import gradio as gr
from PIL import Image
from scripts.faceswap import get_models
from scripts.swapper import UpscaleOptions, swap_face, ImageResult
def get_face_restorer(str):
for restorer in shared.face_restorers:
if restorer.name() == str:
return restorer
return None
def get_full_model(model_name):
models = get_models()
for model in models:
if model.split("/")[-1] == model_name:
return model
return None
def get_models():
models_path = os.path.join(scripts.basedir(), "models" + os.path.sep + "roop" + os.path.sep + "*")
models = glob.glob(models_path)
models = [x for x in models if x.endswith(".onnx") or x.endswith(".pth")]
return models
class UpscaleOptions:
scale: int = 1
upscaler: UpscalerData = None
upscale_visibility: float = 0.5
face_restorer: FaceRestoration = None
restorer_visibility: float = 0.5
def swap_face(
source_img: Image.Image,
target_img: Image.Image,
model: Union[str, None] = None,
faces_index: Set[int] = {0},
upscale_options: Union[UpscaleOptions, None] = None,
) -> ImageResult:
result_image = target_img
converted = convert_to_sd(target_img)
scale, fn = converted[0], converted[1]
if model is not None and not scale:
if isinstance(source_img, str): # source_img is a base64 string
import base64, io
if 'base64,' in source_img: # check if the base64 string has a data URL scheme
base64_data = source_img.split('base64,')[-1]
img_bytes = base64.b64decode(base64_data)
else:
# if no data URL scheme, just decode
img_bytes = base64.b64decode(source_img)
source_img = Image.open(io.BytesIO(img_bytes))
source_img = cv2.cvtColor(np.array(source_img), cv2.COLOR_RGB2BGR)
target_img = cv2.cvtColor(np.array(target_img), cv2.COLOR_RGB2BGR)
source_face = get_face_single(source_img, face_index=0)
if source_face is not None:
result = target_img
model_path = os.path.join(os.path.abspath(os.path.dirname(__file__)), model)
face_swapper = getFaceSwapModel(model_path)
for face_num in faces_index:
target_face = get_face_single(target_img, face_index=face_num)
if target_face is not None:
result = face_swapper.get(result, target_face, source_face)
else:
logger.info(f"No target face found for {face_num}")
result_image = Image.fromarray(cv2.cvtColor(result, cv2.COLOR_BGR2RGB))
if upscale_options is not None:
result_image = upscale_image(result_image, upscale_options)
else:
logger.info("No source face found")
result_image.save(fn.name)
return ImageResult(path=fn.name)
def roop_api(_: gr.Blocks, app: FastAPI):
@app.post("/roop/image")
async def roop_image(
source_image: str = Body("",title="source face image"),
target_image: str = Body("",title="target image"),
face_index: list[int] = Body([0],title="face index"),
scale: int = Body(1,title="scale"),
upscale_visibility: float = Body(1,title="upscale visibility"),
face_restorer: str = Body("None",title="face restorer"),
restorer_visibility: float = Body(1,title="face restorer"),
model: str = Body("inswapper_128.onnx",title="model"),
):
s_image = api.decode_base64_to_image(source_image)
t_image = api.decode_base64_to_image(target_image)
f_index = set(face_index)
up_options = UpscaleOptions(scale=scale, upscale_visibility=upscale_visibility,face_restorer=get_face_restorer(face_restorer),restorer_visibility=restorer_visibility)
use_model = get_full_model(model)
if use_model is None:
Exception("Model not found")
result = swap_face(s_image, t_image, use_model, f_index, up_options)
return {"image": api.encode_pil_to_base64(result.image())}
@app.get("/roop/models")
async def roop_models():
models = []
for model in get_models():
models.append(model.split("/")[-1])
return {"models": models} | null |
157,464 | from selenium.webdriver.support import expected_conditions as EC
from selenium.common import exceptions as SeleniumExceptions
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.common.by import By
import time
def __google_login(self) -> None:
'''
Login to ChatGPT using Google
'''
self.logger.debug('Clicking Google button...')
self.driver.find_element(*google_oauth_btn).click()
google_email_entry = (By.XPATH, f'//div[@data-identifier="{self._ChatGPT__email}"]')
try:
self.logger.debug('Checking if Google remembers emai...')
WebDriverWait(self.driver, 3).until(
EC.element_to_be_clickable(google_email_entry)
).click()
self.logger.debug('Google remembers email')
except SeleniumExceptions.TimeoutException:
self.logger.debug('Google does not remember email')
self.logger.debug('Entering email...')
WebDriverWait(self.driver, 5).until(
EC.element_to_be_clickable(google_email_input)
).send_keys(self._ChatGPT__email)
self.logger.debug('Clicking Next...')
self.driver.find_element(*google_next_btn).click()
self.logger.debug('Entering password...')
WebDriverWait(self.driver, 5).until(
EC.element_to_be_clickable(google_pwd_input)
).send_keys(self._ChatGPT__password)
self.logger.debug('Clicking Next...')
self.driver.find_element(*google_pwd_next_btn).click()
try:
self.logger.debug('Checking if verification code is required...')
WebDriverWait(self.driver, 5).until(
EC.presence_of_element_located(google_code_samp)
)
self.logger.debug('Code is required')
prev_code = self.driver.find_elements(By.TAG_NAME, 'samp')[0].text
print('Verification code:', prev_code)
while True:
code = self.driver.find_elements(*google_code_samp)
if not code:
break
if code[0].text != prev_code:
print('Verification code:', code[0].text)
prev_code = code[0].text
time.sleep(1)
except SeleniumExceptions.TimeoutException:
self.logger.debug('Code is not required')
def __microsoft_login(self) -> None:
self.logger.debug('Clicking Microsoft button...')
self.driver.find_element(*microsoft_oauth_btn).click()
self.logger.debug('Entering email...')
WebDriverWait(self.driver, 5).until(
EC.element_to_be_clickable(microsoft_email_input)
).send_keys(self._ChatGPT__email)
self.logger.debug('Clicking Next...')
self.driver.find_element(*microsoft_next_btn).click()
self.logger.debug('Entering password...')
WebDriverWait(self.driver, 5).until(
EC.element_to_be_clickable(microsoft_pwd_input)
).send_keys(self._ChatGPT__password)
self.logger.debug('Clicking Next...')
self.driver.find_element(*microsoft_next_btn).click()
self.logger.debug('Clicking allow...')
WebDriverWait(self.driver, 5).until(
EC.element_to_be_clickable(microsoft_next_btn)
).click()
def __openai_login(self, retry: int = 3) -> None:
'''
Login to ChatGPT using OpenAI
:param retry: Number of times to retry solving the recaptcha
'''
self.logger.debug('Entering email...')
self.driver.find_element(*openai_email_input).send_keys(self._ChatGPT__email)
self.driver.find_element(*openai_continue_btn).click()
have_recaptcha = False
try:
WebDriverWait(self.driver, 3).until(
EC.presence_of_element_located(
(By.CSS_SELECTOR, 'iframe[title="reCAPTCHA"]')
)
)
have_recaptcha = True
self.logger.debug('Captcha detected')
except SeleniumExceptions.TimeoutException:
self.logger.debug('No captcha detected')
try:
WebDriverWait(self.driver, 3).until(
EC.text_to_be_present_in_element_attribute(
openai_captcha_input, 'value', '_'
)
)
except SeleniumExceptions.TimeoutException:
if self._ChatGPT__captcha_solver == 'pypasser':
__pypasser_solve(self, retry)
elif self._ChatGPT__captcha_solver == '2captcha':
__twocaptcha_solve(self, retry)
if have_recaptcha:
if __have_recaptcha_value(self):
self.logger.debug('Congrat! reCAPTCHA is solved')
else:
self.logger.debug('Oops! you need to solve reCAPTCHA manually')
self.driver.get(self.driver.current_url)
while not __have_recaptcha_value(self):
time.sleep(1)
self.logger.debug('Clicking Continue...')
self.driver.find_element(*openai_continue_btn).click()
self.logger.debug('Entering password...')
self.driver.find_element(*openai_pwd_input).send_keys(self._ChatGPT__password)
self.driver.find_element(*openai_continue_btn).click()
The provided code snippet includes necessary dependencies for implementing the `login` function. Write a Python function `def login(self) -> None` to solve the following problem:
Login to ChatGPT
Here is the function:
def login(self) -> None:
'''
Login to ChatGPT
'''
if self._ChatGPT__auth_type == 'google':
__google_login(self)
elif self._ChatGPT__auth_type == 'microsoft':
__microsoft_login(self)
elif self._ChatGPT__auth_type == 'openai':
__openai_login(self) | Login to ChatGPT |
157,465 | from pyChatGPT import ChatGPT
import os
def clear_screen():
os.system('cls' if os.name == 'nt' else 'clear') | null |
157,466 | from min_dalle import MinDalle
import sys
import PIL
import PIL.Image
import PIL.ImageTk
import tkinter
from tkinter import ttk
root.mainloop()
root.mainloop()
def regen_root():
global root
global blank_image
global padding_image
root = tkinter.Tk()
root.wm_resizable(False, False)
blank_image = PIL.ImageTk.PhotoImage(PIL.Image.new(size=(256 * 2, 256 * 2), mode="RGB"))
padding_image = PIL.ImageTk.PhotoImage(PIL.Image.new(size=(16, 16), mode="RGBA")) | null |
157,467 | from min_dalle import MinDalle
import sys
import PIL
import PIL.Image
import PIL.ImageTk
import tkinter
from tkinter import ttk
is_mega = None
root.mainloop()
if is_mega is None:
print("no option selected")
sys.exit(0)
root.mainloop()
def set_mega_true_and_destroy():
global is_mega
is_mega = True
root.destroy() | null |
157,468 | from min_dalle import MinDalle
import sys
import PIL
import PIL.Image
import PIL.ImageTk
import tkinter
from tkinter import ttk
is_mega = None
root.mainloop()
if is_mega is None:
print("no option selected")
sys.exit(0)
root.mainloop()
def set_mega_false_and_destroy():
global is_mega
is_mega = False
root.destroy() | null |
157,469 | from min_dalle import MinDalle
import sys
import PIL
import PIL.Image
import PIL.ImageTk
import tkinter
from tkinter import ttk
model = MinDalle(
models_root="./pretrained",
is_mega=is_mega,
is_reusable=True,
is_verbose=True
)
label_image_content = blank_image
sv_prompt = tkinter.StringVar(value="artificial intelligence")
sv_temperature = tkinter.StringVar(value="1")
sv_topk = tkinter.StringVar(value="128")
sv_supercond = tkinter.StringVar(value="16")
bv_seamless = tkinter.BooleanVar(value=False)
label_image = ttk.Label(frm, image=blank_image)
label_image.grid(column=0, row=0)
def generate():
# check fields
try:
temperature = float(sv_temperature.get())
except:
sv_temperature.set("ERROR")
return
try:
topk = int(sv_topk.get())
except:
sv_topk.set("ERROR")
return
try:
supercond = int(sv_supercond.get())
except:
sv_supercond.set("ERROR")
return
try:
is_seamless = bool(bv_seamless.get())
except:
return
# and continue
global label_image_content
image_stream = model.generate_image_stream(
sv_prompt.get(),
grid_size=2,
seed=-1,
progressive_outputs=True,
is_seamless=is_seamless,
temperature=temperature,
top_k=topk,
supercondition_factor=supercond,
is_verbose=True
)
for image in image_stream:
global final_image
final_image = image
label_image_content = PIL.ImageTk.PhotoImage(image)
label_image.configure(image=label_image_content)
label_image.update() | null |
157,470 | from min_dalle import MinDalle
import sys
import PIL
import PIL.Image
import PIL.ImageTk
import tkinter
from tkinter import ttk
def save():
final_image.save('generated/out.png') | null |
157,471 | from min_dalle import MinDalle
import tempfile
import string
import torch, torch.backends.cudnn, torch.backends.cuda
from typing import Iterator
from emoji import demojize
from cog import BasePredictor, Path, Input
def filename_from_text(text: str) -> str:
text = demojize(text, delimiters=['', ''])
text = text.lower().encode("ascii", errors="ignore").decode()
allowed_chars = string.ascii_lowercase + ' '
text = ''.join(i for i in text.lower() if i in allowed_chars)
text = text[:64]
text = '-'.join(text.strip().split())
if len(text) == 0: text = 'blank'
return text | null |
157,472 | import argparse
import os
from PIL import Image
from min_dalle import MinDalle
import torch
def ascii_from_image(image: Image.Image, size: int = 128) -> str:
gray_pixels = image.resize((size, int(0.55 * size))).convert('L').getdata()
chars = list('.,;/IOX')
chars = [chars[i * len(chars) // 256] for i in gray_pixels]
chars = [chars[i * size: (i + 1) * size] for i in range(size // 2)]
return '\n'.join(''.join(row) for row in chars)
def save_image(image: Image.Image, path: str):
if os.path.isdir(path):
path = os.path.join(path, 'generated.png')
elif not path.endswith('.png'):
path += '.png'
print("saving image to", path)
image.save(path)
return image
def generate_image(
is_mega: bool,
text: str,
seed: int,
grid_size: int,
top_k: int,
image_path: str,
models_root: str,
fp16: bool,
):
model = MinDalle(
is_mega=is_mega,
models_root=models_root,
is_reusable=False,
is_verbose=True,
dtype=torch.float16 if fp16 else torch.float32
)
image = model.generate_image(
text,
seed,
grid_size,
top_k=top_k,
is_verbose=True
)
save_image(image, image_path)
print(ascii_from_image(image, size=128)) | null |
157,473 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.pseudolabel.pseudolabel import PseudoLabel
from datasets.ssl_dataset import SSL_Dataset
from datasets.data_utils import get_data_loader
def net_builder(net_name, from_name: bool, net_conf=None, is_remix=False):
"""
return **class** of backbone network (not instance).
Args
net_name: 'WideResNet' or network names in torchvision.models
from_name: If True, net_buidler takes models in torch.vision models. Then, net_conf is ignored.
net_conf: When from_name is False, net_conf is the configuration of backbone network (now, only WRN is supported).
"""
if from_name:
import torchvision.models as models
model_name_list = sorted(name for name in models.__dict__
if name.islower() and not name.startswith("__")
and callable(models.__dict__[name]))
if net_name not in model_name_list:
assert Exception(f"[!] Networks\' Name is wrong, check net config, \
expected: {model_name_list} \
received: {net_name}")
else:
return models.__dict__[net_name]
else:
if net_name == 'WideResNet':
import models.nets.wrn as net
builder = getattr(net, 'build_WideResNet')()
elif net_name == 'WideResNetVar':
import models.nets.wrn_var as net
builder = getattr(net, 'build_WideResNetVar')()
elif net_name == 'ResNet50':
import models.nets.resnet50 as net
builder = getattr(net, 'build_ResNet50')(is_remix)
else:
assert Exception("Not Implemented Error")
if net_name != 'ResNet50':
setattr_cls_from_kwargs(builder, net_conf)
return builder.build
def get_logger(name, save_path=None, level='INFO'):
logger = logging.getLogger(name)
logger.setLevel(getattr(logging, level))
log_format = logging.Formatter('[%(asctime)s %(levelname)s] %(message)s')
streamHandler = logging.StreamHandler()
streamHandler.setFormatter(log_format)
logger.addHandler(streamHandler)
if not save_path is None:
os.makedirs(save_path, exist_ok=True)
fileHandler = logging.FileHandler(os.path.join(save_path, 'log.txt'))
fileHandler.setFormatter(log_format)
logger.addHandler(fileHandler)
return logger
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
class TBLog:
"""
Construc tensorboard writer (self.writer).
The tensorboard is saved at os.path.join(tb_dir, file_name).
"""
def __init__(self, tb_dir, file_name, use_tensorboard=False):
self.tb_dir = tb_dir
self.use_tensorboard = use_tensorboard
if self.use_tensorboard:
self.writer = SummaryWriter(os.path.join(self.tb_dir, file_name))
else:
self.writer = CustomWriter(os.path.join(self.tb_dir, file_name))
def update(self, tb_dict, it, suffix=None, mode="train"):
"""
Args
tb_dict: contains scalar values for updating tensorboard
it: contains information of iteration (int).
suffix: If not None, the update key has the suffix.
"""
if suffix is None:
suffix = ''
if self.use_tensorboard:
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value, it)
else:
self.writer.set_epoch(it, mode)
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value)
self.writer.plot_stats()
self.writer.dump_stats()
def get_optimizer(net, optim_name='SGD', lr=0.1, momentum=0.9, weight_decay=0, nesterov=True, bn_wd_skip=True):
'''
return optimizer (name) in torch.optim.
If bn_wd_skip, the optimizer does not apply
weight decay regularization on parameters in batch normalization.
'''
decay = []
no_decay = []
for name, param in net.named_parameters():
if ('bn' in name or 'bias' in name) and bn_wd_skip:
no_decay.append(param)
else:
decay.append(param)
per_param_args = [{'params': decay},
{'params': no_decay, 'weight_decay': 0.0}]
if optim_name == 'SGD':
optimizer = torch.optim.SGD(per_param_args, lr=lr, momentum=momentum, weight_decay=weight_decay,
nesterov=nesterov)
elif optim_name == 'AdamW':
optimizer = torch.optim.AdamW(per_param_args, lr=lr, weight_decay=weight_decay)
return optimizer
def get_cosine_schedule_with_warmup(optimizer,
num_training_steps,
num_cycles=7. / 16.,
num_warmup_steps=0,
last_epoch=-1):
'''
Get cosine scheduler (LambdaLR).
if warmup is needed, set num_warmup_steps (int) > 0.
'''
def _lr_lambda(current_step):
'''
_lr_lambda returns a multiplicative factor given an interger parameter epochs.
Decaying criteria: last_epoch
'''
if current_step < num_warmup_steps:
_lr = float(current_step) / float(max(1, num_warmup_steps))
else:
num_cos_steps = float(current_step - num_warmup_steps)
num_cos_steps = num_cos_steps / float(max(1, num_training_steps - num_warmup_steps))
_lr = max(0.0, math.cos(math.pi * num_cycles * num_cos_steps))
return _lr
return LambdaLR(optimizer, _lr_lambda, last_epoch)
class PseudoLabel:
def __init__(self, net_builder, num_classes, lambda_u,
num_eval_iter=1000, tb_log=None, ema_m=0.999, logger=None):
"""
class PseudoLabel contains setter of data_loader, optimizer, and model update methods.
Args:
net_builder: backbone network class (see net_builder in utils.py)
num_classes: # of label classes
lambda_u: ratio of unsupervised loss to supervised loss
it: initial iteration count
num_eval_iter: frequency of evaluation.
tb_log: tensorboard writer (see train_utils.py)
logger: logger (see utils.py)
"""
super(PseudoLabel, self).__init__()
# momentum update param
self.loader = {}
self.num_classes = num_classes
self.ema_m = ema_m
# create the encoders
# network is builded only by num_classes,
# other configs are covered in main.py
self.model = net_builder(num_classes=num_classes)
self.ema_model = deepcopy(self.model)
self.num_eval_iter = num_eval_iter
self.lambda_u = lambda_u
self.tb_log = tb_log
self.optimizer = None
self.scheduler = None
self.it = 0
self.logger = logger
self.print_fn = print if logger is None else logger.info
self.bn_controller = Bn_Controller()
def set_data_loader(self, loader_dict):
self.loader_dict = loader_dict
self.print_fn(f'[!] data loader keys: {self.loader_dict.keys()}')
def set_dset(self, dset):
self.ulb_dset = dset
def set_optimizer(self, optimizer, scheduler=None):
self.optimizer = optimizer
self.scheduler = scheduler
def train(self, args):
ngpus_per_node = torch.cuda.device_count()
# EMA init
self.model.train()
self.ema = EMA(self.model, self.ema_m)
self.ema.register()
if args.resume == True:
self.ema.load(self.ema_model)
# for gpu profiling
start_batch = torch.cuda.Event(enable_timing=True)
end_batch = torch.cuda.Event(enable_timing=True)
start_run = torch.cuda.Event(enable_timing=True)
end_run = torch.cuda.Event(enable_timing=True)
start_batch.record()
best_eval_acc, best_it = 0.0, 0
scaler = GradScaler()
amp_cm = autocast if args.amp else contextlib.nullcontext
# eval for once to verify if the checkpoint is loaded correctly
if args.resume == True:
eval_dict = self.evaluate(args=args)
print(eval_dict)
selected_label = torch.ones((len(self.ulb_dset),), dtype=torch.long, ) * -1
selected_label = selected_label.cuda(args.gpu)
classwise_acc = torch.zeros((args.num_classes,)).cuda(args.gpu)
for (_, x_lb, y_lb), (x_ulb_idx, x_ulb_w) in zip(self.loader_dict['train_lb'], self.loader_dict['train_ulb']):
# prevent the training iterations exceed args.num_train_iter
if self.it > args.num_train_iter:
break
unsup_warmup = np.clip(self.it / (args.unsup_warmup_pos * args.num_train_iter),
a_min=0.0, a_max=1.0)
end_batch.record()
torch.cuda.synchronize()
start_run.record()
x_lb, x_ulb_w = x_lb.cuda(args.gpu), x_ulb_w.cuda(args.gpu)
x_ulb_idx = x_ulb_idx.cuda(args.gpu)
y_lb = y_lb.cuda(args.gpu)
num_lb = x_lb.shape[0]
if args.use_flex:
pseudo_counter = Counter(selected_label.tolist())
if max(pseudo_counter.values()) < len(self.ulb_dset): # not all(5w) -1
for i in range(args.num_classes):
classwise_acc[i] = pseudo_counter[i] / max(pseudo_counter.values())
# inference and calculate sup/unsup losses
with amp_cm():
logits_x_lb = self.model(x_lb)
self.bn_controller.freeze_bn(self.model)
logits_x_ulb_w = self.model(x_ulb_w)
self.bn_controller.unfreeze_bn(self.model)
sup_loss = ce_loss(logits_x_lb, y_lb, reduction='mean')
unsup_loss, select, pseudo_lb = consistency_loss(logits_x_ulb_w, classwise_acc, self.it, args.dataset,
args.p_cutoff, use_flex=args.use_flex)
if x_ulb_idx[select == 1].nelement() != 0:
selected_label[x_ulb_idx[select == 1]] = pseudo_lb[select == 1]
total_loss = sup_loss + self.lambda_u * unsup_loss * unsup_warmup
# parameter updates
if args.amp:
scaler.scale(total_loss).backward()
if (args.clip > 0):
scaler.unscale_(self.optimizer)
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
scaler.step(self.optimizer)
scaler.update()
else:
total_loss.backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
self.optimizer.step()
self.scheduler.step()
self.ema.update()
self.model.zero_grad()
end_run.record()
torch.cuda.synchronize()
# tensorboard_dict update
tb_dict = {}
tb_dict['train/sup_loss'] = sup_loss.detach()
tb_dict['train/unsup_loss'] = unsup_loss.detach()
tb_dict['train/total_loss'] = total_loss.detach()
tb_dict['lr'] = self.optimizer.param_groups[0]['lr']
tb_dict['train/prefecth_time'] = start_batch.elapsed_time(end_batch) / 1000.
tb_dict['train/run_time'] = start_run.elapsed_time(end_run) / 1000.
# save model for each 10K steps and best model for each 1K steps
if self.it % 10000 == 0:
save_path = os.path.join(args.save_dir, args.save_name)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
self.save_model('latest_model.pth', save_path)
if self.it % self.num_eval_iter == 0:
eval_dict = self.evaluate(args=args)
tb_dict.update(eval_dict)
save_path = os.path.join(args.save_dir, args.save_name)
if tb_dict['eval/top-1-acc'] > best_eval_acc:
best_eval_acc = tb_dict['eval/top-1-acc']
best_it = self.it
self.print_fn(
f"{self.it} iteration, {tb_dict}, BEST_EVAL_ACC: {best_eval_acc}, at {best_it} iters")
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
if self.it == best_it:
self.save_model('model_best.pth', save_path)
if not self.tb_log is None:
self.tb_log.update(tb_dict, self.it)
self.it += 1
del tb_dict
start_batch.record()
if self.it > 0.8 * args.num_train_iter:
self.num_eval_iter = 1000
eval_dict = self.evaluate(args=args)
eval_dict.update({'eval/best_acc': best_eval_acc, 'eval/best_it': best_it})
return eval_dict
def evaluate(self, eval_loader=None, args=None):
self.model.eval()
self.ema.apply_shadow()
if eval_loader is None:
eval_loader = self.loader_dict['eval']
total_loss = 0.0
total_num = 0.0
y_true = []
y_pred = []
y_logits = []
for _, x, y in eval_loader:
x, y = x.cuda(args.gpu), y.cuda(args.gpu)
num_batch = x.shape[0]
total_num += num_batch
logits = self.model(x)
loss = F.cross_entropy(logits, y, reduction='mean')
y_true.extend(y.cpu().tolist())
y_pred.extend(torch.max(logits, dim=-1)[1].cpu().tolist())
y_logits.extend(torch.softmax(logits, dim=-1).cpu().tolist())
total_loss += loss.detach() * num_batch
top1 = accuracy_score(y_true, y_pred)
top5 = top_k_accuracy_score(y_true, y_logits, k=5)
precision = precision_score(y_true, y_pred, average='macro')
recall = recall_score(y_true, y_pred, average='macro')
F1 = f1_score(y_true, y_pred, average='macro')
AUC = roc_auc_score(y_true, y_logits, multi_class='ovo')
cf_mat = confusion_matrix(y_true, y_pred, normalize='true')
self.print_fn('confusion matrix:\n' + np.array_str(cf_mat))
self.ema.restore()
self.model.train()
return {'eval/loss': total_loss / total_num, 'eval/top-1-acc': top1, 'eval/top-5-acc': top5,
'eval/precision': precision, 'eval/recall': recall, 'eval/F1': F1, 'eval/AUC': AUC}
def save_model(self, save_name, save_path):
if self.it < 1000000:
return
save_filename = os.path.join(save_path, save_name)
# copy EMA parameters to ema_model for saving with model as temp
self.model.eval()
self.ema.apply_shadow()
ema_model = self.model.state_dict()
self.ema.restore()
self.model.train()
torch.save({'model': self.model.state_dict(),
'optimizer': self.optimizer.state_dict(),
'scheduler': self.scheduler.state_dict(),
'it': self.it + 1,
'ema_model': ema_model},
save_filename)
self.print_fn(f"model saved: {save_filename}")
def load_model(self, load_path):
checkpoint = torch.load(load_path)
self.model.load_state_dict(checkpoint['model'])
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.scheduler.load_state_dict(checkpoint['scheduler'])
self.it = checkpoint['it']
self.ema_model.load_state_dict(checkpoint['ema_model'])
self.print_fn('model loaded')
# Abandoned in Pseudo Label
def interleave_offsets(self, batch, nu):
groups = [batch // (nu + 1)] * (nu + 1)
for x in range(batch - sum(groups)):
groups[-x - 1] += 1
offsets = [0]
for g in groups:
offsets.append(offsets[-1] + g)
assert offsets[-1] == batch
return offsets
def interleave(self, xy, batch):
nu = len(xy) - 1
offsets = self.interleave_offsets(batch, nu)
xy = [[v[offsets[p]:offsets[p + 1]] for p in range(nu + 1)] for v in xy]
for i in range(1, nu + 1):
xy[0][i], xy[i][i] = xy[i][i], xy[0][i]
return [torch.cat(v, dim=0) for v in xy]
class SSL_Dataset:
"""
SSL_Dataset class gets dataset from torchvision.datasets,
separates labeled and unlabeled data,
and return BasicDataset: torch.utils.data.Dataset (see datasets.dataset.py)
"""
def __init__(self,
args,
alg='fixmatch',
name='cifar10',
train=True,
num_classes=10,
data_dir='./data'):
"""
Args
alg: SSL algorithms
name: name of dataset in torchvision.datasets (cifar10, cifar100, svhn, stl10)
train: True means the dataset is training dataset (default=True)
num_classes: number of label classes
data_dir: path of directory, where data is downloaed or stored.
"""
self.args = args
self.alg = alg
self.name = name
self.train = train
self.num_classes = num_classes
self.data_dir = data_dir
crop_size = 96 if self.name.upper() == 'STL10' else 224 if self.name.upper() == 'IMAGENET' else 32
self.transform = get_transform(mean[name], std[name], crop_size, train)
def get_data(self, svhn_extra=True):
"""
get_data returns data (images) and targets (labels)
shape of data: B, H, W, C
shape of labels: B,
"""
dset = getattr(torchvision.datasets, self.name.upper())
if 'CIFAR' in self.name.upper():
dset = dset(self.data_dir, train=self.train, download=True)
data, targets = dset.data, dset.targets
return data, targets
elif self.name.upper() == 'SVHN':
if self.train:
if svhn_extra: # train+extra
dset_base = dset(self.data_dir, split='train', download=True)
data_b, targets_b = dset_base.data.transpose([0, 2, 3, 1]), dset_base.labels
dset_extra = dset(self.data_dir, split='extra', download=True)
data_e, targets_e = dset_extra.data.transpose([0, 2, 3, 1]), dset_extra.labels
data = np.concatenate([data_b, data_e])
targets = np.concatenate([targets_b, targets_e])
del data_b, data_e
del targets_b, targets_e
else: # train_only
dset = dset(self.data_dir, split='train', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
else: # test
dset = dset(self.data_dir, split='test', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
return data, targets
elif self.name.upper() == 'STL10':
split = 'train' if self.train else 'test'
dset_lb = dset(self.data_dir, split=split, download=True)
dset_ulb = dset(self.data_dir, split='unlabeled', download=True)
data, targets = dset_lb.data.transpose([0, 2, 3, 1]), dset_lb.labels.astype(np.int64)
ulb_data = dset_ulb.data.transpose([0, 2, 3, 1])
return data, targets, ulb_data
def get_dset(self, is_ulb=False,
strong_transform=None, onehot=False):
"""
get_dset returns class BasicDataset, containing the returns of get_data.
Args
is_ulb: If True, returned dataset generates a pair of weak and strong augmented images.
strong_transform: list of strong_transform (augmentation) if use_strong_transform is True。
onehot: If True, the label is not integer, but one-hot vector.
"""
if self.name.upper() == 'STL10':
data, targets, _ = self.get_data()
else:
data, targets = self.get_data()
num_classes = self.num_classes
transform = self.transform
return BasicDataset(self.alg, data, targets, num_classes, transform,
is_ulb, strong_transform, onehot)
def get_ssl_dset(self, num_labels, index=None, include_lb_to_ulb=True,
strong_transform=None, onehot=False):
"""
get_ssl_dset split training samples into labeled and unlabeled samples.
The labeled data is balanced samples over classes.
Args:
num_labels: number of labeled data.
index: If index of np.array is given, labeled data is not randomly sampled, but use index for sampling.
include_lb_to_ulb: If True, consistency regularization is also computed for the labeled data.
strong_transform: list of strong transform (RandAugment in FixMatch)
onehot: If True, the target is converted into onehot vector.
Returns:
BasicDataset (for labeled data), BasicDataset (for unlabeld data)
"""
# Supervised top line using all data as labeled data.
if self.alg == 'fullysupervised':
lb_data, lb_targets = self.get_data()
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
return lb_dset, None
if self.name.upper() == 'STL10':
lb_data, lb_targets, ulb_data = self.get_data()
if include_lb_to_ulb:
ulb_data = np.concatenate([ulb_data, lb_data], axis=0)
lb_data, lb_targets, _ = sample_labeled_data(self.args, lb_data, lb_targets, num_labels, self.num_classes)
ulb_targets = None
else:
data, targets = self.get_data()
lb_data, lb_targets, ulb_data, ulb_targets = split_ssl_data(self.args, data, targets,
num_labels, self.num_classes,
index, include_lb_to_ulb)
# output the distribution of labeled data for remixmatch
count = [0 for _ in range(self.num_classes)]
for c in lb_targets:
count[c] += 1
dist = np.array(count, dtype=float)
dist = dist / dist.sum()
dist = dist.tolist()
out = {"distribution": dist}
output_file = r"./data_statistics/"
output_path = output_file + str(self.name) + '_' + str(num_labels) + '.json'
if not os.path.exists(output_file):
os.makedirs(output_file, exist_ok=True)
with open(output_path, 'w') as w:
json.dump(out, w)
# print(Counter(ulb_targets.tolist()))
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
ulb_dset = BasicDataset(self.alg, ulb_data, ulb_targets, self.num_classes,
self.transform, True, strong_transform, onehot)
# print(lb_data.shape)
# print(ulb_data.shape)
return lb_dset, ulb_dset
def get_data_loader(dset,
batch_size=None,
shuffle=False,
num_workers=4,
pin_memory=False,
data_sampler=None,
replacement=True,
num_epochs=None,
num_iters=None,
generator=None,
drop_last=True,
distributed=False):
"""
get_data_loader returns torch.utils.data.DataLoader for a Dataset.
All arguments are comparable with those of pytorch DataLoader.
However, if distributed, DistributedProxySampler, which is a wrapper of data_sampler, is used.
Args
num_epochs: total batch -> (# of batches in dset) * num_epochs
num_iters: total batch -> num_iters
"""
assert batch_size is not None
if data_sampler is None:
return DataLoader(dset, batch_size=batch_size, shuffle=shuffle,
num_workers=num_workers, pin_memory=pin_memory)
else:
if isinstance(data_sampler, str):
data_sampler = get_sampler_by_name(data_sampler)
if distributed:
assert dist.is_available()
num_replicas = dist.get_world_size()
else:
num_replicas = 1
if (num_epochs is not None) and (num_iters is None):
num_samples = len(dset) * num_epochs
elif (num_epochs is None) and (num_iters is not None):
num_samples = batch_size * num_iters * num_replicas
else:
num_samples = len(dset)
if data_sampler.__name__ == 'RandomSampler':
data_sampler = data_sampler(dset, replacement, num_samples, generator)
else:
raise RuntimeError(f"{data_sampler.__name__} is not implemented.")
if distributed:
'''
Different with DistributedSampler,
the DistribuedProxySampler does not shuffle the data (just wrapper for dist).
'''
data_sampler = DistributedProxySampler(data_sampler)
batch_sampler = BatchSampler(data_sampler, batch_size, drop_last)
return DataLoader(dset, batch_sampler=batch_sampler,
num_workers=num_workers, pin_memory=pin_memory)
The provided code snippet includes necessary dependencies for implementing the `main_worker` function. Write a Python function `def main_worker(gpu, ngpus_per_node, args)` to solve the following problem:
main_worker is conducted on each GPU.
Here is the function:
def main_worker(gpu, ngpus_per_node, args):
'''
main_worker is conducted on each GPU.
'''
global best_acc1
args.gpu = gpu
# random seed has to be set for the syncronization of labeled data sampling in each process.
assert args.seed is not None
random.seed(args.seed)
torch.manual_seed(args.seed)
np.random.seed(args.seed)
cudnn.deterministic = True
# SET UP FOR DISTRIBUTED TRAINING
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
args.rank = args.rank * ngpus_per_node + gpu # compute global rank
# set distributed group:
dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
world_size=args.world_size, rank=args.rank)
# SET save_path and logger
save_path = os.path.join(args.save_dir, args.save_name)
logger_level = "WARNING"
tb_log = None
if args.rank % ngpus_per_node == 0:
tb_log = TBLog(save_path, 'tensorboard', use_tensorboard=args.use_tensorboard)
logger_level = "INFO"
logger = get_logger(args.save_name, save_path, logger_level)
logger.warning(f"USE GPU: {args.gpu} for training")
args.bn_momentum = 1.0 - 0.999
if 'imagenet' in args.dataset.lower():
_net_builder = net_builder('ResNet50', False, None, is_remix=False)
else:
_net_builder = net_builder(args.net,
args.net_from_name,
{'first_stride': 2 if 'stl' in args.dataset else 1,
'depth': args.depth,
'widen_factor': args.widen_factor,
'leaky_slope': args.leaky_slope,
'bn_momentum': args.bn_momentum,
'dropRate': args.dropout,
'use_embed': False,
'is_remix': False},
)
model = PseudoLabel(_net_builder,
args.num_classes,
args.ulb_loss_ratio,
num_eval_iter=args.num_eval_iter,
tb_log=tb_log,
ema_m=args.ema_m,
logger=logger)
logger.info(f'Number of Trainable Params: {count_parameters(model.model)}')
# SET Optimizer & LR Scheduler
## construct SGD and cosine lr scheduler
optimizer = get_optimizer(model.model, args.optim, args.lr, args.momentum, args.weight_decay)
scheduler = get_cosine_schedule_with_warmup(optimizer,
args.num_train_iter,
num_warmup_steps=args.num_train_iter * 0)
## set SGD and cosine lr
model.set_optimizer(optimizer, scheduler)
# SET Devices for (Distributed) DataParallel
if not torch.cuda.is_available():
raise Exception('ONLY GPU TRAINING IS SUPPORTED')
elif args.distributed:
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
'''
batch_size: batch_size per node -> batch_size per gpu
workers: workers per node -> workers per gpu
'''
args.batch_size = int(args.batch_size / ngpus_per_node)
model.model.cuda(args.gpu)
model.model = nn.SyncBatchNorm.convert_sync_batchnorm(model.model)
model.model = torch.nn.parallel.DistributedDataParallel(model.model,
device_ids=[args.gpu],
broadcast_buffers=False,
find_unused_parameters=True)
else:
# if arg.gpu is None, DDP will divide and allocate batch_size
# to all available GPUs if device_ids are not set.
model.cuda()
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.model = model.model.cuda(args.gpu)
else:
model.model = torch.nn.DataParallel(model.model).cuda()
import copy
model.ema_model = copy.deepcopy(model.model)
logger.info(f"model_arch: {model}")
logger.info(f"Arguments: {args}")
cudnn.benchmark = True
if args.rank != 0 and args.distributed:
torch.distributed.barrier()
# Construct Dataset & DataLoader
if args.dataset != "imagenet":
if args.num_labels == 10 and args.dataset == 'cifar10':
fixmatch_index = [
[7408, 8148, 9850, 10361, 33949, 36506, 37018, 45044, 46443, 47447],
[5022, 8193, 8902, 9601, 25226, 26223, 34089, 35186, 40595, 48024],
[7510, 13186, 14043, 21305, 22805, 31288, 34508, 40470, 41493, 45506],
[9915, 9978, 16631, 19915, 28008, 35314, 35801, 36149, 39215, 42557],
[6695, 14891, 19726, 22715, 23999, 34230, 46511, 47457, 49181, 49397],
[12830, 20293, 26835, 30517, 30898, 31061, 43693, 46501, 47310, 48517],
[1156, 11501, 19974, 21963, 32103, 42189, 46789, 47690, 48229, 48675],
[4255, 6446, 8580, 11759, 12598, 29349, 29433, 33759, 35345, 38639]]
index = fixmatch_index[-args.seed - 1]
print("10 labels for cifar10")
else:
index = None
train_dset = SSL_Dataset(args, alg='pseudolabel', name=args.dataset, train=True,
num_classes=args.num_classes, data_dir=args.data_dir)
lb_dset, ulb_dset = train_dset.get_ssl_dset(args.num_labels, index=index)
_eval_dset = SSL_Dataset(args, alg='pseudolabel', name=args.dataset, train=False,
num_classes=args.num_classes, data_dir=args.data_dir)
eval_dset = _eval_dset.get_dset()
if args.rank == 0 and args.distributed:
torch.distributed.barrier()
loader_dict = {}
dset_dict = {'train_lb': lb_dset, 'train_ulb': ulb_dset, 'eval': eval_dset}
loader_dict['train_lb'] = get_data_loader(dset_dict['train_lb'],
args.batch_size,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=args.num_workers,
distributed=args.distributed)
loader_dict['train_ulb'] = get_data_loader(dset_dict['train_ulb'],
args.batch_size * args.uratio,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=4 * args.num_workers,
distributed=args.distributed)
loader_dict['eval'] = get_data_loader(dset_dict['eval'],
args.eval_batch_size,
num_workers=args.num_workers,
drop_last=False)
## set DataLoader
model.set_data_loader(loader_dict)
model.set_dset(ulb_dset)
# If args.resume, load checkpoints from args.load_path
if args.resume:
model.load_model(args.load_path)
# START TRAINING
trainer = model.train
for epoch in range(args.epoch):
trainer(args)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
model.save_model('latest_model.pth', save_path)
logging.warning(f"GPU {args.rank} training is FINISHED") | main_worker is conducted on each GPU. |
157,474 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.pseudolabel.pseudolabel import PseudoLabel
from datasets.ssl_dataset import SSL_Dataset
from datasets.data_utils import get_data_loader
def str2bool(v):
if isinstance(v, bool):
return v
if v.lower() in ('yes', 'true', 't', 'y', '1'):
return True
elif v.lower() in ('no', 'false', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError('Boolean value expected.') | null |
157,475 | import os
import time
from torch.utils.tensorboard import SummaryWriter
import logging
import yaml
def over_write_args_from_file(args, yml):
if yml == '':
return
with open(yml, 'r', encoding='utf-8') as f:
dic = yaml.load(f.read(), Loader=yaml.Loader)
for k in dic:
setattr(args, k, dic[k]) | null |
157,476 | import os
import time
from torch.utils.tensorboard import SummaryWriter
import logging
import yaml
def setattr_cls_from_kwargs(cls, kwargs):
# if default values are in the cls,
# overlap the value by kwargs
for key in kwargs.keys():
if hasattr(cls, key):
print(f"{key} in {cls} is overlapped by kwargs: {getattr(cls, key)} -> {kwargs[key]}")
setattr(cls, key, kwargs[key])
def test_setattr_cls_from_kwargs():
class _test_cls:
def __init__(self):
self.a = 1
self.b = 'hello'
test_cls = _test_cls()
config = {'a': 3, 'b': 'change_hello', 'c': 5}
setattr_cls_from_kwargs(test_cls, config)
for key in config.keys():
print(f"{key}:\t {getattr(test_cls, key)}") | null |
157,477 | import os
import time
from torch.utils.tensorboard import SummaryWriter
import logging
import yaml
def net_builder(net_name, from_name: bool, net_conf=None, is_remix=False):
"""
return **class** of backbone network (not instance).
Args
net_name: 'WideResNet' or network names in torchvision.models
from_name: If True, net_buidler takes models in torch.vision models. Then, net_conf is ignored.
net_conf: When from_name is False, net_conf is the configuration of backbone network (now, only WRN is supported).
"""
if from_name:
import torchvision.models as models
model_name_list = sorted(name for name in models.__dict__
if name.islower() and not name.startswith("__")
and callable(models.__dict__[name]))
if net_name not in model_name_list:
assert Exception(f"[!] Networks\' Name is wrong, check net config, \
expected: {model_name_list} \
received: {net_name}")
else:
return models.__dict__[net_name]
else:
if net_name == 'WideResNet':
import models.nets.wrn as net
builder = getattr(net, 'build_WideResNet')()
elif net_name == 'WideResNetVar':
import models.nets.wrn_var as net
builder = getattr(net, 'build_WideResNetVar')()
elif net_name == 'ResNet50':
import models.nets.resnet50 as net
builder = getattr(net, 'build_ResNet50')(is_remix)
else:
assert Exception("Not Implemented Error")
if net_name != 'ResNet50':
setattr_cls_from_kwargs(builder, net_conf)
return builder.build
def test_net_builder(net_name, from_name, net_conf=None):
builder = net_builder(net_name, from_name, net_conf)
print(f"net_name: {net_name}, from_name: {from_name}, net_conf: {net_conf}")
print(builder) | null |
157,478 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.flexmatch.flexmatch import FlexMatch
from datasets.ssl_dataset import SSL_Dataset, ImageNetLoader
from datasets.data_utils import get_data_loader
def net_builder(net_name, from_name: bool, net_conf=None, is_remix=False):
"""
return **class** of backbone network (not instance).
Args
net_name: 'WideResNet' or network names in torchvision.models
from_name: If True, net_buidler takes models in torch.vision models. Then, net_conf is ignored.
net_conf: When from_name is False, net_conf is the configuration of backbone network (now, only WRN is supported).
"""
if from_name:
import torchvision.models as models
model_name_list = sorted(name for name in models.__dict__
if name.islower() and not name.startswith("__")
and callable(models.__dict__[name]))
if net_name not in model_name_list:
assert Exception(f"[!] Networks\' Name is wrong, check net config, \
expected: {model_name_list} \
received: {net_name}")
else:
return models.__dict__[net_name]
else:
if net_name == 'WideResNet':
import models.nets.wrn as net
builder = getattr(net, 'build_WideResNet')()
elif net_name == 'WideResNetVar':
import models.nets.wrn_var as net
builder = getattr(net, 'build_WideResNetVar')()
elif net_name == 'ResNet50':
import models.nets.resnet50 as net
builder = getattr(net, 'build_ResNet50')(is_remix)
else:
assert Exception("Not Implemented Error")
if net_name != 'ResNet50':
setattr_cls_from_kwargs(builder, net_conf)
return builder.build
def get_logger(name, save_path=None, level='INFO'):
logger = logging.getLogger(name)
logger.setLevel(getattr(logging, level))
log_format = logging.Formatter('[%(asctime)s %(levelname)s] %(message)s')
streamHandler = logging.StreamHandler()
streamHandler.setFormatter(log_format)
logger.addHandler(streamHandler)
if not save_path is None:
os.makedirs(save_path, exist_ok=True)
fileHandler = logging.FileHandler(os.path.join(save_path, 'log.txt'))
fileHandler.setFormatter(log_format)
logger.addHandler(fileHandler)
return logger
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
class TBLog:
"""
Construc tensorboard writer (self.writer).
The tensorboard is saved at os.path.join(tb_dir, file_name).
"""
def __init__(self, tb_dir, file_name, use_tensorboard=False):
self.tb_dir = tb_dir
self.use_tensorboard = use_tensorboard
if self.use_tensorboard:
self.writer = SummaryWriter(os.path.join(self.tb_dir, file_name))
else:
self.writer = CustomWriter(os.path.join(self.tb_dir, file_name))
def update(self, tb_dict, it, suffix=None, mode="train"):
"""
Args
tb_dict: contains scalar values for updating tensorboard
it: contains information of iteration (int).
suffix: If not None, the update key has the suffix.
"""
if suffix is None:
suffix = ''
if self.use_tensorboard:
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value, it)
else:
self.writer.set_epoch(it, mode)
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value)
self.writer.plot_stats()
self.writer.dump_stats()
def get_optimizer(net, optim_name='SGD', lr=0.1, momentum=0.9, weight_decay=0, nesterov=True, bn_wd_skip=True):
'''
return optimizer (name) in torch.optim.
If bn_wd_skip, the optimizer does not apply
weight decay regularization on parameters in batch normalization.
'''
decay = []
no_decay = []
for name, param in net.named_parameters():
if ('bn' in name or 'bias' in name) and bn_wd_skip:
no_decay.append(param)
else:
decay.append(param)
per_param_args = [{'params': decay},
{'params': no_decay, 'weight_decay': 0.0}]
if optim_name == 'SGD':
optimizer = torch.optim.SGD(per_param_args, lr=lr, momentum=momentum, weight_decay=weight_decay,
nesterov=nesterov)
elif optim_name == 'AdamW':
optimizer = torch.optim.AdamW(per_param_args, lr=lr, weight_decay=weight_decay)
return optimizer
def get_cosine_schedule_with_warmup(optimizer,
num_training_steps,
num_cycles=7. / 16.,
num_warmup_steps=0,
last_epoch=-1):
'''
Get cosine scheduler (LambdaLR).
if warmup is needed, set num_warmup_steps (int) > 0.
'''
def _lr_lambda(current_step):
'''
_lr_lambda returns a multiplicative factor given an interger parameter epochs.
Decaying criteria: last_epoch
'''
if current_step < num_warmup_steps:
_lr = float(current_step) / float(max(1, num_warmup_steps))
else:
num_cos_steps = float(current_step - num_warmup_steps)
num_cos_steps = num_cos_steps / float(max(1, num_training_steps - num_warmup_steps))
_lr = max(0.0, math.cos(math.pi * num_cycles * num_cos_steps))
return _lr
return LambdaLR(optimizer, _lr_lambda, last_epoch)
class FlexMatch:
def __init__(self, net_builder, num_classes, ema_m, T, p_cutoff, lambda_u, \
hard_label=True, t_fn=None, p_fn=None, it=0, num_eval_iter=1000, tb_log=None, logger=None):
"""
class Flexmatch contains setter of data_loader, optimizer, and model update methods.
Args:
net_builder: backbone network class (see net_builder in utils.py)
num_classes: # of label classes
ema_m: momentum of exponential moving average for eval_model
T: Temperature scaling parameter for output sharpening (only when hard_label = False)
p_cutoff: confidence cutoff parameters for loss masking
lambda_u: ratio of unsupervised loss to supervised loss
hard_label: If True, consistency regularization use a hard pseudo label.
it: initial iteration count
num_eval_iter: freqeuncy of iteration (after 500,000 iters)
tb_log: tensorboard writer (see train_utils.py)
logger: logger (see utils.py)
"""
super(FlexMatch, self).__init__()
# momentum update param
self.loader = {}
self.num_classes = num_classes
self.ema_m = ema_m
# create the encoders
# network is builded only by num_classes,
# other configs are covered in main.py
self.model = net_builder(num_classes=num_classes)
self.ema_model = None
self.num_eval_iter = num_eval_iter
self.t_fn = Get_Scalar(T) # temperature params function
self.p_fn = Get_Scalar(p_cutoff) # confidence cutoff function
self.lambda_u = lambda_u
self.tb_log = tb_log
self.use_hard_label = hard_label
self.optimizer = None
self.scheduler = None
self.it = 0
self.logger = logger
self.print_fn = print if logger is None else logger.info
self.bn_controller = Bn_Controller()
def set_data_loader(self, loader_dict):
self.loader_dict = loader_dict
self.print_fn(f'[!] data loader keys: {self.loader_dict.keys()}')
def set_dset(self, dset):
self.ulb_dset = dset
def set_optimizer(self, optimizer, scheduler=None):
self.optimizer = optimizer
self.scheduler = scheduler
def train(self, args, logger=None):
ngpus_per_node = torch.cuda.device_count()
# EMA Init
self.model.train()
self.ema = EMA(self.model, self.ema_m)
self.ema.register()
if args.resume == True:
self.ema.load(self.ema_model)
# p(y) based on the labeled examples seen during training
dist_file_name = r"./data_statistics/" + args.dataset + '_' + str(args.num_labels) + '.json'
if args.dataset.upper() == 'IMAGENET':
p_target = None
else:
with open(dist_file_name, 'r') as f:
p_target = json.loads(f.read())
p_target = torch.tensor(p_target['distribution'])
p_target = p_target.cuda(args.gpu)
# print('p_target:', p_target)
p_model = None
# for gpu profiling
start_batch = torch.cuda.Event(enable_timing=True)
end_batch = torch.cuda.Event(enable_timing=True)
start_run = torch.cuda.Event(enable_timing=True)
end_run = torch.cuda.Event(enable_timing=True)
start_batch.record()
best_eval_acc, best_it = 0.0, 0
scaler = GradScaler()
amp_cm = autocast if args.amp else contextlib.nullcontext
# eval for once to verify if the checkpoint is loaded correctly
if args.resume == True:
eval_dict = self.evaluate(args=args)
print(eval_dict)
selected_label = torch.ones((len(self.ulb_dset),), dtype=torch.long, ) * -1
selected_label = selected_label.cuda(args.gpu)
classwise_acc = torch.zeros((args.num_classes,)).cuda(args.gpu)
for (_, x_lb, y_lb), (x_ulb_idx, x_ulb_w, x_ulb_s) in zip(self.loader_dict['train_lb'],
self.loader_dict['train_ulb']):
# prevent the training iterations exceed args.num_train_iter
if self.it > args.num_train_iter:
break
end_batch.record()
torch.cuda.synchronize()
start_run.record()
num_lb = x_lb.shape[0]
num_ulb = x_ulb_w.shape[0]
assert num_ulb == x_ulb_s.shape[0]
x_lb, x_ulb_w, x_ulb_s = x_lb.cuda(args.gpu), x_ulb_w.cuda(args.gpu), x_ulb_s.cuda(args.gpu)
x_ulb_idx = x_ulb_idx.cuda(args.gpu)
y_lb = y_lb.cuda(args.gpu)
pseudo_counter = Counter(selected_label.tolist())
if max(pseudo_counter.values()) < len(self.ulb_dset): # not all(5w) -1
if args.thresh_warmup:
for i in range(args.num_classes):
classwise_acc[i] = pseudo_counter[i] / max(pseudo_counter.values())
else:
wo_negative_one = deepcopy(pseudo_counter)
if -1 in wo_negative_one.keys():
wo_negative_one.pop(-1)
for i in range(args.num_classes):
classwise_acc[i] = pseudo_counter[i] / max(wo_negative_one.values())
inputs = torch.cat((x_lb, x_ulb_w, x_ulb_s))
# inference and calculate sup/unsup losses
with amp_cm():
logits = self.model(inputs)
logits_x_lb = logits[:num_lb]
logits_x_ulb_w, logits_x_ulb_s = logits[num_lb:].chunk(2)
sup_loss = ce_loss(logits_x_lb, y_lb, reduction='mean')
# hyper-params for update
T = self.t_fn(self.it)
p_cutoff = self.p_fn(self.it)
unsup_loss, mask, select, pseudo_lb, p_model = consistency_loss(logits_x_ulb_s,
logits_x_ulb_w,
classwise_acc,
p_target,
p_model,
'ce', T, p_cutoff,
use_hard_labels=args.hard_label,
use_DA=args.use_DA)
if x_ulb_idx[select == 1].nelement() != 0:
selected_label[x_ulb_idx[select == 1]] = pseudo_lb[select == 1]
total_loss = sup_loss + self.lambda_u * unsup_loss
# parameter updates
if args.amp:
scaler.scale(total_loss).backward()
if (args.clip > 0):
scaler.unscale_(self.optimizer)
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
scaler.step(self.optimizer)
scaler.update()
else:
total_loss.backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
self.optimizer.step()
self.scheduler.step()
self.ema.update()
self.model.zero_grad()
end_run.record()
torch.cuda.synchronize()
# tensorboard_dict update
tb_dict = {}
tb_dict['train/sup_loss'] = sup_loss.detach()
tb_dict['train/unsup_loss'] = unsup_loss.detach()
tb_dict['train/total_loss'] = total_loss.detach()
tb_dict['train/mask_ratio'] = 1.0 - mask.detach()
tb_dict['lr'] = self.optimizer.param_groups[0]['lr']
tb_dict['train/prefecth_time'] = start_batch.elapsed_time(end_batch) / 1000.
tb_dict['train/run_time'] = start_run.elapsed_time(end_run) / 1000.
# Save model for each 10K steps and best model for each 1K steps
if self.it % 10000 == 0:
save_path = os.path.join(args.save_dir, args.save_name)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
self.save_model('latest_model.pth', save_path)
if self.it % self.num_eval_iter == 0:
eval_dict = self.evaluate(args=args)
tb_dict.update(eval_dict)
save_path = os.path.join(args.save_dir, args.save_name)
if tb_dict['eval/top-1-acc'] > best_eval_acc:
best_eval_acc = tb_dict['eval/top-1-acc']
best_it = self.it
self.print_fn(
f"{self.it} iteration, USE_EMA: {self.ema_m != 0}, {tb_dict}, BEST_EVAL_ACC: {best_eval_acc}, at {best_it} iters")
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
if self.it == best_it:
self.save_model('model_best.pth', save_path)
if not self.tb_log is None:
self.tb_log.update(tb_dict, self.it)
self.it += 1
del tb_dict
start_batch.record()
if self.it > 0.8 * args.num_train_iter:
self.num_eval_iter = 1000
eval_dict = self.evaluate(args=args)
eval_dict.update({'eval/best_acc': best_eval_acc, 'eval/best_it': best_it})
return eval_dict
def evaluate(self, eval_loader=None, args=None):
self.model.eval()
self.ema.apply_shadow()
if eval_loader is None:
eval_loader = self.loader_dict['eval']
total_loss = 0.0
total_num = 0.0
y_true = []
y_pred = []
y_logits = []
for _, x, y in eval_loader:
x, y = x.cuda(args.gpu), y.cuda(args.gpu)
num_batch = x.shape[0]
total_num += num_batch
logits = self.model(x)
loss = F.cross_entropy(logits, y, reduction='mean')
y_true.extend(y.cpu().tolist())
y_pred.extend(torch.max(logits, dim=-1)[1].cpu().tolist())
y_logits.extend(torch.softmax(logits, dim=-1).cpu().tolist())
total_loss += loss.detach() * num_batch
top1 = accuracy_score(y_true, y_pred)
top5 = top_k_accuracy_score(y_true, y_logits, k=5)
precision = precision_score(y_true, y_pred, average='macro')
recall = recall_score(y_true, y_pred, average='macro')
F1 = f1_score(y_true, y_pred, average='macro')
AUC = roc_auc_score(y_true, y_logits, multi_class='ovo')
cf_mat = confusion_matrix(y_true, y_pred, normalize='true')
self.print_fn('confusion matrix:\n' + np.array_str(cf_mat))
self.ema.restore()
self.model.train()
return {'eval/loss': total_loss / total_num, 'eval/top-1-acc': top1, 'eval/top-5-acc': top5,
'eval/precision': precision, 'eval/recall': recall, 'eval/F1': F1, 'eval/AUC': AUC}
def save_model(self, save_name, save_path):
save_filename = os.path.join(save_path, save_name)
# copy EMA parameters to ema_model for saving with model as temp
self.model.eval()
self.ema.apply_shadow()
ema_model = self.model.state_dict()
self.ema.restore()
self.model.train()
torch.save({'model': self.model.state_dict(),
'optimizer': self.optimizer.state_dict(),
'scheduler': self.scheduler.state_dict(),
'it': self.it + 1,
'ema_model': ema_model},
save_filename)
self.print_fn(f"model saved: {save_filename}")
def load_model(self, load_path):
checkpoint = torch.load(load_path)
self.model.load_state_dict(checkpoint['model'])
self.ema_model = deepcopy(self.model)
self.ema_model.load_state_dict(checkpoint['ema_model'])
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.scheduler.load_state_dict(checkpoint['scheduler'])
self.it = checkpoint['it']
self.print_fn('model loaded')
def interleave_offsets(self, batch, nu):
groups = [batch // (nu + 1)] * (nu + 1)
for x in range(batch - sum(groups)):
groups[-x - 1] += 1
offsets = [0]
for g in groups:
offsets.append(offsets[-1] + g)
assert offsets[-1] == batch
return offsets
def interleave(self, xy, batch):
nu = len(xy) - 1
offsets = self.interleave_offsets(batch, nu)
xy = [[v[offsets[p]:offsets[p + 1]] for p in range(nu + 1)] for v in xy]
for i in range(1, nu + 1):
xy[0][i], xy[i][i] = xy[i][i], xy[0][i]
return [torch.cat(v, dim=0) for v in xy]
class ImageNetLoader:
def __init__(self, root_path, num_labels=-1, num_class=1000):
self.root_path = os.path.join(root_path, 'imagenet')
self.num_labels = num_labels // num_class
def get_transform(self, train, ulb):
if train:
transform = transforms.Compose([
transforms.Resize([256, 256]),
transforms.RandomHorizontalFlip(),
transforms.RandomCrop(224, padding=4, padding_mode='reflect'),
transforms.ToTensor(),
transforms.Normalize(mean["imagenet"], std["imagenet"])])
else:
transform = transforms.Compose([
transforms.Resize([224, 224]),
transforms.ToTensor(),
transforms.Normalize(mean["imagenet"], std["imagenet"])])
return transform
def get_lb_train_data(self):
transform = self.get_transform(train=True, ulb=False)
data = ImagenetDataset(root=os.path.join(self.root_path, "train"), transform=transform, ulb=False,
num_labels=self.num_labels)
return data
def get_ulb_train_data(self):
transform = self.get_transform(train=True, ulb=True)
data = ImagenetDataset(root=os.path.join(self.root_path, "train"), transform=transform, ulb=True)
return data
def get_lb_test_data(self):
transform = self.get_transform(train=False, ulb=False)
data = ImagenetDataset(root=os.path.join(self.root_path, "val"), transform=transform, ulb=False)
return data
class SSL_Dataset:
"""
SSL_Dataset class gets dataset from torchvision.datasets,
separates labeled and unlabeled data,
and return BasicDataset: torch.utils.data.Dataset (see datasets.dataset.py)
"""
def __init__(self,
args,
alg='fixmatch',
name='cifar10',
train=True,
num_classes=10,
data_dir='./data'):
"""
Args
alg: SSL algorithms
name: name of dataset in torchvision.datasets (cifar10, cifar100, svhn, stl10)
train: True means the dataset is training dataset (default=True)
num_classes: number of label classes
data_dir: path of directory, where data is downloaed or stored.
"""
self.args = args
self.alg = alg
self.name = name
self.train = train
self.num_classes = num_classes
self.data_dir = data_dir
crop_size = 96 if self.name.upper() == 'STL10' else 224 if self.name.upper() == 'IMAGENET' else 32
self.transform = get_transform(mean[name], std[name], crop_size, train)
def get_data(self, svhn_extra=True):
"""
get_data returns data (images) and targets (labels)
shape of data: B, H, W, C
shape of labels: B,
"""
dset = getattr(torchvision.datasets, self.name.upper())
if 'CIFAR' in self.name.upper():
dset = dset(self.data_dir, train=self.train, download=True)
data, targets = dset.data, dset.targets
return data, targets
elif self.name.upper() == 'SVHN':
if self.train:
if svhn_extra: # train+extra
dset_base = dset(self.data_dir, split='train', download=True)
data_b, targets_b = dset_base.data.transpose([0, 2, 3, 1]), dset_base.labels
dset_extra = dset(self.data_dir, split='extra', download=True)
data_e, targets_e = dset_extra.data.transpose([0, 2, 3, 1]), dset_extra.labels
data = np.concatenate([data_b, data_e])
targets = np.concatenate([targets_b, targets_e])
del data_b, data_e
del targets_b, targets_e
else: # train_only
dset = dset(self.data_dir, split='train', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
else: # test
dset = dset(self.data_dir, split='test', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
return data, targets
elif self.name.upper() == 'STL10':
split = 'train' if self.train else 'test'
dset_lb = dset(self.data_dir, split=split, download=True)
dset_ulb = dset(self.data_dir, split='unlabeled', download=True)
data, targets = dset_lb.data.transpose([0, 2, 3, 1]), dset_lb.labels.astype(np.int64)
ulb_data = dset_ulb.data.transpose([0, 2, 3, 1])
return data, targets, ulb_data
def get_dset(self, is_ulb=False,
strong_transform=None, onehot=False):
"""
get_dset returns class BasicDataset, containing the returns of get_data.
Args
is_ulb: If True, returned dataset generates a pair of weak and strong augmented images.
strong_transform: list of strong_transform (augmentation) if use_strong_transform is True。
onehot: If True, the label is not integer, but one-hot vector.
"""
if self.name.upper() == 'STL10':
data, targets, _ = self.get_data()
else:
data, targets = self.get_data()
num_classes = self.num_classes
transform = self.transform
return BasicDataset(self.alg, data, targets, num_classes, transform,
is_ulb, strong_transform, onehot)
def get_ssl_dset(self, num_labels, index=None, include_lb_to_ulb=True,
strong_transform=None, onehot=False):
"""
get_ssl_dset split training samples into labeled and unlabeled samples.
The labeled data is balanced samples over classes.
Args:
num_labels: number of labeled data.
index: If index of np.array is given, labeled data is not randomly sampled, but use index for sampling.
include_lb_to_ulb: If True, consistency regularization is also computed for the labeled data.
strong_transform: list of strong transform (RandAugment in FixMatch)
onehot: If True, the target is converted into onehot vector.
Returns:
BasicDataset (for labeled data), BasicDataset (for unlabeld data)
"""
# Supervised top line using all data as labeled data.
if self.alg == 'fullysupervised':
lb_data, lb_targets = self.get_data()
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
return lb_dset, None
if self.name.upper() == 'STL10':
lb_data, lb_targets, ulb_data = self.get_data()
if include_lb_to_ulb:
ulb_data = np.concatenate([ulb_data, lb_data], axis=0)
lb_data, lb_targets, _ = sample_labeled_data(self.args, lb_data, lb_targets, num_labels, self.num_classes)
ulb_targets = None
else:
data, targets = self.get_data()
lb_data, lb_targets, ulb_data, ulb_targets = split_ssl_data(self.args, data, targets,
num_labels, self.num_classes,
index, include_lb_to_ulb)
# output the distribution of labeled data for remixmatch
count = [0 for _ in range(self.num_classes)]
for c in lb_targets:
count[c] += 1
dist = np.array(count, dtype=float)
dist = dist / dist.sum()
dist = dist.tolist()
out = {"distribution": dist}
output_file = r"./data_statistics/"
output_path = output_file + str(self.name) + '_' + str(num_labels) + '.json'
if not os.path.exists(output_file):
os.makedirs(output_file, exist_ok=True)
with open(output_path, 'w') as w:
json.dump(out, w)
# print(Counter(ulb_targets.tolist()))
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
ulb_dset = BasicDataset(self.alg, ulb_data, ulb_targets, self.num_classes,
self.transform, True, strong_transform, onehot)
# print(lb_data.shape)
# print(ulb_data.shape)
return lb_dset, ulb_dset
def get_data_loader(dset,
batch_size=None,
shuffle=False,
num_workers=4,
pin_memory=False,
data_sampler=None,
replacement=True,
num_epochs=None,
num_iters=None,
generator=None,
drop_last=True,
distributed=False):
"""
get_data_loader returns torch.utils.data.DataLoader for a Dataset.
All arguments are comparable with those of pytorch DataLoader.
However, if distributed, DistributedProxySampler, which is a wrapper of data_sampler, is used.
Args
num_epochs: total batch -> (# of batches in dset) * num_epochs
num_iters: total batch -> num_iters
"""
assert batch_size is not None
if data_sampler is None:
return DataLoader(dset, batch_size=batch_size, shuffle=shuffle,
num_workers=num_workers, pin_memory=pin_memory)
else:
if isinstance(data_sampler, str):
data_sampler = get_sampler_by_name(data_sampler)
if distributed:
assert dist.is_available()
num_replicas = dist.get_world_size()
else:
num_replicas = 1
if (num_epochs is not None) and (num_iters is None):
num_samples = len(dset) * num_epochs
elif (num_epochs is None) and (num_iters is not None):
num_samples = batch_size * num_iters * num_replicas
else:
num_samples = len(dset)
if data_sampler.__name__ == 'RandomSampler':
data_sampler = data_sampler(dset, replacement, num_samples, generator)
else:
raise RuntimeError(f"{data_sampler.__name__} is not implemented.")
if distributed:
'''
Different with DistributedSampler,
the DistribuedProxySampler does not shuffle the data (just wrapper for dist).
'''
data_sampler = DistributedProxySampler(data_sampler)
batch_sampler = BatchSampler(data_sampler, batch_size, drop_last)
return DataLoader(dset, batch_sampler=batch_sampler,
num_workers=num_workers, pin_memory=pin_memory)
The provided code snippet includes necessary dependencies for implementing the `main_worker` function. Write a Python function `def main_worker(gpu, ngpus_per_node, args)` to solve the following problem:
main_worker is conducted on each GPU.
Here is the function:
def main_worker(gpu, ngpus_per_node, args):
'''
main_worker is conducted on each GPU.
'''
global best_acc1
args.gpu = gpu
# random seed has to be set for the syncronization of labeled data sampling in each process.
assert args.seed is not None
random.seed(args.seed)
torch.manual_seed(args.seed)
np.random.seed(args.seed)
cudnn.deterministic = True
# SET UP FOR DISTRIBUTED TRAINING
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
args.rank = args.rank * ngpus_per_node + gpu # compute global rank
# set distributed group:
dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
world_size=args.world_size, rank=args.rank)
# SET save_path and logger
save_path = os.path.join(args.save_dir, args.save_name)
logger_level = "WARNING"
tb_log = None
if args.rank % ngpus_per_node == 0:
tb_log = TBLog(save_path, 'tensorboard', use_tensorboard=args.use_tensorboard)
logger_level = "INFO"
logger = get_logger(args.save_name, save_path, logger_level)
logger.warning(f"USE GPU: {args.gpu} for training")
# SET flexmatch: class flexmatch in models.flexmatch
args.bn_momentum = 1.0 - 0.999
if 'imagenet' in args.dataset.lower():
_net_builder = net_builder('ResNet50', False, None, is_remix=False)
else:
_net_builder = net_builder(args.net,
args.net_from_name,
{'first_stride': 2 if 'stl' in args.dataset else 1,
'depth': args.depth,
'widen_factor': args.widen_factor,
'leaky_slope': args.leaky_slope,
'bn_momentum': args.bn_momentum,
'dropRate': args.dropout,
'use_embed': False,
'is_remix': False},
)
model = FlexMatch(_net_builder,
args.num_classes,
args.ema_m,
args.T,
args.p_cutoff,
args.ulb_loss_ratio,
args.hard_label,
num_eval_iter=args.num_eval_iter,
tb_log=tb_log,
logger=logger)
logger.info(f'Number of Trainable Params: {count_parameters(model.model)}')
# SET Optimizer & LR Scheduler
## construct SGD and cosine lr scheduler
optimizer = get_optimizer(model.model, args.optim, args.lr, args.momentum, args.weight_decay)
scheduler = get_cosine_schedule_with_warmup(optimizer,
args.num_train_iter,
num_warmup_steps=args.num_train_iter * 0)
## set SGD and cosine lr on flexmatch
model.set_optimizer(optimizer, scheduler)
# SET Devices for (Distributed) DataParallel
if not torch.cuda.is_available():
raise Exception('ONLY GPU TRAINING IS SUPPORTED')
elif args.distributed:
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
'''
batch_size: batch_size per node -> batch_size per gpu
workers: workers per node -> workers per gpu
'''
args.batch_size = int(args.batch_size / ngpus_per_node)
model.model.cuda(args.gpu)
model.model = nn.SyncBatchNorm.convert_sync_batchnorm(model.model)
model.model = torch.nn.parallel.DistributedDataParallel(model.model,
device_ids=[args.gpu],
broadcast_buffers=False,
find_unused_parameters=True)
else:
# if arg.gpu is None, DDP will divide and allocate batch_size
# to all available GPUs if device_ids are not set.
model.cuda()
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.model = model.model.cuda(args.gpu)
else:
model.model = torch.nn.DataParallel(model.model).cuda()
import copy
model.ema_model = copy.deepcopy(model.model)
logger.info(f"model_arch: {model}")
logger.info(f"Arguments: {args}")
cudnn.benchmark = True
if args.rank != 0 and args.distributed:
torch.distributed.barrier()
# Construct Dataset & DataLoader
if args.dataset.lower() != "imagenet":
if args.num_labels == 10 and args.dataset == 'cifar10':
fixmatch_index = [
[7408, 8148, 9850, 10361, 33949, 36506, 37018, 45044, 46443, 47447],
[5022, 8193, 8902, 9601, 25226, 26223, 34089, 35186, 40595, 48024],
[7510, 13186, 14043, 21305, 22805, 31288, 34508, 40470, 41493, 45506],
[9915, 9978, 16631, 19915, 28008, 35314, 35801, 36149, 39215, 42557],
[6695, 14891, 19726, 22715, 23999, 34230, 46511, 47457, 49181, 49397],
[12830, 20293, 26835, 30517, 30898, 31061, 43693, 46501, 47310, 48517],
[1156, 11501, 19974, 21963, 32103, 42189, 46789, 47690, 48229, 48675],
[4255, 6446, 8580, 11759, 12598, 29349, 29433, 33759, 35345, 38639]]
index = fixmatch_index[-args.seed - 1]
print("10 labels for cifar10")
else:
index = None
train_dset = SSL_Dataset(args, alg='flexmatch', name=args.dataset, train=True,
num_classes=args.num_classes, data_dir=args.data_dir)
lb_dset, ulb_dset = train_dset.get_ssl_dset(args.num_labels, index=index)
_eval_dset = SSL_Dataset(args, alg='flexmatch', name=args.dataset, train=False,
num_classes=args.num_classes, data_dir=args.data_dir)
eval_dset = _eval_dset.get_dset()
else:
image_loader = ImageNetLoader(root_path=args.data_dir, num_labels=args.num_labels,
num_class=args.num_classes)
lb_dset = image_loader.get_lb_train_data()
ulb_dset = image_loader.get_ulb_train_data()
eval_dset = image_loader.get_lb_test_data()
if args.rank == 0 and args.distributed:
torch.distributed.barrier()
loader_dict = {}
dset_dict = {'train_lb': lb_dset, 'train_ulb': ulb_dset, 'eval': eval_dset}
loader_dict['train_lb'] = get_data_loader(dset_dict['train_lb'],
args.batch_size,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=args.num_workers,
distributed=args.distributed)
loader_dict['train_ulb'] = get_data_loader(dset_dict['train_ulb'],
args.batch_size * args.uratio,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=4 * args.num_workers,
distributed=args.distributed)
loader_dict['eval'] = get_data_loader(dset_dict['eval'],
args.eval_batch_size,
num_workers=args.num_workers,
drop_last=False)
## set DataLoader and ulb_dset on FlexMatch
model.set_data_loader(loader_dict)
model.set_dset(ulb_dset)
# If args.resume, load checkpoints from args.load_path
if args.resume:
model.load_model(args.load_path)
# START TRAINING of flexmatch
trainer = model.train
for epoch in range(args.epoch):
trainer(args, logger=logger)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
model.save_model('latest_model.pth', save_path)
logging.warning(f"GPU {args.rank} training is FINISHED") | main_worker is conducted on each GPU. |
157,479 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.flexmatch.flexmatch import FlexMatch
from datasets.ssl_dataset import SSL_Dataset, ImageNetLoader
from datasets.data_utils import get_data_loader
def str2bool(v):
if isinstance(v, bool):
return v
if v.lower() in ('yes', 'true', 't', 'y', '1'):
return True
elif v.lower() in ('no', 'false', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError('Boolean value expected.') | null |
157,480 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.meanteacher.meanteacher import MeanTeacher
from datasets.ssl_dataset import SSL_Dataset
from datasets.data_utils import get_data_loader
def net_builder(net_name, from_name: bool, net_conf=None, is_remix=False):
"""
return **class** of backbone network (not instance).
Args
net_name: 'WideResNet' or network names in torchvision.models
from_name: If True, net_buidler takes models in torch.vision models. Then, net_conf is ignored.
net_conf: When from_name is False, net_conf is the configuration of backbone network (now, only WRN is supported).
"""
if from_name:
import torchvision.models as models
model_name_list = sorted(name for name in models.__dict__
if name.islower() and not name.startswith("__")
and callable(models.__dict__[name]))
if net_name not in model_name_list:
assert Exception(f"[!] Networks\' Name is wrong, check net config, \
expected: {model_name_list} \
received: {net_name}")
else:
return models.__dict__[net_name]
else:
if net_name == 'WideResNet':
import models.nets.wrn as net
builder = getattr(net, 'build_WideResNet')()
elif net_name == 'WideResNetVar':
import models.nets.wrn_var as net
builder = getattr(net, 'build_WideResNetVar')()
elif net_name == 'ResNet50':
import models.nets.resnet50 as net
builder = getattr(net, 'build_ResNet50')(is_remix)
else:
assert Exception("Not Implemented Error")
if net_name != 'ResNet50':
setattr_cls_from_kwargs(builder, net_conf)
return builder.build
def get_logger(name, save_path=None, level='INFO'):
logger = logging.getLogger(name)
logger.setLevel(getattr(logging, level))
log_format = logging.Formatter('[%(asctime)s %(levelname)s] %(message)s')
streamHandler = logging.StreamHandler()
streamHandler.setFormatter(log_format)
logger.addHandler(streamHandler)
if not save_path is None:
os.makedirs(save_path, exist_ok=True)
fileHandler = logging.FileHandler(os.path.join(save_path, 'log.txt'))
fileHandler.setFormatter(log_format)
logger.addHandler(fileHandler)
return logger
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
class TBLog:
"""
Construc tensorboard writer (self.writer).
The tensorboard is saved at os.path.join(tb_dir, file_name).
"""
def __init__(self, tb_dir, file_name, use_tensorboard=False):
self.tb_dir = tb_dir
self.use_tensorboard = use_tensorboard
if self.use_tensorboard:
self.writer = SummaryWriter(os.path.join(self.tb_dir, file_name))
else:
self.writer = CustomWriter(os.path.join(self.tb_dir, file_name))
def update(self, tb_dict, it, suffix=None, mode="train"):
"""
Args
tb_dict: contains scalar values for updating tensorboard
it: contains information of iteration (int).
suffix: If not None, the update key has the suffix.
"""
if suffix is None:
suffix = ''
if self.use_tensorboard:
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value, it)
else:
self.writer.set_epoch(it, mode)
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value)
self.writer.plot_stats()
self.writer.dump_stats()
def get_optimizer(net, optim_name='SGD', lr=0.1, momentum=0.9, weight_decay=0, nesterov=True, bn_wd_skip=True):
'''
return optimizer (name) in torch.optim.
If bn_wd_skip, the optimizer does not apply
weight decay regularization on parameters in batch normalization.
'''
decay = []
no_decay = []
for name, param in net.named_parameters():
if ('bn' in name or 'bias' in name) and bn_wd_skip:
no_decay.append(param)
else:
decay.append(param)
per_param_args = [{'params': decay},
{'params': no_decay, 'weight_decay': 0.0}]
if optim_name == 'SGD':
optimizer = torch.optim.SGD(per_param_args, lr=lr, momentum=momentum, weight_decay=weight_decay,
nesterov=nesterov)
elif optim_name == 'AdamW':
optimizer = torch.optim.AdamW(per_param_args, lr=lr, weight_decay=weight_decay)
return optimizer
def get_cosine_schedule_with_warmup(optimizer,
num_training_steps,
num_cycles=7. / 16.,
num_warmup_steps=0,
last_epoch=-1):
'''
Get cosine scheduler (LambdaLR).
if warmup is needed, set num_warmup_steps (int) > 0.
'''
def _lr_lambda(current_step):
'''
_lr_lambda returns a multiplicative factor given an interger parameter epochs.
Decaying criteria: last_epoch
'''
if current_step < num_warmup_steps:
_lr = float(current_step) / float(max(1, num_warmup_steps))
else:
num_cos_steps = float(current_step - num_warmup_steps)
num_cos_steps = num_cos_steps / float(max(1, num_training_steps - num_warmup_steps))
_lr = max(0.0, math.cos(math.pi * num_cycles * num_cos_steps))
return _lr
return LambdaLR(optimizer, _lr_lambda, last_epoch)
class MeanTeacher:
def __init__(self, net_builder, num_classes, ema_m, lambda_u, \
it=0, num_eval_iter=1000, tb_log=None, logger=None):
"""
class Fixmatch contains setter of data_loader, optimizer, and model update methods.
Args:
net_builder: backbone network class (see net_builder in utils.py)
num_classes: # of label classes
ema_m: momentum of exponential moving average for eval_model
lambda_u: ratio of unsupervised loss to supervised loss
it: initial iteration count
num_eval_iter: freqeuncy of iteration (after 500,000 iters)
tb_log: tensorboard writer (see train_utils.py)
logger: logger (see utils.py)
"""
super(MeanTeacher, self).__init__()
# momentum update param
self.loader = {}
self.num_classes = num_classes
self.ema_m = ema_m
# create the encoders
# network is builded only by num_classes,
# other configs are covered in main.py
self.model = net_builder(num_classes=num_classes)
self.ema_model = deepcopy(self.model)
self.num_eval_iter = num_eval_iter
self.lambda_u = lambda_u
self.tb_log = tb_log
self.optimizer = None
self.scheduler = None
self.it = 0
self.logger = logger
self.print_fn = print if logger is None else logger.info
self.bn_controller = Bn_Controller()
def set_data_loader(self, loader_dict):
self.loader_dict = loader_dict
self.print_fn(f'[!] data loader keys: {self.loader_dict.keys()}')
def set_optimizer(self, optimizer, scheduler=None):
self.optimizer = optimizer
self.scheduler = scheduler
def train(self, args, logger=None):
ngpus_per_node = torch.cuda.device_count()
# lb: labeled, ulb: unlabeled
self.model.train()
# EMA
self.ema = EMA(self.model, self.ema_m)
self.ema.register()
if args.resume == True:
self.ema.load(self.ema_model)
# for gpu profiling
start_batch = torch.cuda.Event(enable_timing=True)
end_batch = torch.cuda.Event(enable_timing=True)
start_run = torch.cuda.Event(enable_timing=True)
end_run = torch.cuda.Event(enable_timing=True)
start_batch.record()
best_eval_acc, best_it = 0.0, 0
scaler = GradScaler()
amp_cm = autocast if args.amp else contextlib.nullcontext
# eval for once to verify if the checkpoint is loaded correctly
if args.resume == True:
eval_dict = self.evaluate(args=args)
print(eval_dict)
for (_, x_lb, y_lb), (_, x_ulb_w1, x_ulb_w2) in zip(self.loader_dict['train_lb'],
self.loader_dict['train_ulb']):
# prevent the training iterations exceed args.num_train_iter
if self.it > args.num_train_iter:
break
end_batch.record()
torch.cuda.synchronize()
start_run.record()
# to CUDA
x_lb, x_ulb_w1, x_ulb_w2 = x_lb.cuda(args.gpu), x_ulb_w1.cuda(args.gpu), x_ulb_w2.cuda(args.gpu)
y_lb = y_lb.cuda(args.gpu)
# inference and calculate sup/unsup losses
with amp_cm():
logits_x_lb = self.model(x_lb)
self.bn_controller.freeze_bn(self.model)
logits_x_ulb_w2 = self.model(x_ulb_w2)
self.bn_controller.unfreeze_bn(self.model)
self.ema.apply_shadow()
with torch.no_grad():
self.bn_controller.freeze_bn(self.model)
logits_x_ulb_w1 = self.model(x_ulb_w1)
self.bn_controller.unfreeze_bn(self.model)
self.ema.restore()
sup_loss = ce_loss(logits_x_lb, y_lb, reduction='mean') # CE_loss for labeled data
warm_up = float(np.clip((self.it) / (args.unsup_warm_up * args.num_train_iter), 0., 1.))
unsup_loss = consistency_loss(logits_x_ulb_w2, logits_x_ulb_w1) # MSE loss for unlabeled data
total_loss = sup_loss + warm_up * self.lambda_u * unsup_loss
# parameter updates
if args.amp:
scaler.scale(total_loss).backward()
if (args.clip > 0):
scaler.unscale_(self.optimizer)
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
scaler.step(self.optimizer)
scaler.update()
else:
total_loss.backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
self.optimizer.step()
self.scheduler.step()
self.ema.update()
self.model.zero_grad()
end_run.record()
torch.cuda.synchronize()
# tensorboard_dict update
tb_dict = {}
tb_dict['train/sup_loss'] = sup_loss.detach()
tb_dict['train/unsup_loss'] = unsup_loss.detach()
tb_dict['train/total_loss'] = total_loss.detach()
tb_dict['lr'] = self.optimizer.param_groups[0]['lr']
tb_dict['train/prefecth_time'] = start_batch.elapsed_time(end_batch) / 1000.
tb_dict['train/run_time'] = start_run.elapsed_time(end_run) / 1000.
# save model for each 10K steps and best model for each 1K steps
if self.it % 10000 == 0:
save_path = os.path.join(args.save_dir, args.save_name)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
self.save_model('latest_model.pth', save_path)
if self.it % self.num_eval_iter == 0:
eval_dict = self.evaluate(args=args)
tb_dict.update(eval_dict)
save_path = os.path.join(args.save_dir, args.save_name)
if tb_dict['eval/top-1-acc'] > best_eval_acc:
best_eval_acc = tb_dict['eval/top-1-acc']
best_it = self.it
self.print_fn(
f"{self.it} iteration, USE_EMA: {self.ema_m != 0}, {tb_dict}, BEST_EVAL_ACC: {best_eval_acc}, at {best_it} iters")
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
if self.it == best_it:
self.save_model('model_best.pth', save_path)
if not self.tb_log is None:
self.tb_log.update(tb_dict, self.it)
self.it += 1
del tb_dict
start_batch.record()
if self.it > 0.8 * args.num_train_iter:
self.num_eval_iter = 1000
eval_dict = self.evaluate(args=args)
eval_dict.update({'eval/best_acc': best_eval_acc, 'eval/best_it': best_it})
return eval_dict
def evaluate(self, eval_loader=None, args=None):
self.model.eval()
self.ema.apply_shadow()
if eval_loader is None:
eval_loader = self.loader_dict['eval']
total_loss = 0.0
total_num = 0.0
y_true = []
y_pred = []
y_logits = []
for _, x, y in eval_loader:
x, y = x.cuda(args.gpu), y.cuda(args.gpu)
num_batch = x.shape[0]
total_num += num_batch
logits = self.model(x)
loss = F.cross_entropy(logits, y, reduction='mean')
y_true.extend(y.cpu().tolist())
y_pred.extend(torch.max(logits, dim=-1)[1].cpu().tolist())
y_logits.extend(torch.softmax(logits, dim=-1).cpu().tolist())
total_loss += loss.detach() * num_batch
top1 = accuracy_score(y_true, y_pred)
top5 = top_k_accuracy_score(y_true, y_logits, k=5)
cf_mat = confusion_matrix(y_true, y_pred, normalize='true')
self.print_fn('confusion matrix:\n' + np.array_str(cf_mat))
self.ema.restore()
self.model.train()
return {'eval/loss': total_loss / total_num, 'eval/top-1-acc': top1, 'eval/top-5-acc': top5}
def save_model(self, save_name, save_path):
if self.it < 1000000:
return
save_filename = os.path.join(save_path, save_name)
# copy EMA parameters to ema_model for saving with model as temp
self.model.eval()
self.ema.apply_shadow()
ema_model = deepcopy(self.model)
self.ema.restore()
self.model.train()
torch.save({'model': self.model.state_dict(),
'optimizer': self.optimizer.state_dict(),
'scheduler': self.scheduler.state_dict(),
'it': self.it + 1,
'ema_model': ema_model.state_dict()},
save_filename)
self.print_fn(f"model saved: {save_filename}")
def load_model(self, load_path):
checkpoint = torch.load(load_path)
self.model.load_state_dict(checkpoint['model'])
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.scheduler.load_state_dict(checkpoint['scheduler'])
self.it = checkpoint['it']
self.ema_model.load_state_dict(checkpoint['ema_model'])
self.print_fn('model loaded')
# Abandoned in Meanteacher
def interleave_offsets(self, batch, nu):
groups = [batch // (nu + 1)] * (nu + 1)
for x in range(batch - sum(groups)):
groups[-x - 1] += 1
offsets = [0]
for g in groups:
offsets.append(offsets[-1] + g)
assert offsets[-1] == batch
return offsets
def interleave(self, xy, batch):
nu = len(xy) - 1
offsets = self.interleave_offsets(batch, nu)
xy = [[v[offsets[p]:offsets[p + 1]] for p in range(nu + 1)] for v in xy]
for i in range(1, nu + 1):
xy[0][i], xy[i][i] = xy[i][i], xy[0][i]
return [torch.cat(v, dim=0) for v in xy]
class SSL_Dataset:
"""
SSL_Dataset class gets dataset from torchvision.datasets,
separates labeled and unlabeled data,
and return BasicDataset: torch.utils.data.Dataset (see datasets.dataset.py)
"""
def __init__(self,
args,
alg='fixmatch',
name='cifar10',
train=True,
num_classes=10,
data_dir='./data'):
"""
Args
alg: SSL algorithms
name: name of dataset in torchvision.datasets (cifar10, cifar100, svhn, stl10)
train: True means the dataset is training dataset (default=True)
num_classes: number of label classes
data_dir: path of directory, where data is downloaed or stored.
"""
self.args = args
self.alg = alg
self.name = name
self.train = train
self.num_classes = num_classes
self.data_dir = data_dir
crop_size = 96 if self.name.upper() == 'STL10' else 224 if self.name.upper() == 'IMAGENET' else 32
self.transform = get_transform(mean[name], std[name], crop_size, train)
def get_data(self, svhn_extra=True):
"""
get_data returns data (images) and targets (labels)
shape of data: B, H, W, C
shape of labels: B,
"""
dset = getattr(torchvision.datasets, self.name.upper())
if 'CIFAR' in self.name.upper():
dset = dset(self.data_dir, train=self.train, download=True)
data, targets = dset.data, dset.targets
return data, targets
elif self.name.upper() == 'SVHN':
if self.train:
if svhn_extra: # train+extra
dset_base = dset(self.data_dir, split='train', download=True)
data_b, targets_b = dset_base.data.transpose([0, 2, 3, 1]), dset_base.labels
dset_extra = dset(self.data_dir, split='extra', download=True)
data_e, targets_e = dset_extra.data.transpose([0, 2, 3, 1]), dset_extra.labels
data = np.concatenate([data_b, data_e])
targets = np.concatenate([targets_b, targets_e])
del data_b, data_e
del targets_b, targets_e
else: # train_only
dset = dset(self.data_dir, split='train', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
else: # test
dset = dset(self.data_dir, split='test', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
return data, targets
elif self.name.upper() == 'STL10':
split = 'train' if self.train else 'test'
dset_lb = dset(self.data_dir, split=split, download=True)
dset_ulb = dset(self.data_dir, split='unlabeled', download=True)
data, targets = dset_lb.data.transpose([0, 2, 3, 1]), dset_lb.labels.astype(np.int64)
ulb_data = dset_ulb.data.transpose([0, 2, 3, 1])
return data, targets, ulb_data
def get_dset(self, is_ulb=False,
strong_transform=None, onehot=False):
"""
get_dset returns class BasicDataset, containing the returns of get_data.
Args
is_ulb: If True, returned dataset generates a pair of weak and strong augmented images.
strong_transform: list of strong_transform (augmentation) if use_strong_transform is True。
onehot: If True, the label is not integer, but one-hot vector.
"""
if self.name.upper() == 'STL10':
data, targets, _ = self.get_data()
else:
data, targets = self.get_data()
num_classes = self.num_classes
transform = self.transform
return BasicDataset(self.alg, data, targets, num_classes, transform,
is_ulb, strong_transform, onehot)
def get_ssl_dset(self, num_labels, index=None, include_lb_to_ulb=True,
strong_transform=None, onehot=False):
"""
get_ssl_dset split training samples into labeled and unlabeled samples.
The labeled data is balanced samples over classes.
Args:
num_labels: number of labeled data.
index: If index of np.array is given, labeled data is not randomly sampled, but use index for sampling.
include_lb_to_ulb: If True, consistency regularization is also computed for the labeled data.
strong_transform: list of strong transform (RandAugment in FixMatch)
onehot: If True, the target is converted into onehot vector.
Returns:
BasicDataset (for labeled data), BasicDataset (for unlabeld data)
"""
# Supervised top line using all data as labeled data.
if self.alg == 'fullysupervised':
lb_data, lb_targets = self.get_data()
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
return lb_dset, None
if self.name.upper() == 'STL10':
lb_data, lb_targets, ulb_data = self.get_data()
if include_lb_to_ulb:
ulb_data = np.concatenate([ulb_data, lb_data], axis=0)
lb_data, lb_targets, _ = sample_labeled_data(self.args, lb_data, lb_targets, num_labels, self.num_classes)
ulb_targets = None
else:
data, targets = self.get_data()
lb_data, lb_targets, ulb_data, ulb_targets = split_ssl_data(self.args, data, targets,
num_labels, self.num_classes,
index, include_lb_to_ulb)
# output the distribution of labeled data for remixmatch
count = [0 for _ in range(self.num_classes)]
for c in lb_targets:
count[c] += 1
dist = np.array(count, dtype=float)
dist = dist / dist.sum()
dist = dist.tolist()
out = {"distribution": dist}
output_file = r"./data_statistics/"
output_path = output_file + str(self.name) + '_' + str(num_labels) + '.json'
if not os.path.exists(output_file):
os.makedirs(output_file, exist_ok=True)
with open(output_path, 'w') as w:
json.dump(out, w)
# print(Counter(ulb_targets.tolist()))
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
ulb_dset = BasicDataset(self.alg, ulb_data, ulb_targets, self.num_classes,
self.transform, True, strong_transform, onehot)
# print(lb_data.shape)
# print(ulb_data.shape)
return lb_dset, ulb_dset
def get_data_loader(dset,
batch_size=None,
shuffle=False,
num_workers=4,
pin_memory=False,
data_sampler=None,
replacement=True,
num_epochs=None,
num_iters=None,
generator=None,
drop_last=True,
distributed=False):
"""
get_data_loader returns torch.utils.data.DataLoader for a Dataset.
All arguments are comparable with those of pytorch DataLoader.
However, if distributed, DistributedProxySampler, which is a wrapper of data_sampler, is used.
Args
num_epochs: total batch -> (# of batches in dset) * num_epochs
num_iters: total batch -> num_iters
"""
assert batch_size is not None
if data_sampler is None:
return DataLoader(dset, batch_size=batch_size, shuffle=shuffle,
num_workers=num_workers, pin_memory=pin_memory)
else:
if isinstance(data_sampler, str):
data_sampler = get_sampler_by_name(data_sampler)
if distributed:
assert dist.is_available()
num_replicas = dist.get_world_size()
else:
num_replicas = 1
if (num_epochs is not None) and (num_iters is None):
num_samples = len(dset) * num_epochs
elif (num_epochs is None) and (num_iters is not None):
num_samples = batch_size * num_iters * num_replicas
else:
num_samples = len(dset)
if data_sampler.__name__ == 'RandomSampler':
data_sampler = data_sampler(dset, replacement, num_samples, generator)
else:
raise RuntimeError(f"{data_sampler.__name__} is not implemented.")
if distributed:
'''
Different with DistributedSampler,
the DistribuedProxySampler does not shuffle the data (just wrapper for dist).
'''
data_sampler = DistributedProxySampler(data_sampler)
batch_sampler = BatchSampler(data_sampler, batch_size, drop_last)
return DataLoader(dset, batch_sampler=batch_sampler,
num_workers=num_workers, pin_memory=pin_memory)
The provided code snippet includes necessary dependencies for implementing the `main_worker` function. Write a Python function `def main_worker(gpu, ngpus_per_node, args)` to solve the following problem:
main_worker is conducted on each GPU.
Here is the function:
def main_worker(gpu, ngpus_per_node, args):
'''
main_worker is conducted on each GPU.
'''
global best_acc1
args.gpu = gpu
# random seed has to be set for the syncronization of labeled data sampling in each process.
assert args.seed is not None
random.seed(args.seed)
torch.manual_seed(args.seed)
np.random.seed(args.seed)
cudnn.deterministic = True
# SET UP FOR DISTRIBUTED TRAINING
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
args.rank = args.rank * ngpus_per_node + gpu # compute global rank
# set distributed group:
dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
world_size=args.world_size, rank=args.rank)
# SET save_path and logger
save_path = os.path.join(args.save_dir, args.save_name)
logger_level = "WARNING"
tb_log = None
if args.rank % ngpus_per_node == 0:
tb_log = TBLog(save_path, 'tensorboard', use_tensorboard=args.use_tensorboard)
logger_level = "INFO"
logger = get_logger(args.save_name, save_path, logger_level)
logger.warning(f"USE GPU: {args.gpu} for training")
args.bn_momentum = 1.0 - 0.999
if 'imagenet' in args.dataset.lower():
_net_builder = net_builder('ResNet50', False, None, is_remix=False)
else:
_net_builder = net_builder(args.net,
args.net_from_name,
{'first_stride': 2 if 'stl' in args.dataset else 1,
'depth': args.depth,
'widen_factor': args.widen_factor,
'leaky_slope': args.leaky_slope,
'bn_momentum': args.bn_momentum,
'dropRate': args.dropout,
'use_embed': False,
'is_remix': False},
)
model = MeanTeacher(_net_builder,
args.num_classes,
args.ema_m,
args.ulb_loss_ratio,
num_eval_iter=args.num_eval_iter,
tb_log=tb_log,
logger=logger)
logger.info(f'Number of Trainable Params: {count_parameters(model.model)}')
# SET Optimizer & LR Scheduler
## construct SGD and cosine lr scheduler
optimizer = get_optimizer(model.model, args.optim, args.lr, args.momentum, args.weight_decay)
scheduler = get_cosine_schedule_with_warmup(optimizer,
args.num_train_iter,
num_warmup_steps=args.num_train_iter * 0)
## set SGD and cosine lr on MeanTeacher
model.set_optimizer(optimizer, scheduler)
# SET Devices for (Distributed) DataParallel
if not torch.cuda.is_available():
raise Exception('ONLY GPU TRAINING IS SUPPORTED')
elif args.distributed:
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
'''
batch_size: batch_size per node -> batch_size per gpu
workers: workers per node -> workers per gpu
'''
args.batch_size = int(args.batch_size / ngpus_per_node)
model.model.cuda(args.gpu)
model.model = torch.nn.parallel.DistributedDataParallel(model.model,
device_ids=[args.gpu],
broadcast_buffers=False,
find_unused_parameters=True
)
else:
# if arg.gpu is None, DDP will divide and allocate batch_size
# to all available GPUs if device_ids are not set.
model.cuda()
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.model = model.model.cuda(args.gpu)
else:
model.model = torch.nn.DataParallel(model.model).cuda()
import copy
model.ema_model = copy.deepcopy(model.model)
logger.info(f"model_arch: {model}")
logger.info(f"Arguments: {args}")
cudnn.benchmark = True
if args.rank != 0 and args.distributed:
torch.distributed.barrier()
if args.dataset != "imagenet":
if args.num_labels == 10 and args.dataset == 'cifar10':
fixmatch_index = [
[7408, 8148, 9850, 10361, 33949, 36506, 37018, 45044, 46443, 47447],
[5022, 8193, 8902, 9601, 25226, 26223, 34089, 35186, 40595, 48024],
[7510, 13186, 14043, 21305, 22805, 31288, 34508, 40470, 41493, 45506],
[9915, 9978, 16631, 19915, 28008, 35314, 35801, 36149, 39215, 42557],
[6695, 14891, 19726, 22715, 23999, 34230, 46511, 47457, 49181, 49397],
[12830, 20293, 26835, 30517, 30898, 31061, 43693, 46501, 47310, 48517],
[1156, 11501, 19974, 21963, 32103, 42189, 46789, 47690, 48229, 48675],
[4255, 6446, 8580, 11759, 12598, 29349, 29433, 33759, 35345, 38639]]
index = fixmatch_index[-args.seed - 1]
print("10 labels for cifar10")
else:
index = None
# Construct Dataset & DataLoader
train_dset = SSL_Dataset(args, alg='meanteacher', name=args.dataset, train=True,
num_classes=args.num_classes, data_dir=args.data_dir)
lb_dset, ulb_dset = train_dset.get_ssl_dset(args.num_labels,index=index)
_eval_dset = SSL_Dataset(args, alg='meanteacher', name=args.dataset, train=False,
num_classes=args.num_classes, data_dir=args.data_dir)
eval_dset = _eval_dset.get_dset()
if args.rank == 0 and args.distributed:
torch.distributed.barrier()
loader_dict = {}
dset_dict = {'train_lb': lb_dset, 'train_ulb': ulb_dset, 'eval': eval_dset}
loader_dict['train_lb'] = get_data_loader(dset_dict['train_lb'],
args.batch_size,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=args.num_workers,
distributed=args.distributed)
loader_dict['train_ulb'] = get_data_loader(dset_dict['train_ulb'],
args.batch_size * args.uratio,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=4 * args.num_workers,
distributed=args.distributed)
loader_dict['eval'] = get_data_loader(dset_dict['eval'],
args.eval_batch_size,
num_workers=args.num_workers,
drop_last=False)
## set DataLoader on MeanTeacher
model.set_data_loader(loader_dict)
# If args.resume, load checkpoints from args.load_path
if args.resume:
model.load_model(args.load_path)
# START TRAINING of MeanTeacher
trainer = model.train
for epoch in range(args.epoch):
trainer(args, logger=logger)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
model.save_model('latest_model.pth', save_path)
logging.warning(f"GPU {args.rank} training is FINISHED") | main_worker is conducted on each GPU. |
157,481 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.meanteacher.meanteacher import MeanTeacher
from datasets.ssl_dataset import SSL_Dataset
from datasets.data_utils import get_data_loader
def str2bool(v):
if isinstance(v, bool):
return v
if v.lower() in ('yes', 'true', 't', 'y', '1'):
return True
elif v.lower() in ('no', 'false', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError('Boolean value expected.') | null |
157,482 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.mixmatch.mixmatch import MixMatch
from datasets.ssl_dataset import SSL_Dataset
from datasets.data_utils import get_data_loader
def net_builder(net_name, from_name: bool, net_conf=None, is_remix=False):
"""
return **class** of backbone network (not instance).
Args
net_name: 'WideResNet' or network names in torchvision.models
from_name: If True, net_buidler takes models in torch.vision models. Then, net_conf is ignored.
net_conf: When from_name is False, net_conf is the configuration of backbone network (now, only WRN is supported).
"""
if from_name:
import torchvision.models as models
model_name_list = sorted(name for name in models.__dict__
if name.islower() and not name.startswith("__")
and callable(models.__dict__[name]))
if net_name not in model_name_list:
assert Exception(f"[!] Networks\' Name is wrong, check net config, \
expected: {model_name_list} \
received: {net_name}")
else:
return models.__dict__[net_name]
else:
if net_name == 'WideResNet':
import models.nets.wrn as net
builder = getattr(net, 'build_WideResNet')()
elif net_name == 'WideResNetVar':
import models.nets.wrn_var as net
builder = getattr(net, 'build_WideResNetVar')()
elif net_name == 'ResNet50':
import models.nets.resnet50 as net
builder = getattr(net, 'build_ResNet50')(is_remix)
else:
assert Exception("Not Implemented Error")
if net_name != 'ResNet50':
setattr_cls_from_kwargs(builder, net_conf)
return builder.build
def get_logger(name, save_path=None, level='INFO'):
logger = logging.getLogger(name)
logger.setLevel(getattr(logging, level))
log_format = logging.Formatter('[%(asctime)s %(levelname)s] %(message)s')
streamHandler = logging.StreamHandler()
streamHandler.setFormatter(log_format)
logger.addHandler(streamHandler)
if not save_path is None:
os.makedirs(save_path, exist_ok=True)
fileHandler = logging.FileHandler(os.path.join(save_path, 'log.txt'))
fileHandler.setFormatter(log_format)
logger.addHandler(fileHandler)
return logger
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
class TBLog:
"""
Construc tensorboard writer (self.writer).
The tensorboard is saved at os.path.join(tb_dir, file_name).
"""
def __init__(self, tb_dir, file_name, use_tensorboard=False):
self.tb_dir = tb_dir
self.use_tensorboard = use_tensorboard
if self.use_tensorboard:
self.writer = SummaryWriter(os.path.join(self.tb_dir, file_name))
else:
self.writer = CustomWriter(os.path.join(self.tb_dir, file_name))
def update(self, tb_dict, it, suffix=None, mode="train"):
"""
Args
tb_dict: contains scalar values for updating tensorboard
it: contains information of iteration (int).
suffix: If not None, the update key has the suffix.
"""
if suffix is None:
suffix = ''
if self.use_tensorboard:
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value, it)
else:
self.writer.set_epoch(it, mode)
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value)
self.writer.plot_stats()
self.writer.dump_stats()
def get_optimizer(net, optim_name='SGD', lr=0.1, momentum=0.9, weight_decay=0, nesterov=True, bn_wd_skip=True):
'''
return optimizer (name) in torch.optim.
If bn_wd_skip, the optimizer does not apply
weight decay regularization on parameters in batch normalization.
'''
decay = []
no_decay = []
for name, param in net.named_parameters():
if ('bn' in name or 'bias' in name) and bn_wd_skip:
no_decay.append(param)
else:
decay.append(param)
per_param_args = [{'params': decay},
{'params': no_decay, 'weight_decay': 0.0}]
if optim_name == 'SGD':
optimizer = torch.optim.SGD(per_param_args, lr=lr, momentum=momentum, weight_decay=weight_decay,
nesterov=nesterov)
elif optim_name == 'AdamW':
optimizer = torch.optim.AdamW(per_param_args, lr=lr, weight_decay=weight_decay)
return optimizer
def get_cosine_schedule_with_warmup(optimizer,
num_training_steps,
num_cycles=7. / 16.,
num_warmup_steps=0,
last_epoch=-1):
'''
Get cosine scheduler (LambdaLR).
if warmup is needed, set num_warmup_steps (int) > 0.
'''
def _lr_lambda(current_step):
'''
_lr_lambda returns a multiplicative factor given an interger parameter epochs.
Decaying criteria: last_epoch
'''
if current_step < num_warmup_steps:
_lr = float(current_step) / float(max(1, num_warmup_steps))
else:
num_cos_steps = float(current_step - num_warmup_steps)
num_cos_steps = num_cos_steps / float(max(1, num_training_steps - num_warmup_steps))
_lr = max(0.0, math.cos(math.pi * num_cycles * num_cos_steps))
return _lr
return LambdaLR(optimizer, _lr_lambda, last_epoch)
class MixMatch:
def __init__(self, net_builder, num_classes, ema_m, T, lambda_u, \
t_fn=None, it=0, num_eval_iter=1000, tb_log=None, logger=None):
"""
class Mixmatch contains setter of data_loader, optimizer, and model update methods.
Args:
net_builder: backbone network class (see net_builder in utils.py)
num_classes: # of label classes
ema_m: momentum of exponential moving average for eval_model
T: Temperature scaling parameter for output sharpening (only when hard_label = False)
p_cutoff: confidence cutoff parameters for loss masking
lambda_u: ratio of unsupervised loss to supervised loss
hard_label: If True, consistency regularization use a hard pseudo label.
it: initial iteration count
num_eval_iter: freqeuncy of iteration (after 500,000 iters)
tb_log: tensorboard writer (see train_utils.py)
logger: logger (see utils.py)
"""
super(MixMatch, self).__init__()
# momentum update param
self.loader = {}
self.num_classes = num_classes
self.ema_m = ema_m
# create the encoders
# network is builded only by num_classes,
# other configs are covered in main.py
self.model = net_builder(num_classes=num_classes)
self.ema_model = deepcopy(self.model)
self.num_eval_iter = num_eval_iter
self.t_fn = Get_Scalar(T) # temperature params function
self.lambda_u = lambda_u
self.tb_log = tb_log
self.optimizer = None
self.scheduler = None
self.it = 0
self.logger = logger
self.print_fn = print if logger is None else logger.info
self.bn_controller = Bn_Controller()
def set_data_loader(self, loader_dict):
self.loader_dict = loader_dict
self.print_fn(f'[!] data loader keys: {self.loader_dict.keys()}')
def set_optimizer(self, optimizer, scheduler=None):
self.optimizer = optimizer
self.scheduler = scheduler
def train(self, args, logger=None):
ngpus_per_node = torch.cuda.device_count()
# EMA init
self.model.train()
self.ema = EMA(self.model, self.ema_m)
self.ema.register()
if args.resume == True:
self.ema.load(self.ema_model)
# for gpu profiling
start_batch = torch.cuda.Event(enable_timing=True)
end_batch = torch.cuda.Event(enable_timing=True)
start_run = torch.cuda.Event(enable_timing=True)
end_run = torch.cuda.Event(enable_timing=True)
start_batch.record()
best_eval_acc, best_it = 0.0, 0
scaler = GradScaler()
amp_cm = autocast if args.amp else contextlib.nullcontext
# eval once to verify if the checkpoint is loaded correctly
if args.resume == True:
eval_dict = self.evaluate(args=args)
print(eval_dict)
for (_, x_lb, y_lb), (_, x_ulb_w1, x_ulb_w2) in zip(self.loader_dict['train_lb'],
self.loader_dict['train_ulb']):
# prevent the training iterations exceed args.num_train_iter
if self.it > args.num_train_iter:
break
end_batch.record()
torch.cuda.synchronize()
start_run.record()
num_lb = x_lb.shape[0]
num_ulb = x_ulb_w1.shape[0]
assert num_ulb == x_ulb_w2.shape[0]
x_lb, x_ulb_w1, x_ulb_w2 = x_lb.cuda(args.gpu), x_ulb_w1.cuda(args.gpu), x_ulb_w2.cuda(args.gpu)
y_lb = y_lb.cuda(args.gpu)
# inference and calculate sup/unsup losses
with amp_cm():
with torch.no_grad():
self.bn_controller.freeze_bn(self.model)
logits_x_ulb_w1 = self.model(x_ulb_w1)
logits_x_ulb_w2 = self.model(x_ulb_w2)
self.bn_controller.unfreeze_bn(self.model)
# Temperature sharpening
T = self.t_fn(self.it)
# avg
avg_prob_x_ulb = (torch.softmax(logits_x_ulb_w1, dim=1) + torch.softmax(logits_x_ulb_w2, dim=1)) / 2
avg_prob_x_ulb = (avg_prob_x_ulb / avg_prob_x_ulb.sum(dim=-1, keepdim=True))
# sharpening
sharpen_prob_x_ulb = avg_prob_x_ulb ** (1 / T)
sharpen_prob_x_ulb = (sharpen_prob_x_ulb / sharpen_prob_x_ulb.sum(dim=-1, keepdim=True)).detach()
# Pseudo Label
input_labels = torch.cat(
[one_hot(y_lb, args.num_classes, args.gpu), sharpen_prob_x_ulb, sharpen_prob_x_ulb], dim=0)
# Mix up
inputs = torch.cat([x_lb, x_ulb_w1, x_ulb_w2])
mixed_x, mixed_y, _ = mixup_one_target(inputs, input_labels,
args.gpu,
args.alpha,
is_bias=True)
# Interleave labeled and unlabeled samples between batches to get correct batch norm calculation
mixed_x = list(torch.split(mixed_x, num_lb))
mixed_x = self.interleave(mixed_x, num_lb)
logits = [self.model(mixed_x[0])]
# calculate BN for only the first batch
self.bn_controller.freeze_bn(self.model)
for ipt in mixed_x[1:]:
logits.append(self.model(ipt))
# put interleaved samples back
logits = self.interleave(logits, num_lb)
logits_x = logits[0]
logits_u = torch.cat(logits[1:], dim=0)
self.bn_controller.unfreeze_bn(self.model)
sup_loss = ce_loss(logits_x, mixed_y[:num_lb], use_hard_labels=False)
sup_loss = sup_loss.mean()
unsup_loss = consistency_loss(logits_u, mixed_y[num_lb:])
# set ramp_up for lambda_u
rampup = float(np.clip(self.it / (args.ramp_up * args.num_train_iter), 0.0, 1.0))
lambda_u = self.lambda_u * rampup
total_loss = sup_loss + lambda_u * unsup_loss
# parameter updates
if args.amp:
scaler.scale(total_loss).backward()
if (args.clip > 0):
scaler.unscale_(self.optimizer)
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
scaler.step(self.optimizer)
scaler.update()
else:
total_loss.backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
self.optimizer.step()
self.scheduler.step()
self.ema.update()
self.model.zero_grad()
end_run.record()
torch.cuda.synchronize()
# tensorboard_dict update
tb_dict = {}
tb_dict['train/sup_loss'] = sup_loss.detach()
tb_dict['train/unsup_loss'] = unsup_loss.detach()
tb_dict['train/total_loss'] = total_loss.detach()
tb_dict['lr'] = self.optimizer.param_groups[0]['lr']
tb_dict['train/prefecth_time'] = start_batch.elapsed_time(end_batch) / 1000.
tb_dict['train/run_time'] = start_run.elapsed_time(end_run) / 1000.
# Save model for each 10K steps and best model for each 1K steps
if self.it % 10000 == 0:
save_path = os.path.join(args.save_dir, args.save_name)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
self.save_model('latest_model.pth', save_path)
if self.it % self.num_eval_iter == 0:
eval_dict = self.evaluate(args=args)
tb_dict.update(eval_dict)
save_path = os.path.join(args.save_dir, args.save_name)
if tb_dict['eval/top-1-acc'] > best_eval_acc:
best_eval_acc = tb_dict['eval/top-1-acc']
best_it = self.it
self.print_fn(
f"{self.it} iteration, USE_EMA: {self.ema_m != 0}, {tb_dict}, BEST_EVAL_ACC: {best_eval_acc}, at {best_it} iters")
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
if self.it == best_it:
self.save_model('model_best.pth', save_path)
if not self.tb_log is None:
self.tb_log.update(tb_dict, self.it)
self.it += 1
del tb_dict
start_batch.record()
if self.it > 0.8 * args.num_train_iter:
self.num_eval_iter = 1000
eval_dict = self.evaluate(args=args)
eval_dict.update({'eval/best_acc': best_eval_acc, 'eval/best_it': best_it})
return eval_dict
def evaluate(self, eval_loader=None, args=None):
self.model.eval()
self.ema.apply_shadow()
if eval_loader is None:
eval_loader = self.loader_dict['eval']
total_loss = 0.0
total_num = 0.0
y_true = []
y_pred = []
y_logits = []
for _, x, y in eval_loader:
x, y = x.cuda(args.gpu), y.cuda(args.gpu)
num_batch = x.shape[0]
total_num += num_batch
logits = self.model(x)
loss = F.cross_entropy(logits, y, reduction='mean')
y_true.extend(y.cpu().tolist())
y_pred.extend(torch.max(logits, dim=-1)[1].cpu().tolist())
y_logits.extend(torch.softmax(logits, dim=-1).cpu().tolist())
total_loss += loss.detach() * num_batch
top1 = accuracy_score(y_true, y_pred)
top5 = top_k_accuracy_score(y_true, y_logits, k=5)
cf_mat = confusion_matrix(y_true, y_pred, normalize='true')
self.print_fn('confusion matrix:\n' + np.array_str(cf_mat))
self.ema.restore()
self.model.train()
return {'eval/loss': total_loss / total_num, 'eval/top-1-acc': top1, 'eval/top-5-acc': top5}
def save_model(self, save_name, save_path):
if self.it < 1000000:
return
save_filename = os.path.join(save_path, save_name)
# copy EMA parameters to ema_model for saving with model as temp
self.model.eval()
self.ema.apply_shadow()
ema_model = deepcopy(self.model)
self.ema.restore()
self.model.train()
torch.save({'model': self.model.state_dict(),
'optimizer': self.optimizer.state_dict(),
'scheduler': self.scheduler.state_dict(),
'it': self.it + 1,
'ema_model': ema_model.state_dict()},
save_filename)
self.print_fn(f"model saved: {save_filename}")
def load_model(self, load_path):
checkpoint = torch.load(load_path)
self.model.load_state_dict(checkpoint['model'])
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.scheduler.load_state_dict(checkpoint['scheduler'])
self.it = checkpoint['it']
self.ema_model.load_state_dict(checkpoint['ema_model'])
self.print_fn('model loaded')
def interleave_offsets(self, batch, nu):
groups = [batch // (nu + 1)] * (nu + 1)
for x in range(batch - sum(groups)):
groups[-x - 1] += 1
offsets = [0]
for g in groups:
offsets.append(offsets[-1] + g)
assert offsets[-1] == batch
return offsets
def interleave(self, xy, batch):
nu = len(xy) - 1
offsets = self.interleave_offsets(batch, nu)
xy = [[v[offsets[p]:offsets[p + 1]] for p in range(nu + 1)] for v in xy]
for i in range(1, nu + 1):
xy[0][i], xy[i][i] = xy[i][i], xy[0][i]
return [torch.cat(v, dim=0) for v in xy]
class SSL_Dataset:
"""
SSL_Dataset class gets dataset from torchvision.datasets,
separates labeled and unlabeled data,
and return BasicDataset: torch.utils.data.Dataset (see datasets.dataset.py)
"""
def __init__(self,
args,
alg='fixmatch',
name='cifar10',
train=True,
num_classes=10,
data_dir='./data'):
"""
Args
alg: SSL algorithms
name: name of dataset in torchvision.datasets (cifar10, cifar100, svhn, stl10)
train: True means the dataset is training dataset (default=True)
num_classes: number of label classes
data_dir: path of directory, where data is downloaed or stored.
"""
self.args = args
self.alg = alg
self.name = name
self.train = train
self.num_classes = num_classes
self.data_dir = data_dir
crop_size = 96 if self.name.upper() == 'STL10' else 224 if self.name.upper() == 'IMAGENET' else 32
self.transform = get_transform(mean[name], std[name], crop_size, train)
def get_data(self, svhn_extra=True):
"""
get_data returns data (images) and targets (labels)
shape of data: B, H, W, C
shape of labels: B,
"""
dset = getattr(torchvision.datasets, self.name.upper())
if 'CIFAR' in self.name.upper():
dset = dset(self.data_dir, train=self.train, download=True)
data, targets = dset.data, dset.targets
return data, targets
elif self.name.upper() == 'SVHN':
if self.train:
if svhn_extra: # train+extra
dset_base = dset(self.data_dir, split='train', download=True)
data_b, targets_b = dset_base.data.transpose([0, 2, 3, 1]), dset_base.labels
dset_extra = dset(self.data_dir, split='extra', download=True)
data_e, targets_e = dset_extra.data.transpose([0, 2, 3, 1]), dset_extra.labels
data = np.concatenate([data_b, data_e])
targets = np.concatenate([targets_b, targets_e])
del data_b, data_e
del targets_b, targets_e
else: # train_only
dset = dset(self.data_dir, split='train', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
else: # test
dset = dset(self.data_dir, split='test', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
return data, targets
elif self.name.upper() == 'STL10':
split = 'train' if self.train else 'test'
dset_lb = dset(self.data_dir, split=split, download=True)
dset_ulb = dset(self.data_dir, split='unlabeled', download=True)
data, targets = dset_lb.data.transpose([0, 2, 3, 1]), dset_lb.labels.astype(np.int64)
ulb_data = dset_ulb.data.transpose([0, 2, 3, 1])
return data, targets, ulb_data
def get_dset(self, is_ulb=False,
strong_transform=None, onehot=False):
"""
get_dset returns class BasicDataset, containing the returns of get_data.
Args
is_ulb: If True, returned dataset generates a pair of weak and strong augmented images.
strong_transform: list of strong_transform (augmentation) if use_strong_transform is True。
onehot: If True, the label is not integer, but one-hot vector.
"""
if self.name.upper() == 'STL10':
data, targets, _ = self.get_data()
else:
data, targets = self.get_data()
num_classes = self.num_classes
transform = self.transform
return BasicDataset(self.alg, data, targets, num_classes, transform,
is_ulb, strong_transform, onehot)
def get_ssl_dset(self, num_labels, index=None, include_lb_to_ulb=True,
strong_transform=None, onehot=False):
"""
get_ssl_dset split training samples into labeled and unlabeled samples.
The labeled data is balanced samples over classes.
Args:
num_labels: number of labeled data.
index: If index of np.array is given, labeled data is not randomly sampled, but use index for sampling.
include_lb_to_ulb: If True, consistency regularization is also computed for the labeled data.
strong_transform: list of strong transform (RandAugment in FixMatch)
onehot: If True, the target is converted into onehot vector.
Returns:
BasicDataset (for labeled data), BasicDataset (for unlabeld data)
"""
# Supervised top line using all data as labeled data.
if self.alg == 'fullysupervised':
lb_data, lb_targets = self.get_data()
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
return lb_dset, None
if self.name.upper() == 'STL10':
lb_data, lb_targets, ulb_data = self.get_data()
if include_lb_to_ulb:
ulb_data = np.concatenate([ulb_data, lb_data], axis=0)
lb_data, lb_targets, _ = sample_labeled_data(self.args, lb_data, lb_targets, num_labels, self.num_classes)
ulb_targets = None
else:
data, targets = self.get_data()
lb_data, lb_targets, ulb_data, ulb_targets = split_ssl_data(self.args, data, targets,
num_labels, self.num_classes,
index, include_lb_to_ulb)
# output the distribution of labeled data for remixmatch
count = [0 for _ in range(self.num_classes)]
for c in lb_targets:
count[c] += 1
dist = np.array(count, dtype=float)
dist = dist / dist.sum()
dist = dist.tolist()
out = {"distribution": dist}
output_file = r"./data_statistics/"
output_path = output_file + str(self.name) + '_' + str(num_labels) + '.json'
if not os.path.exists(output_file):
os.makedirs(output_file, exist_ok=True)
with open(output_path, 'w') as w:
json.dump(out, w)
# print(Counter(ulb_targets.tolist()))
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
ulb_dset = BasicDataset(self.alg, ulb_data, ulb_targets, self.num_classes,
self.transform, True, strong_transform, onehot)
# print(lb_data.shape)
# print(ulb_data.shape)
return lb_dset, ulb_dset
def get_data_loader(dset,
batch_size=None,
shuffle=False,
num_workers=4,
pin_memory=False,
data_sampler=None,
replacement=True,
num_epochs=None,
num_iters=None,
generator=None,
drop_last=True,
distributed=False):
"""
get_data_loader returns torch.utils.data.DataLoader for a Dataset.
All arguments are comparable with those of pytorch DataLoader.
However, if distributed, DistributedProxySampler, which is a wrapper of data_sampler, is used.
Args
num_epochs: total batch -> (# of batches in dset) * num_epochs
num_iters: total batch -> num_iters
"""
assert batch_size is not None
if data_sampler is None:
return DataLoader(dset, batch_size=batch_size, shuffle=shuffle,
num_workers=num_workers, pin_memory=pin_memory)
else:
if isinstance(data_sampler, str):
data_sampler = get_sampler_by_name(data_sampler)
if distributed:
assert dist.is_available()
num_replicas = dist.get_world_size()
else:
num_replicas = 1
if (num_epochs is not None) and (num_iters is None):
num_samples = len(dset) * num_epochs
elif (num_epochs is None) and (num_iters is not None):
num_samples = batch_size * num_iters * num_replicas
else:
num_samples = len(dset)
if data_sampler.__name__ == 'RandomSampler':
data_sampler = data_sampler(dset, replacement, num_samples, generator)
else:
raise RuntimeError(f"{data_sampler.__name__} is not implemented.")
if distributed:
'''
Different with DistributedSampler,
the DistribuedProxySampler does not shuffle the data (just wrapper for dist).
'''
data_sampler = DistributedProxySampler(data_sampler)
batch_sampler = BatchSampler(data_sampler, batch_size, drop_last)
return DataLoader(dset, batch_sampler=batch_sampler,
num_workers=num_workers, pin_memory=pin_memory)
The provided code snippet includes necessary dependencies for implementing the `main_worker` function. Write a Python function `def main_worker(gpu, ngpus_per_node, args)` to solve the following problem:
main_worker is conducted on each GPU.
Here is the function:
def main_worker(gpu, ngpus_per_node, args):
'''
main_worker is conducted on each GPU.
'''
global best_acc1
args.gpu = gpu
# random seed has to be set for the syncronization of labeled data sampling in each process.
assert args.seed is not None
random.seed(args.seed)
torch.manual_seed(args.seed)
np.random.seed(args.seed)
cudnn.deterministic = True
# SET UP FOR DISTRIBUTED TRAINING
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
args.rank = args.rank * ngpus_per_node + gpu # compute global rank
# set distributed group:
dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
world_size=args.world_size, rank=args.rank)
# SET save_path and logger
save_path = os.path.join(args.save_dir, args.save_name)
logger_level = "WARNING"
tb_log = None
if args.rank % ngpus_per_node == 0:
tb_log = TBLog(save_path, 'tensorboard', use_tensorboard=args.use_tensorboard)
logger_level = "INFO"
logger = get_logger(args.save_name, save_path, logger_level)
logger.warning(f"USE GPU: {args.gpu} for training")
# SET MixMatch
args.bn_momentum = 1.0 - 0.999
if 'imagenet' in args.dataset.lower():
_net_builder = net_builder('ResNet50', False, None, is_remix=False)
else:
_net_builder = net_builder(args.net,
args.net_from_name,
{'first_stride': 2 if 'stl' in args.dataset else 1,
'depth': args.depth,
'widen_factor': args.widen_factor,
'leaky_slope': args.leaky_slope,
'bn_momentum': args.bn_momentum,
'dropRate': args.dropout,
'use_embed': False,
'is_remix': False},
)
model = MixMatch(_net_builder,
args.num_classes,
args.ema_m,
args.T,
args.ulb_loss_ratio,
num_eval_iter=args.num_eval_iter,
tb_log=tb_log,
logger=logger)
logger.info(f'Number of Trainable Params: {count_parameters(model.model)}')
# SET Optimizer & LR Scheduler
## construct SGD and cosine lr scheduler
optimizer = get_optimizer(model.model, args.optim, args.lr, args.momentum, args.weight_decay)
scheduler = get_cosine_schedule_with_warmup(optimizer,
args.num_train_iter,
num_warmup_steps=args.num_train_iter * 0)
## set SGD and cosine lr on MixMatch
model.set_optimizer(optimizer, scheduler)
# SET Devices for (Distributed) DataParallel
if not torch.cuda.is_available():
raise Exception('ONLY GPU TRAINING IS SUPPORTED')
elif args.distributed:
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
'''
batch_size: batch_size per node -> batch_size per gpu
workers: workers per node -> workers per gpu
'''
args.batch_size = int(args.batch_size / ngpus_per_node)
model.model.cuda(args.gpu)
model.model = torch.nn.parallel.DistributedDataParallel(model.model,
device_ids=[args.gpu],
broadcast_buffers=False,
find_unused_parameters=True)
else:
# if arg.gpu is None, DDP will divide and allocate batch_size
# to all available GPUs if device_ids are not set.
model.cuda()
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.model = model.model.cuda(args.gpu)
else:
model.model = torch.nn.DataParallel(model.model).cuda()
import copy
model.ema_model = copy.deepcopy(model.model)
logger.info(f"model_arch: {model}")
logger.info(f"Arguments: {args}")
cudnn.benchmark = True
if args.rank != 0 and args.distributed:
torch.distributed.barrier()
# Construct Dataset & DataLoader
if args.dataset != "imagenet":
if args.num_labels == 10 and args.dataset == 'cifar10':
fixmatch_index = [
[7408, 8148, 9850, 10361, 33949, 36506, 37018, 45044, 46443, 47447],
[5022, 8193, 8902, 9601, 25226, 26223, 34089, 35186, 40595, 48024],
[7510, 13186, 14043, 21305, 22805, 31288, 34508, 40470, 41493, 45506],
[9915, 9978, 16631, 19915, 28008, 35314, 35801, 36149, 39215, 42557],
[6695, 14891, 19726, 22715, 23999, 34230, 46511, 47457, 49181, 49397],
[12830, 20293, 26835, 30517, 30898, 31061, 43693, 46501, 47310, 48517],
[1156, 11501, 19974, 21963, 32103, 42189, 46789, 47690, 48229, 48675],
[4255, 6446, 8580, 11759, 12598, 29349, 29433, 33759, 35345, 38639]]
index = fixmatch_index[-args.seed - 1]
print("10 labels for cifar10")
else:
index = None
train_dset = SSL_Dataset(args, alg='mixmatch', name=args.dataset, train=True,
num_classes=args.num_classes, data_dir=args.data_dir)
lb_dset, ulb_dset = train_dset.get_ssl_dset(args.num_labels,index=index)
_eval_dset = SSL_Dataset(args, alg='mixmatch', name=args.dataset, train=False,
num_classes=args.num_classes, data_dir=args.data_dir)
eval_dset = _eval_dset.get_dset()
if args.rank == 0 and args.distributed:
torch.distributed.barrier()
loader_dict = {}
dset_dict = {'train_lb': lb_dset, 'train_ulb': ulb_dset, 'eval': eval_dset}
loader_dict['train_lb'] = get_data_loader(dset_dict['train_lb'],
args.batch_size,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=args.num_workers,
distributed=args.distributed)
loader_dict['train_ulb'] = get_data_loader(dset_dict['train_ulb'],
args.batch_size * args.uratio,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=4 * args.num_workers,
distributed=args.distributed)
loader_dict['eval'] = get_data_loader(dset_dict['eval'],
args.eval_batch_size,
num_workers=args.num_workers,
drop_last=False)
## set DataLoader on MixMatch
model.set_data_loader(loader_dict)
# If args.resume, load checkpoints from args.load_path
if args.resume:
model.load_model(args.load_path)
# START TRAINING of MixMatch
trainer = model.train
for epoch in range(args.epoch):
trainer(args, logger=logger)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
model.save_model('latest_model.pth', save_path)
logging.warning(f"GPU {args.rank} training is FINISHED") | main_worker is conducted on each GPU. |
157,483 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.mixmatch.mixmatch import MixMatch
from datasets.ssl_dataset import SSL_Dataset
from datasets.data_utils import get_data_loader
def str2bool(v):
if isinstance(v, bool):
return v
if v.lower() in ('yes', 'true', 't', 'y', '1'):
return True
elif v.lower() in ('no', 'false', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError('Boolean value expected.') | null |
157,484 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.uda.uda import Uda
from datasets.ssl_dataset import SSL_Dataset
from datasets.data_utils import get_data_loader
def net_builder(net_name, from_name: bool, net_conf=None, is_remix=False):
"""
return **class** of backbone network (not instance).
Args
net_name: 'WideResNet' or network names in torchvision.models
from_name: If True, net_buidler takes models in torch.vision models. Then, net_conf is ignored.
net_conf: When from_name is False, net_conf is the configuration of backbone network (now, only WRN is supported).
"""
if from_name:
import torchvision.models as models
model_name_list = sorted(name for name in models.__dict__
if name.islower() and not name.startswith("__")
and callable(models.__dict__[name]))
if net_name not in model_name_list:
assert Exception(f"[!] Networks\' Name is wrong, check net config, \
expected: {model_name_list} \
received: {net_name}")
else:
return models.__dict__[net_name]
else:
if net_name == 'WideResNet':
import models.nets.wrn as net
builder = getattr(net, 'build_WideResNet')()
elif net_name == 'WideResNetVar':
import models.nets.wrn_var as net
builder = getattr(net, 'build_WideResNetVar')()
elif net_name == 'ResNet50':
import models.nets.resnet50 as net
builder = getattr(net, 'build_ResNet50')(is_remix)
else:
assert Exception("Not Implemented Error")
if net_name != 'ResNet50':
setattr_cls_from_kwargs(builder, net_conf)
return builder.build
def get_logger(name, save_path=None, level='INFO'):
logger = logging.getLogger(name)
logger.setLevel(getattr(logging, level))
log_format = logging.Formatter('[%(asctime)s %(levelname)s] %(message)s')
streamHandler = logging.StreamHandler()
streamHandler.setFormatter(log_format)
logger.addHandler(streamHandler)
if not save_path is None:
os.makedirs(save_path, exist_ok=True)
fileHandler = logging.FileHandler(os.path.join(save_path, 'log.txt'))
fileHandler.setFormatter(log_format)
logger.addHandler(fileHandler)
return logger
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
class TBLog:
"""
Construc tensorboard writer (self.writer).
The tensorboard is saved at os.path.join(tb_dir, file_name).
"""
def __init__(self, tb_dir, file_name, use_tensorboard=False):
self.tb_dir = tb_dir
self.use_tensorboard = use_tensorboard
if self.use_tensorboard:
self.writer = SummaryWriter(os.path.join(self.tb_dir, file_name))
else:
self.writer = CustomWriter(os.path.join(self.tb_dir, file_name))
def update(self, tb_dict, it, suffix=None, mode="train"):
"""
Args
tb_dict: contains scalar values for updating tensorboard
it: contains information of iteration (int).
suffix: If not None, the update key has the suffix.
"""
if suffix is None:
suffix = ''
if self.use_tensorboard:
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value, it)
else:
self.writer.set_epoch(it, mode)
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value)
self.writer.plot_stats()
self.writer.dump_stats()
def get_optimizer(net, optim_name='SGD', lr=0.1, momentum=0.9, weight_decay=0, nesterov=True, bn_wd_skip=True):
'''
return optimizer (name) in torch.optim.
If bn_wd_skip, the optimizer does not apply
weight decay regularization on parameters in batch normalization.
'''
decay = []
no_decay = []
for name, param in net.named_parameters():
if ('bn' in name or 'bias' in name) and bn_wd_skip:
no_decay.append(param)
else:
decay.append(param)
per_param_args = [{'params': decay},
{'params': no_decay, 'weight_decay': 0.0}]
if optim_name == 'SGD':
optimizer = torch.optim.SGD(per_param_args, lr=lr, momentum=momentum, weight_decay=weight_decay,
nesterov=nesterov)
elif optim_name == 'AdamW':
optimizer = torch.optim.AdamW(per_param_args, lr=lr, weight_decay=weight_decay)
return optimizer
def get_cosine_schedule_with_warmup(optimizer,
num_training_steps,
num_cycles=7. / 16.,
num_warmup_steps=0,
last_epoch=-1):
'''
Get cosine scheduler (LambdaLR).
if warmup is needed, set num_warmup_steps (int) > 0.
'''
def _lr_lambda(current_step):
'''
_lr_lambda returns a multiplicative factor given an interger parameter epochs.
Decaying criteria: last_epoch
'''
if current_step < num_warmup_steps:
_lr = float(current_step) / float(max(1, num_warmup_steps))
else:
num_cos_steps = float(current_step - num_warmup_steps)
num_cos_steps = num_cos_steps / float(max(1, num_training_steps - num_warmup_steps))
_lr = max(0.0, math.cos(math.pi * num_cycles * num_cos_steps))
return _lr
return LambdaLR(optimizer, _lr_lambda, last_epoch)
class Uda:
def __init__(self, net_builder, num_classes, ema_m, T, p_cutoff, lambda_u, \
t_fn=None, p_fn=None, it=0, num_eval_iter=1000, tb_log=None, logger=None):
"""
class Uda contains setter of data_loader, optimizer, and model update methods.
Args:
net_builder: backbone network class (see net_builder in utils.py)
num_classes: # of label classes
ema_m: momentum of exponential moving average for eval_model
T: Temperature scaling parameter for output sharpening (only when hard_label = False)
p_cutoff: confidence cutoff parameters for loss masking
lambda_u: ratio of unsupervised loss to supervised loss
it: initial iteration count
num_eval_iter: freqeuncy of iteration (after 500,000 iters)
tb_log: tensorboard writer (see train_utils.py)
logger: logger (see utils.py)
"""
super(Uda, self).__init__()
# momentum update param
self.loader = {}
self.num_classes = num_classes
self.ema_m = ema_m
# create the encoders
# network is builded only by num_classes,
# other configs are covered in main.py
self.model = net_builder(num_classes=num_classes)
self.ema_model = deepcopy(self.model)
self.num_eval_iter = num_eval_iter
self.t_fn = Get_Scalar(T) # temperature params function
self.p_fn = Get_Scalar(p_cutoff) # confidence cutoff function
self.lambda_u = lambda_u
self.tb_log = tb_log
self.optimizer = None
self.scheduler = None
self.it = 0
self.logger = logger
self.print_fn = print if logger is None else logger.info
self.bn_controller = Bn_Controller()
def set_data_loader(self, loader_dict):
self.loader_dict = loader_dict
self.print_fn(f'[!] data loader keys: {self.loader_dict.keys()}')
def set_dset(self, dset):
self.ulb_dset = dset
def set_optimizer(self, optimizer, scheduler=None):
self.optimizer = optimizer
self.scheduler = scheduler
def train(self, args, logger=None):
ngpus_per_node = torch.cuda.device_count()
# EMA Init
self.model.train()
self.ema = EMA(self.model, self.ema_m)
self.ema.register()
if args.resume == True:
self.ema.load(self.ema_model)
# for gpu profiling
start_batch = torch.cuda.Event(enable_timing=True)
end_batch = torch.cuda.Event(enable_timing=True)
start_run = torch.cuda.Event(enable_timing=True)
end_run = torch.cuda.Event(enable_timing=True)
start_batch.record()
best_eval_acc, best_it = 0.0, 0
scaler = GradScaler()
amp_cm = autocast if args.amp else contextlib.nullcontext
# eval for once to verify if the checkpoint is loaded correctly
if args.resume == True:
eval_dict = self.evaluate(args=args)
print(eval_dict)
selected_label = torch.ones((len(self.ulb_dset),), dtype=torch.long, ) * -1
selected_label = selected_label.cuda(args.gpu)
classwise_acc = torch.zeros((args.num_classes,)).cuda(args.gpu)
for (_, x_lb, y_lb), (x_ulb_idx, x_ulb_w, x_ulb_s) in zip(self.loader_dict['train_lb'],
self.loader_dict['train_ulb']):
# prevent the training iterations exceed args.num_train_iter
if self.it > args.num_train_iter:
break
end_batch.record()
torch.cuda.synchronize()
start_run.record()
num_lb = x_lb.shape[0]
num_ulb = x_ulb_w.shape[0]
assert num_ulb == x_ulb_s.shape[0]
x_lb, x_ulb_w, x_ulb_s = x_lb.cuda(args.gpu), x_ulb_w.cuda(args.gpu), x_ulb_s.cuda(args.gpu)
x_ulb_idx = x_ulb_idx.cuda(args.gpu)
y_lb = y_lb.cuda(args.gpu)
if args.use_flex:
pseudo_counter = Counter(selected_label.tolist())
if max(pseudo_counter.values()) < len(self.ulb_dset): # not all(5w) -1
for i in range(args.num_classes):
classwise_acc[i] = pseudo_counter[i] / max(pseudo_counter.values())
# inference and calculate sup/unsup losses
with amp_cm():
inputs = torch.cat([x_lb, x_ulb_w, x_ulb_s], dim=0)
logits = self.model(inputs)
logits_x_lb = logits[:num_lb]
logits_x_ulb_w, logits_x_ulb_s = logits[num_lb:].chunk(2)
# hyper-params for update
T = self.t_fn(self.it) # temperature
# p_cutoff = self.p_fn(self.it) # threshold
p_cutoff = args.p_cutoff # threshold
tsa = TSA(args.TSA_schedule, self.it, args.num_train_iter,
args.num_classes) # Training Signal Annealing
sup_mask = torch.max(torch.softmax(logits_x_lb, dim=-1), dim=-1)[0].le(tsa).float().detach()
sup_loss = (ce_loss(logits_x_lb, y_lb, reduction='none') * sup_mask).mean()
unsup_loss, mask, select, pseudo_lb = consistency_loss(logits_x_ulb_s,
logits_x_ulb_w,
classwise_acc,
self.it,
args.dataset,
'ce', T, p_cutoff,
use_flex=args.use_flex)
if x_ulb_idx[select == 1].nelement() != 0:
selected_label[x_ulb_idx[select == 1]] = pseudo_lb[select == 1]
total_loss = sup_loss + self.lambda_u * unsup_loss
# parameter updates
if args.amp:
scaler.scale(total_loss).backward()
if (args.clip > 0):
scaler.unscale_(self.optimizer)
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
scaler.step(self.optimizer)
scaler.update()
else:
total_loss.backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
self.optimizer.step()
self.scheduler.step()
self.ema.update()
self.model.zero_grad()
end_run.record()
torch.cuda.synchronize()
# tensorboard_dict update
tb_dict = {}
tb_dict['train/sup_loss'] = sup_loss.detach()
tb_dict['train/unsup_loss'] = unsup_loss.detach()
tb_dict['train/total_loss'] = total_loss.detach()
tb_dict['train/mask_ratio'] = 1.0 - mask.detach()
tb_dict['lr'] = self.optimizer.param_groups[0]['lr']
tb_dict['train/prefecth_time'] = start_batch.elapsed_time(end_batch) / 1000.
tb_dict['train/run_time'] = start_run.elapsed_time(end_run) / 1000.
# Save model for each 10K steps and best model for each 1K steps
if self.it % 10000 == 0:
save_path = os.path.join(args.save_dir, args.save_name)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
self.save_model('latest_model.pth', save_path)
if self.it % self.num_eval_iter == 0:
eval_dict = self.evaluate(args=args)
tb_dict.update(eval_dict)
save_path = os.path.join(args.save_dir, args.save_name)
if tb_dict['eval/top-1-acc'] > best_eval_acc:
best_eval_acc = tb_dict['eval/top-1-acc']
best_it = self.it
self.print_fn(
f"{self.it} iteration, USE_EMA: {self.ema_m != 0}, {tb_dict}, BEST_EVAL_ACC: {best_eval_acc}, at {best_it} iters")
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
if self.it == best_it:
self.save_model('model_best.pth', save_path)
if not self.tb_log is None:
self.tb_log.update(tb_dict, self.it)
self.it += 1
del tb_dict
start_batch.record()
if self.it > 0.8 * args.num_train_iter:
self.num_eval_iter = 1000
eval_dict = self.evaluate(args=args)
eval_dict.update({'eval/best_acc': best_eval_acc, 'eval/best_it': best_it})
return eval_dict
def evaluate(self, eval_loader=None, args=None):
self.model.eval()
self.ema.apply_shadow()
if eval_loader is None:
eval_loader = self.loader_dict['eval']
total_loss = 0.0
total_num = 0.0
y_true = []
y_pred = []
y_logits = []
for _, x, y in eval_loader:
x, y = x.cuda(args.gpu), y.cuda(args.gpu)
num_batch = x.shape[0]
total_num += num_batch
logits = self.model(x)
loss = F.cross_entropy(logits, y, reduction='mean')
y_true.extend(y.cpu().tolist())
y_pred.extend(torch.max(logits, dim=-1)[1].cpu().tolist())
y_logits.extend(torch.softmax(logits, dim=-1).cpu().tolist())
total_loss += loss.detach() * num_batch
top1 = accuracy_score(y_true, y_pred)
top5 = top_k_accuracy_score(y_true, y_logits, k=5)
precision = precision_score(y_true, y_pred, average='macro')
recall = recall_score(y_true, y_pred, average='macro')
F1 = f1_score(y_true, y_pred, average='macro')
AUC = roc_auc_score(y_true, y_logits, multi_class='ovo')
cf_mat = confusion_matrix(y_true, y_pred, normalize='true')
self.print_fn('confusion matrix:\n' + np.array_str(cf_mat))
self.ema.restore()
self.model.train()
return {'eval/loss': total_loss / total_num, 'eval/top-1-acc': top1, 'eval/top-5-acc': top5,
'eval/precision': precision, 'eval/recall': recall, 'eval/F1': F1, 'eval/AUC': AUC}
def save_model(self, save_name, save_path):
if self.it < 1000000:
return
save_filename = os.path.join(save_path, save_name)
# copy EMA parameters to ema_model for saving with model as temp
self.model.eval()
self.ema.apply_shadow()
ema_model = self.model.state_dict()
self.ema.restore()
self.model.train()
torch.save({'model': self.model.state_dict(),
'optimizer': self.optimizer.state_dict(),
'scheduler': self.scheduler.state_dict(),
'it': self.it + 1,
'ema_model': ema_model},
save_filename)
self.print_fn(f"model saved: {save_filename}")
def load_model(self, load_path):
checkpoint = torch.load(load_path)
self.model.load_state_dict(checkpoint['model'])
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.scheduler.load_state_dict(checkpoint['scheduler'])
self.it = checkpoint['it']
self.ema_model.load_state_dict(checkpoint['ema_model'])
self.print_fn('model loaded')
def interleave_offsets(self, batch, nu):
groups = [batch // (nu + 1)] * (nu + 1)
for x in range(batch - sum(groups)):
groups[-x - 1] += 1
offsets = [0]
for g in groups:
offsets.append(offsets[-1] + g)
assert offsets[-1] == batch
return offsets
def interleave(self, xy, batch):
nu = len(xy) - 1
offsets = self.interleave_offsets(batch, nu)
xy = [[v[offsets[p]:offsets[p + 1]] for p in range(nu + 1)] for v in xy]
for i in range(1, nu + 1):
xy[0][i], xy[i][i] = xy[i][i], xy[0][i]
return [torch.cat(v, dim=0) for v in xy]
class SSL_Dataset:
"""
SSL_Dataset class gets dataset from torchvision.datasets,
separates labeled and unlabeled data,
and return BasicDataset: torch.utils.data.Dataset (see datasets.dataset.py)
"""
def __init__(self,
args,
alg='fixmatch',
name='cifar10',
train=True,
num_classes=10,
data_dir='./data'):
"""
Args
alg: SSL algorithms
name: name of dataset in torchvision.datasets (cifar10, cifar100, svhn, stl10)
train: True means the dataset is training dataset (default=True)
num_classes: number of label classes
data_dir: path of directory, where data is downloaed or stored.
"""
self.args = args
self.alg = alg
self.name = name
self.train = train
self.num_classes = num_classes
self.data_dir = data_dir
crop_size = 96 if self.name.upper() == 'STL10' else 224 if self.name.upper() == 'IMAGENET' else 32
self.transform = get_transform(mean[name], std[name], crop_size, train)
def get_data(self, svhn_extra=True):
"""
get_data returns data (images) and targets (labels)
shape of data: B, H, W, C
shape of labels: B,
"""
dset = getattr(torchvision.datasets, self.name.upper())
if 'CIFAR' in self.name.upper():
dset = dset(self.data_dir, train=self.train, download=True)
data, targets = dset.data, dset.targets
return data, targets
elif self.name.upper() == 'SVHN':
if self.train:
if svhn_extra: # train+extra
dset_base = dset(self.data_dir, split='train', download=True)
data_b, targets_b = dset_base.data.transpose([0, 2, 3, 1]), dset_base.labels
dset_extra = dset(self.data_dir, split='extra', download=True)
data_e, targets_e = dset_extra.data.transpose([0, 2, 3, 1]), dset_extra.labels
data = np.concatenate([data_b, data_e])
targets = np.concatenate([targets_b, targets_e])
del data_b, data_e
del targets_b, targets_e
else: # train_only
dset = dset(self.data_dir, split='train', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
else: # test
dset = dset(self.data_dir, split='test', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
return data, targets
elif self.name.upper() == 'STL10':
split = 'train' if self.train else 'test'
dset_lb = dset(self.data_dir, split=split, download=True)
dset_ulb = dset(self.data_dir, split='unlabeled', download=True)
data, targets = dset_lb.data.transpose([0, 2, 3, 1]), dset_lb.labels.astype(np.int64)
ulb_data = dset_ulb.data.transpose([0, 2, 3, 1])
return data, targets, ulb_data
def get_dset(self, is_ulb=False,
strong_transform=None, onehot=False):
"""
get_dset returns class BasicDataset, containing the returns of get_data.
Args
is_ulb: If True, returned dataset generates a pair of weak and strong augmented images.
strong_transform: list of strong_transform (augmentation) if use_strong_transform is True。
onehot: If True, the label is not integer, but one-hot vector.
"""
if self.name.upper() == 'STL10':
data, targets, _ = self.get_data()
else:
data, targets = self.get_data()
num_classes = self.num_classes
transform = self.transform
return BasicDataset(self.alg, data, targets, num_classes, transform,
is_ulb, strong_transform, onehot)
def get_ssl_dset(self, num_labels, index=None, include_lb_to_ulb=True,
strong_transform=None, onehot=False):
"""
get_ssl_dset split training samples into labeled and unlabeled samples.
The labeled data is balanced samples over classes.
Args:
num_labels: number of labeled data.
index: If index of np.array is given, labeled data is not randomly sampled, but use index for sampling.
include_lb_to_ulb: If True, consistency regularization is also computed for the labeled data.
strong_transform: list of strong transform (RandAugment in FixMatch)
onehot: If True, the target is converted into onehot vector.
Returns:
BasicDataset (for labeled data), BasicDataset (for unlabeld data)
"""
# Supervised top line using all data as labeled data.
if self.alg == 'fullysupervised':
lb_data, lb_targets = self.get_data()
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
return lb_dset, None
if self.name.upper() == 'STL10':
lb_data, lb_targets, ulb_data = self.get_data()
if include_lb_to_ulb:
ulb_data = np.concatenate([ulb_data, lb_data], axis=0)
lb_data, lb_targets, _ = sample_labeled_data(self.args, lb_data, lb_targets, num_labels, self.num_classes)
ulb_targets = None
else:
data, targets = self.get_data()
lb_data, lb_targets, ulb_data, ulb_targets = split_ssl_data(self.args, data, targets,
num_labels, self.num_classes,
index, include_lb_to_ulb)
# output the distribution of labeled data for remixmatch
count = [0 for _ in range(self.num_classes)]
for c in lb_targets:
count[c] += 1
dist = np.array(count, dtype=float)
dist = dist / dist.sum()
dist = dist.tolist()
out = {"distribution": dist}
output_file = r"./data_statistics/"
output_path = output_file + str(self.name) + '_' + str(num_labels) + '.json'
if not os.path.exists(output_file):
os.makedirs(output_file, exist_ok=True)
with open(output_path, 'w') as w:
json.dump(out, w)
# print(Counter(ulb_targets.tolist()))
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
ulb_dset = BasicDataset(self.alg, ulb_data, ulb_targets, self.num_classes,
self.transform, True, strong_transform, onehot)
# print(lb_data.shape)
# print(ulb_data.shape)
return lb_dset, ulb_dset
def get_data_loader(dset,
batch_size=None,
shuffle=False,
num_workers=4,
pin_memory=False,
data_sampler=None,
replacement=True,
num_epochs=None,
num_iters=None,
generator=None,
drop_last=True,
distributed=False):
"""
get_data_loader returns torch.utils.data.DataLoader for a Dataset.
All arguments are comparable with those of pytorch DataLoader.
However, if distributed, DistributedProxySampler, which is a wrapper of data_sampler, is used.
Args
num_epochs: total batch -> (# of batches in dset) * num_epochs
num_iters: total batch -> num_iters
"""
assert batch_size is not None
if data_sampler is None:
return DataLoader(dset, batch_size=batch_size, shuffle=shuffle,
num_workers=num_workers, pin_memory=pin_memory)
else:
if isinstance(data_sampler, str):
data_sampler = get_sampler_by_name(data_sampler)
if distributed:
assert dist.is_available()
num_replicas = dist.get_world_size()
else:
num_replicas = 1
if (num_epochs is not None) and (num_iters is None):
num_samples = len(dset) * num_epochs
elif (num_epochs is None) and (num_iters is not None):
num_samples = batch_size * num_iters * num_replicas
else:
num_samples = len(dset)
if data_sampler.__name__ == 'RandomSampler':
data_sampler = data_sampler(dset, replacement, num_samples, generator)
else:
raise RuntimeError(f"{data_sampler.__name__} is not implemented.")
if distributed:
'''
Different with DistributedSampler,
the DistribuedProxySampler does not shuffle the data (just wrapper for dist).
'''
data_sampler = DistributedProxySampler(data_sampler)
batch_sampler = BatchSampler(data_sampler, batch_size, drop_last)
return DataLoader(dset, batch_sampler=batch_sampler,
num_workers=num_workers, pin_memory=pin_memory)
The provided code snippet includes necessary dependencies for implementing the `main_worker` function. Write a Python function `def main_worker(gpu, ngpus_per_node, args)` to solve the following problem:
main_worker is conducted on each GPU.
Here is the function:
def main_worker(gpu, ngpus_per_node, args):
'''
main_worker is conducted on each GPU.
'''
global best_acc1
args.gpu = gpu
# random seed has to be set for the syncronization of labeled data sampling in each process.
assert args.seed is not None
random.seed(args.seed)
torch.manual_seed(args.seed)
np.random.seed(args.seed)
cudnn.deterministic = True
# SET UP FOR DISTRIBUTED TRAINING
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
args.rank = args.rank * ngpus_per_node + gpu # compute global rank
# set distributed group:
dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
world_size=args.world_size, rank=args.rank)
# SET save_path and logger
save_path = os.path.join(args.save_dir, args.save_name)
logger_level = "WARNING"
tb_log = None
if args.rank % ngpus_per_node == 0:
tb_log = TBLog(save_path, 'tensorboard', use_tensorboard=args.use_tensorboard)
logger_level = "INFO"
logger = get_logger(args.save_name, save_path, logger_level)
logger.warning(f"USE GPU: {args.gpu} for training")
args.bn_momentum = 1.0 - 0.999
if 'imagenet' in args.dataset.lower():
_net_builder = net_builder('ResNet50', False, None, is_remix=False)
else:
_net_builder = net_builder(args.net,
args.net_from_name,
{'first_stride': 2 if 'stl' in args.dataset else 1,
'depth': args.depth,
'widen_factor': args.widen_factor,
'leaky_slope': args.leaky_slope,
'bn_momentum': args.bn_momentum,
'dropRate': args.dropout,
'use_embed': False,
'is_remix': False},
)
model = Uda(_net_builder,
args.num_classes,
args.ema_m,
args.T,
args.p_cutoff,
args.ulb_loss_ratio,
num_eval_iter=args.num_eval_iter,
tb_log=tb_log,
logger=logger)
logger.info(f'Number of Trainable Params: {count_parameters(model.model)}')
# SET Optimizer & LR Scheduler
## construct SGD and cosine lr scheduler
optimizer = get_optimizer(model.model, args.optim, args.lr, args.momentum, args.weight_decay)
scheduler = get_cosine_schedule_with_warmup(optimizer,
args.num_train_iter,
num_warmup_steps=args.num_train_iter * 0)
## set SGD and cosine lr on UDA
model.set_optimizer(optimizer, scheduler)
# SET Devices for (Distributed) DataParallel
if not torch.cuda.is_available():
raise Exception('ONLY GPU TRAINING IS SUPPORTED')
elif args.distributed:
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
'''
batch_size: batch_size per node -> batch_size per gpu
workers: workers per node -> workers per gpu
'''
args.batch_size = int(args.batch_size / ngpus_per_node)
model.model.cuda(args.gpu)
model.model = nn.SyncBatchNorm.convert_sync_batchnorm(model.model)
model.model = torch.nn.parallel.DistributedDataParallel(model.model,
device_ids=[args.gpu],
find_unused_parameters=True,
broadcast_buffers=False)
else:
# if arg.gpu is None, DDP will divide and allocate batch_size
# to all available GPUs if device_ids are not set.
model.cuda()
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.model = model.model.cuda(args.gpu)
else:
model.model = torch.nn.DataParallel(model.model).cuda()
import copy
model.ema_model = copy.deepcopy(model.model)
logger.info(f"model_arch: {model}")
logger.info(f"Arguments: {args}")
cudnn.benchmark = True
if args.rank != 0 and args.distributed:
torch.distributed.barrier()
# Construct Dataset & DataLoader
if args.dataset != "imagenet":
if args.num_labels == 10 and args.dataset == 'cifar10':
fixmatch_index = [
[7408, 8148, 9850, 10361, 33949, 36506, 37018, 45044, 46443, 47447],
[5022, 8193, 8902, 9601, 25226, 26223, 34089, 35186, 40595, 48024],
[7510, 13186, 14043, 21305, 22805, 31288, 34508, 40470, 41493, 45506],
[9915, 9978, 16631, 19915, 28008, 35314, 35801, 36149, 39215, 42557],
[6695, 14891, 19726, 22715, 23999, 34230, 46511, 47457, 49181, 49397],
[12830, 20293, 26835, 30517, 30898, 31061, 43693, 46501, 47310, 48517],
[1156, 11501, 19974, 21963, 32103, 42189, 46789, 47690, 48229, 48675],
[4255, 6446, 8580, 11759, 12598, 29349, 29433, 33759, 35345, 38639]]
index = fixmatch_index[-args.seed - 1]
print("10 labels for cifar10")
else:
index = None
train_dset = SSL_Dataset(args, alg='uda', name=args.dataset, train=True,
num_classes=args.num_classes, data_dir=args.data_dir)
lb_dset, ulb_dset = train_dset.get_ssl_dset(args.num_labels,index=index)
_eval_dset = SSL_Dataset(args, alg='uda', name=args.dataset, train=False,
num_classes=args.num_classes, data_dir=args.data_dir)
eval_dset = _eval_dset.get_dset()
if args.rank == 0 and args.distributed:
torch.distributed.barrier()
loader_dict = {}
dset_dict = {'train_lb': lb_dset, 'train_ulb': ulb_dset, 'eval': eval_dset}
loader_dict['train_lb'] = get_data_loader(dset_dict['train_lb'],
args.batch_size,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=args.num_workers,
distributed=args.distributed)
loader_dict['train_ulb'] = get_data_loader(dset_dict['train_ulb'],
args.batch_size * args.uratio,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=4 * args.num_workers,
distributed=args.distributed)
loader_dict['eval'] = get_data_loader(dset_dict['eval'],
args.eval_batch_size,
num_workers=args.num_workers,
drop_last=False)
## set DataLoader on UDA
model.set_data_loader(loader_dict)
model.set_dset(ulb_dset)
# If args.resume, load checkpoints from args.load_path
if args.resume:
model.load_model(args.load_path)
# START TRAINING of UDA
trainer = model.train
for epoch in range(args.epoch):
trainer(args, logger=logger)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
model.save_model('latest_model.pth', save_path)
logging.warning(f"GPU {args.rank} training is FINISHED") | main_worker is conducted on each GPU. |
157,485 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.uda.uda import Uda
from datasets.ssl_dataset import SSL_Dataset
from datasets.data_utils import get_data_loader
def str2bool(v):
if isinstance(v, bool):
return v
if v.lower() in ('yes', 'true', 't', 'y', '1'):
return True
elif v.lower() in ('no', 'false', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError('Boolean value expected.') | null |
157,486 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.fullysupervised.fullysupervised import FullySupervised
from datasets.ssl_dataset import SSL_Dataset
from datasets.data_utils import get_data_loader
def net_builder(net_name, from_name: bool, net_conf=None, is_remix=False):
"""
return **class** of backbone network (not instance).
Args
net_name: 'WideResNet' or network names in torchvision.models
from_name: If True, net_buidler takes models in torch.vision models. Then, net_conf is ignored.
net_conf: When from_name is False, net_conf is the configuration of backbone network (now, only WRN is supported).
"""
if from_name:
import torchvision.models as models
model_name_list = sorted(name for name in models.__dict__
if name.islower() and not name.startswith("__")
and callable(models.__dict__[name]))
if net_name not in model_name_list:
assert Exception(f"[!] Networks\' Name is wrong, check net config, \
expected: {model_name_list} \
received: {net_name}")
else:
return models.__dict__[net_name]
else:
if net_name == 'WideResNet':
import models.nets.wrn as net
builder = getattr(net, 'build_WideResNet')()
elif net_name == 'WideResNetVar':
import models.nets.wrn_var as net
builder = getattr(net, 'build_WideResNetVar')()
elif net_name == 'ResNet50':
import models.nets.resnet50 as net
builder = getattr(net, 'build_ResNet50')(is_remix)
else:
assert Exception("Not Implemented Error")
if net_name != 'ResNet50':
setattr_cls_from_kwargs(builder, net_conf)
return builder.build
def get_logger(name, save_path=None, level='INFO'):
logger = logging.getLogger(name)
logger.setLevel(getattr(logging, level))
log_format = logging.Formatter('[%(asctime)s %(levelname)s] %(message)s')
streamHandler = logging.StreamHandler()
streamHandler.setFormatter(log_format)
logger.addHandler(streamHandler)
if not save_path is None:
os.makedirs(save_path, exist_ok=True)
fileHandler = logging.FileHandler(os.path.join(save_path, 'log.txt'))
fileHandler.setFormatter(log_format)
logger.addHandler(fileHandler)
return logger
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
class TBLog:
"""
Construc tensorboard writer (self.writer).
The tensorboard is saved at os.path.join(tb_dir, file_name).
"""
def __init__(self, tb_dir, file_name, use_tensorboard=False):
self.tb_dir = tb_dir
self.use_tensorboard = use_tensorboard
if self.use_tensorboard:
self.writer = SummaryWriter(os.path.join(self.tb_dir, file_name))
else:
self.writer = CustomWriter(os.path.join(self.tb_dir, file_name))
def update(self, tb_dict, it, suffix=None, mode="train"):
"""
Args
tb_dict: contains scalar values for updating tensorboard
it: contains information of iteration (int).
suffix: If not None, the update key has the suffix.
"""
if suffix is None:
suffix = ''
if self.use_tensorboard:
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value, it)
else:
self.writer.set_epoch(it, mode)
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value)
self.writer.plot_stats()
self.writer.dump_stats()
def get_optimizer(net, optim_name='SGD', lr=0.1, momentum=0.9, weight_decay=0, nesterov=True, bn_wd_skip=True):
'''
return optimizer (name) in torch.optim.
If bn_wd_skip, the optimizer does not apply
weight decay regularization on parameters in batch normalization.
'''
decay = []
no_decay = []
for name, param in net.named_parameters():
if ('bn' in name or 'bias' in name) and bn_wd_skip:
no_decay.append(param)
else:
decay.append(param)
per_param_args = [{'params': decay},
{'params': no_decay, 'weight_decay': 0.0}]
if optim_name == 'SGD':
optimizer = torch.optim.SGD(per_param_args, lr=lr, momentum=momentum, weight_decay=weight_decay,
nesterov=nesterov)
elif optim_name == 'AdamW':
optimizer = torch.optim.AdamW(per_param_args, lr=lr, weight_decay=weight_decay)
return optimizer
def get_cosine_schedule_with_warmup(optimizer,
num_training_steps,
num_cycles=7. / 16.,
num_warmup_steps=0,
last_epoch=-1):
'''
Get cosine scheduler (LambdaLR).
if warmup is needed, set num_warmup_steps (int) > 0.
'''
def _lr_lambda(current_step):
'''
_lr_lambda returns a multiplicative factor given an interger parameter epochs.
Decaying criteria: last_epoch
'''
if current_step < num_warmup_steps:
_lr = float(current_step) / float(max(1, num_warmup_steps))
else:
num_cos_steps = float(current_step - num_warmup_steps)
num_cos_steps = num_cos_steps / float(max(1, num_training_steps - num_warmup_steps))
_lr = max(0.0, math.cos(math.pi * num_cycles * num_cos_steps))
return _lr
return LambdaLR(optimizer, _lr_lambda, last_epoch)
class FullySupervised:
def __init__(self, net_builder, num_classes,
num_eval_iter=1000, tb_log=None, ema_m=0.999, logger=None):
"""
class FullySupervised contains setter of data_loader, optimizer, and model update methods.
Args:
net_builder: backbone network class (see net_builder in utils.py)
num_classes: # of label classes
it: initial iteration count
num_eval_iter: frequency of evaluation.
tb_log: tensorboard writer (see train_utils.py)
logger: logger (see utils.py)
"""
super(FullySupervised, self).__init__()
# momentum update param
self.loader = {}
self.num_classes = num_classes
# create the encoders
# network is builded only by num_classes,
# other configs are covered in main.py
self.model = net_builder(num_classes=num_classes)
self.num_eval_iter = num_eval_iter
self.tb_log = tb_log
self.optimizer = None
self.scheduler = None
self.it = 0
self.logger = logger
self.print_fn = print if logger is None else logger.info
self.ema_m = ema_m
self.ema_model = deepcopy(self.model)
self.bn_controller = Bn_Controller()
def set_data_loader(self, loader_dict):
self.loader_dict = loader_dict
self.print_fn(f'[!] data loader keys: {self.loader_dict.keys()}')
def set_optimizer(self, optimizer, scheduler=None):
self.optimizer = optimizer
self.scheduler = scheduler
def train(self, args):
ngpus_per_node = torch.cuda.device_count()
# lb: labeled, ulb: unlabeled
self.model.train()
self.ema = EMA(self.model, self.ema_m)
self.ema.register()
if args.resume == True:
self.ema.load(self.ema_model)
# for gpu profiling
start_batch = torch.cuda.Event(enable_timing=True)
end_batch = torch.cuda.Event(enable_timing=True)
start_run = torch.cuda.Event(enable_timing=True)
end_run = torch.cuda.Event(enable_timing=True)
start_batch.record()
best_eval_acc, best_it = 0.0, 0
scaler = GradScaler()
amp_cm = autocast if args.amp else contextlib.nullcontext
# eval for once to verify if the checkpoint is loaded correctly
if args.resume == True:
eval_dict = self.evaluate(args=args)
print(eval_dict)
for _, x_lb, y_lb in self.loader_dict['train_lb']:
# prevent the training iterations exceed args.num_train_iter
if self.it > args.num_train_iter:
break
end_batch.record()
torch.cuda.synchronize()
start_run.record()
x_lb = x_lb.cuda(args.gpu)
y_lb = y_lb.cuda(args.gpu)
num_lb = x_lb.shape[0]
# inference and calculate sup/unsup losses
with amp_cm():
logits_x_lb = self.model(x_lb)
sup_loss = ce_loss(logits_x_lb, y_lb, reduction='mean')
total_loss = sup_loss
# parameter updates
if args.amp:
scaler.scale(total_loss).backward()
if (args.clip > 0):
scaler.unscale_(self.optimizer)
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
scaler.step(self.optimizer)
scaler.update()
else:
total_loss.backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
self.optimizer.step()
self.scheduler.step()
self.ema.update()
self.model.zero_grad()
end_run.record()
torch.cuda.synchronize()
# tensorboard_dict update
tb_dict = {}
tb_dict['train/sup_loss'] = sup_loss.detach()
tb_dict['train/total_loss'] = total_loss.detach()
tb_dict['lr'] = self.optimizer.param_groups[0]['lr']
tb_dict['train/prefecth_time'] = start_batch.elapsed_time(end_batch) / 1000.
tb_dict['train/run_time'] = start_run.elapsed_time(end_run) / 1000.
# Save model for each 10K steps and best model for each 1K steps
if self.it % 10000 == 0:
save_path = os.path.join(args.save_dir, args.save_name)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
self.save_model('latest_model.pth', save_path)
if self.it % self.num_eval_iter == 0:
eval_dict = self.evaluate(args=args)
tb_dict.update(eval_dict)
save_path = os.path.join(args.save_dir, args.save_name)
if tb_dict['eval/top-1-acc'] > best_eval_acc:
best_eval_acc = tb_dict['eval/top-1-acc']
best_it = self.it
self.print_fn(
f"{self.it} iteration, {tb_dict}, BEST_EVAL_ACC: {best_eval_acc}, at {best_it} iters")
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
if self.it == best_it:
self.save_model('model_best.pth', save_path)
if not self.tb_log is None:
self.tb_log.update(tb_dict, self.it)
self.it += 1
del tb_dict
start_batch.record()
if self.it > 0.8 * args.num_train_iter:
self.num_eval_iter = 1000
eval_dict = self.evaluate(args=args)
eval_dict.update({'eval/best_acc': best_eval_acc, 'eval/best_it': best_it})
return eval_dict
def evaluate(self, eval_loader=None, args=None):
self.model.eval()
self.ema.apply_shadow()
if eval_loader is None:
eval_loader = self.loader_dict['eval']
total_loss = 0.0
total_num = 0.0
y_true = []
y_pred = []
y_logits = []
for _, x, y in eval_loader:
x, y = x.cuda(args.gpu), y.cuda(args.gpu)
num_batch = x.shape[0]
total_num += num_batch
logits = self.model(x)
loss = F.cross_entropy(logits, y, reduction='mean')
y_true.extend(y.cpu().tolist())
y_pred.extend(torch.max(logits, dim=-1)[1].cpu().tolist())
y_logits.extend(torch.softmax(logits, dim=-1).cpu().tolist())
total_loss += loss.detach() * num_batch
top1 = accuracy_score(y_true, y_pred)
top5 = top_k_accuracy_score(y_true, y_logits, k=5)
cf_mat = confusion_matrix(y_true, y_pred, normalize='true')
self.print_fn('confusion matrix:\n' + np.array_str(cf_mat))
self.ema.restore()
self.model.train()
return {'eval/loss': total_loss / total_num, 'eval/top-1-acc': top1, 'eval/top-5-acc': top5}
def save_model(self, save_name, save_path):
if self.it < 1000000:
return
save_filename = os.path.join(save_path, save_name)
# copy EMA parameters to ema_model for saving with model as temp
self.model.eval()
self.ema.apply_shadow()
ema_model = deepcopy(self.model)
self.ema.restore()
self.model.train()
torch.save({'model': self.model.state_dict(),
'optimizer': self.optimizer.state_dict(),
'scheduler': self.scheduler.state_dict(),
'it': self.it + 1,
'ema_model': ema_model.state_dict()},
save_filename)
self.print_fn(f"model saved: {save_filename}")
def load_model(self, load_path):
checkpoint = torch.load(load_path)
self.model.load_state_dict(checkpoint['model'])
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.scheduler.load_state_dict(checkpoint['scheduler'])
self.it = checkpoint['it']
self.ema_model.load_state_dict(checkpoint['ema_model'])
self.print_fn('model loaded')
# Abandoned in PiModel
def interleave_offsets(self, batch, nu):
groups = [batch // (nu + 1)] * (nu + 1)
for x in range(batch - sum(groups)):
groups[-x - 1] += 1
offsets = [0]
for g in groups:
offsets.append(offsets[-1] + g)
assert offsets[-1] == batch
return offsets
def interleave(self, xy, batch):
nu = len(xy) - 1
offsets = self.interleave_offsets(batch, nu)
xy = [[v[offsets[p]:offsets[p + 1]] for p in range(nu + 1)] for v in xy]
for i in range(1, nu + 1):
xy[0][i], xy[i][i] = xy[i][i], xy[0][i]
return [torch.cat(v, dim=0) for v in xy]
class SSL_Dataset:
"""
SSL_Dataset class gets dataset from torchvision.datasets,
separates labeled and unlabeled data,
and return BasicDataset: torch.utils.data.Dataset (see datasets.dataset.py)
"""
def __init__(self,
args,
alg='fixmatch',
name='cifar10',
train=True,
num_classes=10,
data_dir='./data'):
"""
Args
alg: SSL algorithms
name: name of dataset in torchvision.datasets (cifar10, cifar100, svhn, stl10)
train: True means the dataset is training dataset (default=True)
num_classes: number of label classes
data_dir: path of directory, where data is downloaed or stored.
"""
self.args = args
self.alg = alg
self.name = name
self.train = train
self.num_classes = num_classes
self.data_dir = data_dir
crop_size = 96 if self.name.upper() == 'STL10' else 224 if self.name.upper() == 'IMAGENET' else 32
self.transform = get_transform(mean[name], std[name], crop_size, train)
def get_data(self, svhn_extra=True):
"""
get_data returns data (images) and targets (labels)
shape of data: B, H, W, C
shape of labels: B,
"""
dset = getattr(torchvision.datasets, self.name.upper())
if 'CIFAR' in self.name.upper():
dset = dset(self.data_dir, train=self.train, download=True)
data, targets = dset.data, dset.targets
return data, targets
elif self.name.upper() == 'SVHN':
if self.train:
if svhn_extra: # train+extra
dset_base = dset(self.data_dir, split='train', download=True)
data_b, targets_b = dset_base.data.transpose([0, 2, 3, 1]), dset_base.labels
dset_extra = dset(self.data_dir, split='extra', download=True)
data_e, targets_e = dset_extra.data.transpose([0, 2, 3, 1]), dset_extra.labels
data = np.concatenate([data_b, data_e])
targets = np.concatenate([targets_b, targets_e])
del data_b, data_e
del targets_b, targets_e
else: # train_only
dset = dset(self.data_dir, split='train', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
else: # test
dset = dset(self.data_dir, split='test', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
return data, targets
elif self.name.upper() == 'STL10':
split = 'train' if self.train else 'test'
dset_lb = dset(self.data_dir, split=split, download=True)
dset_ulb = dset(self.data_dir, split='unlabeled', download=True)
data, targets = dset_lb.data.transpose([0, 2, 3, 1]), dset_lb.labels.astype(np.int64)
ulb_data = dset_ulb.data.transpose([0, 2, 3, 1])
return data, targets, ulb_data
def get_dset(self, is_ulb=False,
strong_transform=None, onehot=False):
"""
get_dset returns class BasicDataset, containing the returns of get_data.
Args
is_ulb: If True, returned dataset generates a pair of weak and strong augmented images.
strong_transform: list of strong_transform (augmentation) if use_strong_transform is True。
onehot: If True, the label is not integer, but one-hot vector.
"""
if self.name.upper() == 'STL10':
data, targets, _ = self.get_data()
else:
data, targets = self.get_data()
num_classes = self.num_classes
transform = self.transform
return BasicDataset(self.alg, data, targets, num_classes, transform,
is_ulb, strong_transform, onehot)
def get_ssl_dset(self, num_labels, index=None, include_lb_to_ulb=True,
strong_transform=None, onehot=False):
"""
get_ssl_dset split training samples into labeled and unlabeled samples.
The labeled data is balanced samples over classes.
Args:
num_labels: number of labeled data.
index: If index of np.array is given, labeled data is not randomly sampled, but use index for sampling.
include_lb_to_ulb: If True, consistency regularization is also computed for the labeled data.
strong_transform: list of strong transform (RandAugment in FixMatch)
onehot: If True, the target is converted into onehot vector.
Returns:
BasicDataset (for labeled data), BasicDataset (for unlabeld data)
"""
# Supervised top line using all data as labeled data.
if self.alg == 'fullysupervised':
lb_data, lb_targets = self.get_data()
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
return lb_dset, None
if self.name.upper() == 'STL10':
lb_data, lb_targets, ulb_data = self.get_data()
if include_lb_to_ulb:
ulb_data = np.concatenate([ulb_data, lb_data], axis=0)
lb_data, lb_targets, _ = sample_labeled_data(self.args, lb_data, lb_targets, num_labels, self.num_classes)
ulb_targets = None
else:
data, targets = self.get_data()
lb_data, lb_targets, ulb_data, ulb_targets = split_ssl_data(self.args, data, targets,
num_labels, self.num_classes,
index, include_lb_to_ulb)
# output the distribution of labeled data for remixmatch
count = [0 for _ in range(self.num_classes)]
for c in lb_targets:
count[c] += 1
dist = np.array(count, dtype=float)
dist = dist / dist.sum()
dist = dist.tolist()
out = {"distribution": dist}
output_file = r"./data_statistics/"
output_path = output_file + str(self.name) + '_' + str(num_labels) + '.json'
if not os.path.exists(output_file):
os.makedirs(output_file, exist_ok=True)
with open(output_path, 'w') as w:
json.dump(out, w)
# print(Counter(ulb_targets.tolist()))
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
ulb_dset = BasicDataset(self.alg, ulb_data, ulb_targets, self.num_classes,
self.transform, True, strong_transform, onehot)
# print(lb_data.shape)
# print(ulb_data.shape)
return lb_dset, ulb_dset
def get_data_loader(dset,
batch_size=None,
shuffle=False,
num_workers=4,
pin_memory=False,
data_sampler=None,
replacement=True,
num_epochs=None,
num_iters=None,
generator=None,
drop_last=True,
distributed=False):
"""
get_data_loader returns torch.utils.data.DataLoader for a Dataset.
All arguments are comparable with those of pytorch DataLoader.
However, if distributed, DistributedProxySampler, which is a wrapper of data_sampler, is used.
Args
num_epochs: total batch -> (# of batches in dset) * num_epochs
num_iters: total batch -> num_iters
"""
assert batch_size is not None
if data_sampler is None:
return DataLoader(dset, batch_size=batch_size, shuffle=shuffle,
num_workers=num_workers, pin_memory=pin_memory)
else:
if isinstance(data_sampler, str):
data_sampler = get_sampler_by_name(data_sampler)
if distributed:
assert dist.is_available()
num_replicas = dist.get_world_size()
else:
num_replicas = 1
if (num_epochs is not None) and (num_iters is None):
num_samples = len(dset) * num_epochs
elif (num_epochs is None) and (num_iters is not None):
num_samples = batch_size * num_iters * num_replicas
else:
num_samples = len(dset)
if data_sampler.__name__ == 'RandomSampler':
data_sampler = data_sampler(dset, replacement, num_samples, generator)
else:
raise RuntimeError(f"{data_sampler.__name__} is not implemented.")
if distributed:
'''
Different with DistributedSampler,
the DistribuedProxySampler does not shuffle the data (just wrapper for dist).
'''
data_sampler = DistributedProxySampler(data_sampler)
batch_sampler = BatchSampler(data_sampler, batch_size, drop_last)
return DataLoader(dset, batch_sampler=batch_sampler,
num_workers=num_workers, pin_memory=pin_memory)
The provided code snippet includes necessary dependencies for implementing the `main_worker` function. Write a Python function `def main_worker(gpu, ngpus_per_node, args)` to solve the following problem:
main_worker is conducted on each GPU.
Here is the function:
def main_worker(gpu, ngpus_per_node, args):
'''
main_worker is conducted on each GPU.
'''
global best_acc1
args.gpu = gpu
# random seed has to be set for the syncronization of labeled data sampling in each process.
assert args.seed is not None
random.seed(args.seed)
torch.manual_seed(args.seed)
np.random.seed(args.seed)
cudnn.deterministic = True
# SET UP FOR DISTRIBUTED TRAINING
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
args.rank = args.rank * ngpus_per_node + gpu # compute global rank
# set distributed group:
dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
world_size=args.world_size, rank=args.rank)
# SET save_path and logger
save_path = os.path.join(args.save_dir, args.save_name)
logger_level = "WARNING"
tb_log = None
if args.rank % ngpus_per_node == 0:
tb_log = TBLog(save_path, 'tensorboard', use_tensorboard=args.use_tensorboard)
logger_level = "INFO"
logger = get_logger(args.save_name, save_path, logger_level)
logger.warning(f"USE GPU: {args.gpu} for training")
args.bn_momentum = 1.0 - 0.999
if 'imagenet' in args.dataset.lower():
_net_builder = net_builder('ResNet50', False, None, is_remix=False)
else:
_net_builder = net_builder(args.net,
args.net_from_name,
{'first_stride': 2 if 'stl' in args.dataset else 1,
'depth': args.depth,
'widen_factor': args.widen_factor,
'leaky_slope': args.leaky_slope,
'bn_momentum': args.bn_momentum,
'dropRate': args.dropout,
'use_embed': False,
'is_remix': False},
)
model = FullySupervised(_net_builder,
args.num_classes,
num_eval_iter=args.num_eval_iter,
tb_log=tb_log,
ema_m=args.ema_m,
logger=logger)
logger.info(f'Number of Trainable Params: {count_parameters(model.model)}')
# SET Optimizer & LR Scheduler
## construct SGD and cosine lr scheduler
optimizer = get_optimizer(model.model, args.optim, args.lr, args.momentum, args.weight_decay)
scheduler = get_cosine_schedule_with_warmup(optimizer,
args.num_train_iter,
num_warmup_steps=args.num_train_iter * 0)
## set SGD and cosine lr
model.set_optimizer(optimizer, scheduler)
# SET Devices for (Distributed) DataParallel
if not torch.cuda.is_available():
raise Exception('ONLY GPU TRAINING IS SUPPORTED')
elif args.distributed:
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
'''
batch_size: batch_size per node -> batch_size per gpu
workers: workers per node -> workers per gpu
'''
args.batch_size = int(args.batch_size / ngpus_per_node)
model.model.cuda(args.gpu)
model.model = torch.nn.parallel.DistributedDataParallel(model.model,
device_ids=[args.gpu],
broadcast_buffers=False,
find_unused_parameters=True)
else:
# if arg.gpu is None, DDP will divide and allocate batch_size
# to all available GPUs if device_ids are not set.
model.cuda()
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.model = model.model.cuda(args.gpu)
else:
model.model = torch.nn.DataParallel(model.model).cuda()
import copy
model.ema_model = copy.deepcopy(model.model)
logger.info(f"model_arch: {model}")
logger.info(f"Arguments: {args}")
cudnn.benchmark = True
if args.rank != 0 and args.distributed:
torch.distributed.barrier()
# Construct Dataset & DataLoader
train_dset = SSL_Dataset(args, alg='fullysupervised', name=args.dataset, train=True,
num_classes=args.num_classes, data_dir=args.data_dir)
lb_dset, ulb_dset = train_dset.get_ssl_dset(args.num_labels)
_eval_dset = SSL_Dataset(args, alg='fullysupervised', name=args.dataset, train=False,
num_classes=args.num_classes, data_dir=args.data_dir)
eval_dset = _eval_dset.get_dset()
if args.rank == 0 and args.distributed:
torch.distributed.barrier()
loader_dict = {}
dset_dict = {'train_lb': lb_dset, 'eval': eval_dset}
loader_dict['train_lb'] = get_data_loader(dset_dict['train_lb'],
args.batch_size,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=args.num_workers,
distributed=args.distributed)
loader_dict['eval'] = get_data_loader(dset_dict['eval'],
args.eval_batch_size,
num_workers=args.num_workers,
drop_last=False)
## set DataLoader
model.set_data_loader(loader_dict)
# If args.resume, load checkpoints from args.load_path
if args.resume:
model.load_model(args.load_path)
# START TRAINING
trainer = model.train
for epoch in range(args.epoch):
trainer(args)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
model.save_model('latest_model.pth', save_path)
logging.warning(f"GPU {args.rank} training is FINISHED") | main_worker is conducted on each GPU. |
157,487 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.fullysupervised.fullysupervised import FullySupervised
from datasets.ssl_dataset import SSL_Dataset
from datasets.data_utils import get_data_loader
def str2bool(v):
if isinstance(v, bool):
return v
if v.lower() in ('yes', 'true', 't', 'y', '1'):
return True
elif v.lower() in ('no', 'false', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError('Boolean value expected.') | null |
157,488 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.softmatch.softmatch import SoftMatch
from datasets.ssl_dataset import SSL_Dataset, ImageNetLoader
from datasets.data_utils import get_data_loader
def net_builder(net_name, from_name: bool, net_conf=None, is_remix=False):
"""
return **class** of backbone network (not instance).
Args
net_name: 'WideResNet' or network names in torchvision.models
from_name: If True, net_buidler takes models in torch.vision models. Then, net_conf is ignored.
net_conf: When from_name is False, net_conf is the configuration of backbone network (now, only WRN is supported).
"""
if from_name:
import torchvision.models as models
model_name_list = sorted(name for name in models.__dict__
if name.islower() and not name.startswith("__")
and callable(models.__dict__[name]))
if net_name not in model_name_list:
assert Exception(f"[!] Networks\' Name is wrong, check net config, \
expected: {model_name_list} \
received: {net_name}")
else:
return models.__dict__[net_name]
else:
if net_name == 'WideResNet':
import models.nets.wrn as net
builder = getattr(net, 'build_WideResNet')()
elif net_name == 'WideResNetVar':
import models.nets.wrn_var as net
builder = getattr(net, 'build_WideResNetVar')()
elif net_name == 'ResNet50':
import models.nets.resnet50 as net
builder = getattr(net, 'build_ResNet50')(is_remix)
else:
assert Exception("Not Implemented Error")
if net_name != 'ResNet50':
setattr_cls_from_kwargs(builder, net_conf)
return builder.build
def get_logger(name, save_path=None, level='INFO'):
logger = logging.getLogger(name)
logger.setLevel(getattr(logging, level))
log_format = logging.Formatter('[%(asctime)s %(levelname)s] %(message)s')
streamHandler = logging.StreamHandler()
streamHandler.setFormatter(log_format)
logger.addHandler(streamHandler)
if not save_path is None:
os.makedirs(save_path, exist_ok=True)
fileHandler = logging.FileHandler(os.path.join(save_path, 'log.txt'))
fileHandler.setFormatter(log_format)
logger.addHandler(fileHandler)
return logger
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
class TBLog:
"""
Construc tensorboard writer (self.writer).
The tensorboard is saved at os.path.join(tb_dir, file_name).
"""
def __init__(self, tb_dir, file_name, use_tensorboard=False):
self.tb_dir = tb_dir
self.use_tensorboard = use_tensorboard
if self.use_tensorboard:
self.writer = SummaryWriter(os.path.join(self.tb_dir, file_name))
else:
self.writer = CustomWriter(os.path.join(self.tb_dir, file_name))
def update(self, tb_dict, it, suffix=None, mode="train"):
"""
Args
tb_dict: contains scalar values for updating tensorboard
it: contains information of iteration (int).
suffix: If not None, the update key has the suffix.
"""
if suffix is None:
suffix = ''
if self.use_tensorboard:
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value, it)
else:
self.writer.set_epoch(it, mode)
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value)
self.writer.plot_stats()
self.writer.dump_stats()
def get_optimizer(net, optim_name='SGD', lr=0.1, momentum=0.9, weight_decay=0, nesterov=True, bn_wd_skip=True):
'''
return optimizer (name) in torch.optim.
If bn_wd_skip, the optimizer does not apply
weight decay regularization on parameters in batch normalization.
'''
decay = []
no_decay = []
for name, param in net.named_parameters():
if ('bn' in name or 'bias' in name) and bn_wd_skip:
no_decay.append(param)
else:
decay.append(param)
per_param_args = [{'params': decay},
{'params': no_decay, 'weight_decay': 0.0}]
if optim_name == 'SGD':
optimizer = torch.optim.SGD(per_param_args, lr=lr, momentum=momentum, weight_decay=weight_decay,
nesterov=nesterov)
elif optim_name == 'AdamW':
optimizer = torch.optim.AdamW(per_param_args, lr=lr, weight_decay=weight_decay)
return optimizer
def get_cosine_schedule_with_warmup(optimizer,
num_training_steps,
num_cycles=7. / 16.,
num_warmup_steps=0,
last_epoch=-1):
'''
Get cosine scheduler (LambdaLR).
if warmup is needed, set num_warmup_steps (int) > 0.
'''
def _lr_lambda(current_step):
'''
_lr_lambda returns a multiplicative factor given an interger parameter epochs.
Decaying criteria: last_epoch
'''
if current_step < num_warmup_steps:
_lr = float(current_step) / float(max(1, num_warmup_steps))
else:
num_cos_steps = float(current_step - num_warmup_steps)
num_cos_steps = num_cos_steps / float(max(1, num_training_steps - num_warmup_steps))
_lr = max(0.0, math.cos(math.pi * num_cycles * num_cos_steps))
return _lr
return LambdaLR(optimizer, _lr_lambda, last_epoch)
class SoftMatch:
def __init__(self, net_builder, num_classes, ema_m, lambda_u, dist_algn, \
hard_label=True, t_fn=None, p_fn=None, it=0, num_eval_iter=1000, tb_log=None, logger=None):
"""
class Freematch contains setter of data_loader, optimizer, and model update methods.
Args:
net_builder: backbone network class (see net_builder in utils.py)
num_classes: # of label classes
ema_m: momentum of exponential moving average for eval_model
lambda_u: ratio of unsupervised loss to supervised loss
hard_label: If True, consistency regularization use a hard pseudo label.
it: initial iteration count
num_eval_iter: freqeuncy of iteration (after 500,000 iters)
tb_log: tensorboard writer (see train_utils.py)
logger: logger (see utils.py)
"""
super(SoftMatch, self).__init__()
# momentum update param
self.loader = {}
self.num_classes = num_classes
self.ema_m = ema_m
# create the encoders
# network is builded only by num_classes,
# other configs are covered in main.py
self.model = net_builder(num_classes=num_classes)
self.ema_model = None
self.num_eval_iter = num_eval_iter
self.lambda_u = lambda_u
self.tb_log = tb_log
self.use_hard_label = hard_label
self.dist_align = dist_algn
self.ema_p = 0.999
self.optimizer = None
self.scheduler = None
self.it = 0
self.lst = [[] for i in range(10)]
self.abs_lst = [[] for i in range(10)]
self.clsacc = [[] for i in range(10)]
self.logger = logger
self.print_fn = print if logger is None else logger.info
self.bn_controller = Bn_Controller()
def set_data_loader(self, loader_dict):
self.loader_dict = loader_dict
self.print_fn(f'[!] data loader keys: {self.loader_dict.keys()}')
def set_dset(self, dset):
self.ulb_dset = dset
def set_optimizer(self, optimizer, scheduler=None):
self.optimizer = optimizer
self.scheduler = scheduler
def train(self, args, logger=None):
ngpus_per_node = torch.cuda.device_count()
# EMA Init
self.model.train()
self.ema = EMA(self.model, self.ema_m)
self.ema.register()
if args.resume == True:
self.ema.load(self.ema_model)
# for gpu profiling
start_batch = torch.cuda.Event(enable_timing=True)
end_batch = torch.cuda.Event(enable_timing=True)
start_run = torch.cuda.Event(enable_timing=True)
end_run = torch.cuda.Event(enable_timing=True)
start_batch.record()
best_eval_acc, best_it = 0.0, 0
scaler = GradScaler()
amp_cm = autocast if args.amp else contextlib.nullcontext
# eval for once to verify if the checkpoint is loaded correctly
if args.resume == True:
eval_dict = self.evaluate(args=args)
print(eval_dict)
self.lb_prob_t = torch.ones((args.num_classes)).cuda(args.gpu) / args.num_classes
self.ulb_prob_t = torch.ones((args.num_classes)).cuda(args.gpu) / args.num_classes
self.prob_max_mu_t = 1.0 / args.num_classes
self.prob_max_var_t = 1.0
for (_, x_lb, y_lb), (x_ulb_idx, x_ulb_w, x_ulb_s) in zip(self.loader_dict['train_lb'],
self.loader_dict['train_ulb']):
# prevent the training iterations exceed args.num_train_iter
if self.it > args.num_train_iter:
break
end_batch.record()
torch.cuda.synchronize()
start_run.record()
num_lb = x_lb.shape[0]
num_ulb = x_ulb_w.shape[0]
assert num_ulb == x_ulb_s.shape[0]
x_lb, x_ulb_w, x_ulb_s = x_lb.cuda(args.gpu), x_ulb_w.cuda(args.gpu), x_ulb_s.cuda(args.gpu)
y_lb = y_lb.cuda(args.gpu)
inputs = torch.cat((x_lb, x_ulb_w, x_ulb_s))
# inference and calculate sup/unsup losses
with amp_cm():
logits = self.model(inputs)
logits_x_lb = logits[:num_lb]
logits_x_ulb_w, logits_x_ulb_s = logits[num_lb:].chunk(2)
sup_loss = ce_loss(logits_x_lb, y_lb, reduction='mean')
# hyper-params for update
probs_x_lb = torch.softmax(logits_x_lb.detach(), dim=-1)
probs_x_ulb_w = torch.softmax(logits_x_ulb_w.detach(), dim=-1)
# update probs
self.update_prob_t(probs_x_lb, probs_x_ulb_w)
# distribution alignment
if self.dist_align:
probs_x_ulb_w = self.distribution_alignment(probs_x_ulb_w)
# calculate weight
max_probs, mask = self.calculate_mask(probs_x_ulb_w)
unsup_loss, mask = consistency_loss(logits_x_ulb_s,logits_x_ulb_w,
mask,
'ce',
use_hard_labels=args.hard_label)
total_loss = sup_loss + self.lambda_u * unsup_loss
# parameter updates
if args.amp:
scaler.scale(total_loss).backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
scaler.step(self.optimizer)
scaler.update()
else:
total_loss.backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
self.optimizer.step()
self.scheduler.step()
self.ema.update()
self.model.zero_grad()
end_run.record()
torch.cuda.synchronize()
# tensorboard_dict update
tb_dict = {}
tb_dict['train/sup_loss'] = sup_loss.item()
tb_dict['train/unsup_loss'] = unsup_loss.item()
tb_dict['train/total_loss'] = total_loss.item()
tb_dict['train/mask_ratio'] = 1.0 - mask.float().mean().item()
tb_dict['train/avg_w'] = mask.mean().item()
tb_dict['train/avg_max_prob'] = max_probs.mean().item()
tb_dict['train/avg_prob_t'] = self.ulb_prob_t.mean().item()
tb_dict['train/avg_mu_t'] = self.prob_max_mu_t
tb_dict['train/avg_var_t'] = self.prob_max_var_t
tb_dict['lr'] = self.optimizer.param_groups[0]['lr']
tb_dict['train/prefecth_time'] = start_batch.elapsed_time(end_batch) / 1000.
tb_dict['train/run_time'] = start_run.elapsed_time(end_run) / 1000.
# Save model for each 10K steps and best model for each 1K steps
if self.it % 10000 == 0:
save_path = os.path.join(args.save_dir, args.save_name)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
self.save_model('latest_model.pth', save_path)
if self.it % self.num_eval_iter == 0:
eval_dict = self.evaluate(args=args)
tb_dict.update(eval_dict)
save_path = os.path.join(args.save_dir, args.save_name)
if tb_dict['eval/top-1-acc'] > best_eval_acc:
best_eval_acc = tb_dict['eval/top-1-acc']
best_it = self.it
self.print_fn(
f"{self.it} iteration, USE_EMA: {self.ema_m != 0}, {tb_dict}, BEST_EVAL_ACC: {best_eval_acc}, at {best_it} iters")
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
if self.it == best_it:
self.save_model('model_best.pth', save_path)
if not self.tb_log is None:
self.tb_log.update(tb_dict, self.it)
self.it += 1
del tb_dict
start_batch.record()
if self.it > 0.8 * args.num_train_iter:
self.num_eval_iter = 1000
eval_dict = self.evaluate(args=args)
eval_dict.update({'eval/best_acc': best_eval_acc, 'eval/best_it': best_it})
return eval_dict
def update_prob_t(self, lb_probs, ulb_probs):
ulb_prob_t = ulb_probs.mean(0)
self.ulb_prob_t = self.ema_p * self.ulb_prob_t + (1 - self.ema_p) * ulb_prob_t
lb_prob_t = lb_probs.mean(0)
self.lb_prob_t = self.ema_p * self.lb_prob_t + (1 - self.ema_p) * lb_prob_t
max_probs, max_idx = ulb_probs.max(dim=-1)
prob_max_mu_t = torch.mean(max_probs)
prob_max_var_t = torch.var(max_probs, unbiased=True)
self.prob_max_mu_t = self.ema_p * self.prob_max_mu_t + (1 - self.ema_p) * prob_max_mu_t.item()
self.prob_max_var_t = self.ema_p * self.prob_max_var_t + (1 - self.ema_p) * prob_max_var_t.item()
def calculate_mask(self, probs):
max_probs, max_idx = probs.max(dim=-1)
# compute weight
mu = self.prob_max_mu_t
var = self.prob_max_var_t
mask = torch.exp(-((torch.clamp(max_probs - mu, max=0.0) ** 2) / (2 * var / 4)))
return max_probs.detach(), mask.detach()
def distribution_alignment(self, probs):
# da
probs = probs * self.lb_prob_t / self.ulb_prob_t
probs = probs / probs.sum(dim=1, keepdim=True)
return probs.detach()
def evaluate(self, eval_loader=None, args=None):
self.model.eval()
self.ema.apply_shadow()
if eval_loader is None:
eval_loader = self.loader_dict['eval']
total_loss = 0.0
total_num = 0.0
y_true = []
y_pred = []
y_logits = []
for _, x, y in eval_loader:
x, y = x.cuda(args.gpu), y.cuda(args.gpu)
num_batch = x.shape[0]
total_num += num_batch
logits = self.model(x)
loss = F.cross_entropy(logits, y, reduction='mean')
y_true.extend(y.cpu().tolist())
y_pred.extend(torch.max(logits, dim=-1)[1].cpu().tolist())
y_logits.extend(torch.softmax(logits, dim=-1).cpu().tolist())
total_loss += loss.detach() * num_batch
top1 = accuracy_score(y_true, y_pred)
top5 = top_k_accuracy_score(y_true, y_logits, k=5)
precision = precision_score(y_true, y_pred, average='macro')
recall = recall_score(y_true, y_pred, average='macro')
F1 = f1_score(y_true, y_pred, average='macro')
AUC = roc_auc_score(y_true, y_logits, multi_class='ovo')
cf_mat = confusion_matrix(y_true, y_pred, normalize='true')
self.print_fn('confusion matrix:\n' + np.array_str(cf_mat))
self.ema.restore()
self.model.train()
return {'eval/loss': total_loss / total_num, 'eval/top-1-acc': top1, 'eval/top-5-acc': top5,
'eval/precision': precision, 'eval/recall': recall, 'eval/F1': F1, 'eval/AUC': AUC}
def save_model(self, save_name, save_path):
save_filename = os.path.join(save_path, save_name)
# copy EMA parameters to ema_model for saving with model as temp
self.model.eval()
self.ema.apply_shadow()
ema_model = self.model.state_dict()
self.ema.restore()
self.model.train()
torch.save({'model': self.model.state_dict(),
'optimizer': self.optimizer.state_dict(),
'scheduler': self.scheduler.state_dict(),
'it': self.it,
'ema_model': ema_model},
save_filename)
self.print_fn(f"model saved: {save_filename}")
def load_model(self, load_path):
checkpoint = torch.load(load_path)
self.model.load_state_dict(checkpoint['model'])
self.ema_model = deepcopy(self.model)
self.ema_model.load_state_dict(checkpoint['ema_model'])
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.scheduler.load_state_dict(checkpoint['scheduler'])
self.it = checkpoint['it']
self.print_fn('model loaded')
class ImageNetLoader:
def __init__(self, root_path, num_labels=-1, num_class=1000):
self.root_path = os.path.join(root_path, 'imagenet')
self.num_labels = num_labels // num_class
def get_transform(self, train, ulb):
if train:
transform = transforms.Compose([
transforms.Resize([256, 256]),
transforms.RandomHorizontalFlip(),
transforms.RandomCrop(224, padding=4, padding_mode='reflect'),
transforms.ToTensor(),
transforms.Normalize(mean["imagenet"], std["imagenet"])])
else:
transform = transforms.Compose([
transforms.Resize([224, 224]),
transforms.ToTensor(),
transforms.Normalize(mean["imagenet"], std["imagenet"])])
return transform
def get_lb_train_data(self):
transform = self.get_transform(train=True, ulb=False)
data = ImagenetDataset(root=os.path.join(self.root_path, "train"), transform=transform, ulb=False,
num_labels=self.num_labels)
return data
def get_ulb_train_data(self):
transform = self.get_transform(train=True, ulb=True)
data = ImagenetDataset(root=os.path.join(self.root_path, "train"), transform=transform, ulb=True)
return data
def get_lb_test_data(self):
transform = self.get_transform(train=False, ulb=False)
data = ImagenetDataset(root=os.path.join(self.root_path, "val"), transform=transform, ulb=False)
return data
class SSL_Dataset:
"""
SSL_Dataset class gets dataset from torchvision.datasets,
separates labeled and unlabeled data,
and return BasicDataset: torch.utils.data.Dataset (see datasets.dataset.py)
"""
def __init__(self,
args,
alg='fixmatch',
name='cifar10',
train=True,
num_classes=10,
data_dir='./data'):
"""
Args
alg: SSL algorithms
name: name of dataset in torchvision.datasets (cifar10, cifar100, svhn, stl10)
train: True means the dataset is training dataset (default=True)
num_classes: number of label classes
data_dir: path of directory, where data is downloaed or stored.
"""
self.args = args
self.alg = alg
self.name = name
self.train = train
self.num_classes = num_classes
self.data_dir = data_dir
crop_size = 96 if self.name.upper() == 'STL10' else 224 if self.name.upper() == 'IMAGENET' else 32
self.transform = get_transform(mean[name], std[name], crop_size, train)
def get_data(self, svhn_extra=True):
"""
get_data returns data (images) and targets (labels)
shape of data: B, H, W, C
shape of labels: B,
"""
dset = getattr(torchvision.datasets, self.name.upper())
if 'CIFAR' in self.name.upper():
dset = dset(self.data_dir, train=self.train, download=True)
data, targets = dset.data, dset.targets
return data, targets
elif self.name.upper() == 'SVHN':
if self.train:
if svhn_extra: # train+extra
dset_base = dset(self.data_dir, split='train', download=True)
data_b, targets_b = dset_base.data.transpose([0, 2, 3, 1]), dset_base.labels
dset_extra = dset(self.data_dir, split='extra', download=True)
data_e, targets_e = dset_extra.data.transpose([0, 2, 3, 1]), dset_extra.labels
data = np.concatenate([data_b, data_e])
targets = np.concatenate([targets_b, targets_e])
del data_b, data_e
del targets_b, targets_e
else: # train_only
dset = dset(self.data_dir, split='train', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
else: # test
dset = dset(self.data_dir, split='test', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
return data, targets
elif self.name.upper() == 'STL10':
split = 'train' if self.train else 'test'
dset_lb = dset(self.data_dir, split=split, download=True)
dset_ulb = dset(self.data_dir, split='unlabeled', download=True)
data, targets = dset_lb.data.transpose([0, 2, 3, 1]), dset_lb.labels.astype(np.int64)
ulb_data = dset_ulb.data.transpose([0, 2, 3, 1])
return data, targets, ulb_data
def get_dset(self, is_ulb=False,
strong_transform=None, onehot=False):
"""
get_dset returns class BasicDataset, containing the returns of get_data.
Args
is_ulb: If True, returned dataset generates a pair of weak and strong augmented images.
strong_transform: list of strong_transform (augmentation) if use_strong_transform is True。
onehot: If True, the label is not integer, but one-hot vector.
"""
if self.name.upper() == 'STL10':
data, targets, _ = self.get_data()
else:
data, targets = self.get_data()
num_classes = self.num_classes
transform = self.transform
return BasicDataset(self.alg, data, targets, num_classes, transform,
is_ulb, strong_transform, onehot)
def get_ssl_dset(self, num_labels, index=None, include_lb_to_ulb=True,
strong_transform=None, onehot=False):
"""
get_ssl_dset split training samples into labeled and unlabeled samples.
The labeled data is balanced samples over classes.
Args:
num_labels: number of labeled data.
index: If index of np.array is given, labeled data is not randomly sampled, but use index for sampling.
include_lb_to_ulb: If True, consistency regularization is also computed for the labeled data.
strong_transform: list of strong transform (RandAugment in FixMatch)
onehot: If True, the target is converted into onehot vector.
Returns:
BasicDataset (for labeled data), BasicDataset (for unlabeld data)
"""
# Supervised top line using all data as labeled data.
if self.alg == 'fullysupervised':
lb_data, lb_targets = self.get_data()
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
return lb_dset, None
if self.name.upper() == 'STL10':
lb_data, lb_targets, ulb_data = self.get_data()
if include_lb_to_ulb:
ulb_data = np.concatenate([ulb_data, lb_data], axis=0)
lb_data, lb_targets, _ = sample_labeled_data(self.args, lb_data, lb_targets, num_labels, self.num_classes)
ulb_targets = None
else:
data, targets = self.get_data()
lb_data, lb_targets, ulb_data, ulb_targets = split_ssl_data(self.args, data, targets,
num_labels, self.num_classes,
index, include_lb_to_ulb)
# output the distribution of labeled data for remixmatch
count = [0 for _ in range(self.num_classes)]
for c in lb_targets:
count[c] += 1
dist = np.array(count, dtype=float)
dist = dist / dist.sum()
dist = dist.tolist()
out = {"distribution": dist}
output_file = r"./data_statistics/"
output_path = output_file + str(self.name) + '_' + str(num_labels) + '.json'
if not os.path.exists(output_file):
os.makedirs(output_file, exist_ok=True)
with open(output_path, 'w') as w:
json.dump(out, w)
# print(Counter(ulb_targets.tolist()))
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
ulb_dset = BasicDataset(self.alg, ulb_data, ulb_targets, self.num_classes,
self.transform, True, strong_transform, onehot)
# print(lb_data.shape)
# print(ulb_data.shape)
return lb_dset, ulb_dset
def get_data_loader(dset,
batch_size=None,
shuffle=False,
num_workers=4,
pin_memory=False,
data_sampler=None,
replacement=True,
num_epochs=None,
num_iters=None,
generator=None,
drop_last=True,
distributed=False):
"""
get_data_loader returns torch.utils.data.DataLoader for a Dataset.
All arguments are comparable with those of pytorch DataLoader.
However, if distributed, DistributedProxySampler, which is a wrapper of data_sampler, is used.
Args
num_epochs: total batch -> (# of batches in dset) * num_epochs
num_iters: total batch -> num_iters
"""
assert batch_size is not None
if data_sampler is None:
return DataLoader(dset, batch_size=batch_size, shuffle=shuffle,
num_workers=num_workers, pin_memory=pin_memory)
else:
if isinstance(data_sampler, str):
data_sampler = get_sampler_by_name(data_sampler)
if distributed:
assert dist.is_available()
num_replicas = dist.get_world_size()
else:
num_replicas = 1
if (num_epochs is not None) and (num_iters is None):
num_samples = len(dset) * num_epochs
elif (num_epochs is None) and (num_iters is not None):
num_samples = batch_size * num_iters * num_replicas
else:
num_samples = len(dset)
if data_sampler.__name__ == 'RandomSampler':
data_sampler = data_sampler(dset, replacement, num_samples, generator)
else:
raise RuntimeError(f"{data_sampler.__name__} is not implemented.")
if distributed:
'''
Different with DistributedSampler,
the DistribuedProxySampler does not shuffle the data (just wrapper for dist).
'''
data_sampler = DistributedProxySampler(data_sampler)
batch_sampler = BatchSampler(data_sampler, batch_size, drop_last)
return DataLoader(dset, batch_sampler=batch_sampler,
num_workers=num_workers, pin_memory=pin_memory)
The provided code snippet includes necessary dependencies for implementing the `main_worker` function. Write a Python function `def main_worker(gpu, ngpus_per_node, args)` to solve the following problem:
main_worker is conducted on each GPU.
Here is the function:
def main_worker(gpu, ngpus_per_node, args):
'''
main_worker is conducted on each GPU.
'''
global best_acc1
args.gpu = gpu
# random seed has to be set for the syncronization of labeled data sampling in each process.
assert args.seed is not None
random.seed(args.seed)
torch.manual_seed(args.seed)
np.random.seed(args.seed)
cudnn.deterministic = True
# SET UP FOR DISTRIBUTED TRAINING
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
args.rank = args.rank * ngpus_per_node + gpu # compute global rank
# set distributed group:
dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
world_size=args.world_size, rank=args.rank)
# SET save_path and logger
save_path = os.path.join(args.save_dir, args.save_name)
logger_level = "WARNING"
tb_log = None
if args.rank % ngpus_per_node == 0:
tb_log = TBLog(save_path, 'tensorboard', use_tensorboard=args.use_tensorboard)
logger_level = "INFO"
logger = get_logger(args.save_name, save_path, logger_level)
logger.warning(f"USE GPU: {args.gpu} for training")
# SET FreeMatch: class FreeMatch in models.freematch
args.bn_momentum = 1.0 - 0.999
if 'imagenet' in args.dataset.lower():
_net_builder = net_builder('ResNet50', False, None, is_remix=False)
args.lr = 0.1
else:
_net_builder = net_builder(args.net,
args.net_from_name,
{'first_stride': 2 if 'stl' in args.dataset else 1,
'depth': args.depth,
'widen_factor': args.widen_factor,
'leaky_slope': args.leaky_slope,
'bn_momentum': args.bn_momentum,
'dropRate': args.dropout,
'use_embed': False,
'is_remix': False},
)
model = SoftMatch(_net_builder,
args.num_classes,
args.ema_m,
args.ulb_loss_ratio,
args.dist_align,
args.hard_label,
num_eval_iter=args.num_eval_iter,
tb_log=tb_log,
logger=logger)
logger.info(f'Number of Trainable Params: {count_parameters(model.model)}')
# SET Optimizer & LR Scheduler
## construct SGD and cosine lr scheduler
optimizer = get_optimizer(model.model, args.optim, args.lr, args.momentum, args.weight_decay)
scheduler = get_cosine_schedule_with_warmup(optimizer,
args.num_train_iter,
num_warmup_steps=args.num_train_iter * 0)
## set SGD and cosine lr on FreeMatch
model.set_optimizer(optimizer, scheduler)
# SET Devices for (Distributed) DataParallel
if not torch.cuda.is_available():
raise Exception('ONLY GPU TRAINING IS SUPPORTED')
elif args.distributed:
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
'''
batch_size: batch_size per node -> batch_size per gpu
workers: workers per node -> workers per gpu
'''
args.batch_size = int(args.batch_size / ngpus_per_node)
model.model.cuda(args.gpu)
model.model = nn.SyncBatchNorm.convert_sync_batchnorm(model.model)
model.model = torch.nn.parallel.DistributedDataParallel(model.model,
device_ids=[args.gpu],
broadcast_buffers=False,
find_unused_parameters=True)
else:
# if arg.gpu is None, DDP will divide and allocate batch_size
# to all available GPUs if device_ids are not set.
model.cuda()
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.model = model.model.cuda(args.gpu)
else:
model.model = torch.nn.DataParallel(model.model).cuda()
import copy
model.ema_model = copy.deepcopy(model.model)
logger.info(f"model_arch: {model}")
logger.info(f"Arguments: {args}")
cudnn.benchmark = True
if args.rank != 0:
torch.distributed.barrier()
# Construct Dataset & DataLoader
if args.dataset != "imagenet":
if args.num_labels == 10 and args.dataset == 'cifar10':
fixmatch_index = [
[7408, 8148, 9850, 10361, 33949, 36506, 37018, 45044, 46443, 47447],
[5022, 8193, 8902, 9601, 25226, 26223, 34089, 35186, 40595, 48024],
[7510, 13186, 14043, 21305, 22805, 31288, 34508, 40470, 41493, 45506],
[9915, 9978, 16631, 19915, 28008, 35314, 35801, 36149, 39215, 42557],
[6695, 14891, 19726, 22715, 23999, 34230, 46511, 47457, 49181, 49397],
[12830, 20293, 26835, 30517, 30898, 31061, 43693, 46501, 47310, 48517],
[1156, 11501, 19974, 21963, 32103, 42189, 46789, 47690, 48229, 48675],
[4255, 6446, 8580, 11759, 12598, 29349, 29433, 33759, 35345, 38639]]
index = fixmatch_index[-args.seed - 1]
print("10 labels for cifar10")
else:
index = None
train_dset = SSL_Dataset(args, alg='freematch', name=args.dataset, train=True,
num_classes=args.num_classes, data_dir=args.data_dir)
lb_dset, ulb_dset = train_dset.get_ssl_dset(args.num_labels)
_eval_dset = SSL_Dataset(args, alg='freematch', name=args.dataset, train=False,
num_classes=args.num_classes, data_dir=args.data_dir)
eval_dset = _eval_dset.get_dset()
else:
image_loader = ImageNetLoader(root_path=args.data_dir, num_labels=args.num_labels,
num_class=args.num_classes)
lb_dset = image_loader.get_lb_train_data()
ulb_dset = image_loader.get_ulb_train_data()
eval_dset = image_loader.get_lb_test_data()
if args.rank == 0:
torch.distributed.barrier()
loader_dict = {}
dset_dict = {'train_lb': lb_dset, 'train_ulb': ulb_dset, 'eval': eval_dset}
loader_dict['train_lb'] = get_data_loader(dset_dict['train_lb'],
args.batch_size,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=args.num_workers,
distributed=args.distributed)
loader_dict['train_ulb'] = get_data_loader(dset_dict['train_ulb'],
args.batch_size * args.uratio,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=4 * args.num_workers,
distributed=args.distributed)
loader_dict['eval'] = get_data_loader(dset_dict['eval'],
args.eval_batch_size,
num_workers=args.num_workers,
drop_last=False)
## set DataLoader on FreeMatch
model.set_data_loader(loader_dict)
model.set_dset(ulb_dset)
# If args.resume, load checkpoints from args.load_path
if args.resume:
model.load_model(args.load_path)
# START TRAINING of FreeMatch
trainer = model.train
for epoch in range(args.epoch):
trainer(args, logger=logger)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
model.save_model('latest_model.pth', save_path)
logging.warning(f"GPU {args.rank} training is FINISHED") | main_worker is conducted on each GPU. |
157,489 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.softmatch.softmatch import SoftMatch
from datasets.ssl_dataset import SSL_Dataset, ImageNetLoader
from datasets.data_utils import get_data_loader
def str2bool(v):
if isinstance(v, bool):
return v
if v.lower() in ('yes', 'true', 't', 'y', '1'):
return True
elif v.lower() in ('no', 'false', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError('Boolean value expected.') | null |
157,490 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.vat.vat import Vat
from datasets.ssl_dataset import SSL_Dataset
from datasets.data_utils import get_data_loader
def net_builder(net_name, from_name: bool, net_conf=None, is_remix=False):
"""
return **class** of backbone network (not instance).
Args
net_name: 'WideResNet' or network names in torchvision.models
from_name: If True, net_buidler takes models in torch.vision models. Then, net_conf is ignored.
net_conf: When from_name is False, net_conf is the configuration of backbone network (now, only WRN is supported).
"""
if from_name:
import torchvision.models as models
model_name_list = sorted(name for name in models.__dict__
if name.islower() and not name.startswith("__")
and callable(models.__dict__[name]))
if net_name not in model_name_list:
assert Exception(f"[!] Networks\' Name is wrong, check net config, \
expected: {model_name_list} \
received: {net_name}")
else:
return models.__dict__[net_name]
else:
if net_name == 'WideResNet':
import models.nets.wrn as net
builder = getattr(net, 'build_WideResNet')()
elif net_name == 'WideResNetVar':
import models.nets.wrn_var as net
builder = getattr(net, 'build_WideResNetVar')()
elif net_name == 'ResNet50':
import models.nets.resnet50 as net
builder = getattr(net, 'build_ResNet50')(is_remix)
else:
assert Exception("Not Implemented Error")
if net_name != 'ResNet50':
setattr_cls_from_kwargs(builder, net_conf)
return builder.build
def get_logger(name, save_path=None, level='INFO'):
logger = logging.getLogger(name)
logger.setLevel(getattr(logging, level))
log_format = logging.Formatter('[%(asctime)s %(levelname)s] %(message)s')
streamHandler = logging.StreamHandler()
streamHandler.setFormatter(log_format)
logger.addHandler(streamHandler)
if not save_path is None:
os.makedirs(save_path, exist_ok=True)
fileHandler = logging.FileHandler(os.path.join(save_path, 'log.txt'))
fileHandler.setFormatter(log_format)
logger.addHandler(fileHandler)
return logger
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
class TBLog:
"""
Construc tensorboard writer (self.writer).
The tensorboard is saved at os.path.join(tb_dir, file_name).
"""
def __init__(self, tb_dir, file_name, use_tensorboard=False):
self.tb_dir = tb_dir
self.use_tensorboard = use_tensorboard
if self.use_tensorboard:
self.writer = SummaryWriter(os.path.join(self.tb_dir, file_name))
else:
self.writer = CustomWriter(os.path.join(self.tb_dir, file_name))
def update(self, tb_dict, it, suffix=None, mode="train"):
"""
Args
tb_dict: contains scalar values for updating tensorboard
it: contains information of iteration (int).
suffix: If not None, the update key has the suffix.
"""
if suffix is None:
suffix = ''
if self.use_tensorboard:
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value, it)
else:
self.writer.set_epoch(it, mode)
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value)
self.writer.plot_stats()
self.writer.dump_stats()
def get_optimizer(net, optim_name='SGD', lr=0.1, momentum=0.9, weight_decay=0, nesterov=True, bn_wd_skip=True):
'''
return optimizer (name) in torch.optim.
If bn_wd_skip, the optimizer does not apply
weight decay regularization on parameters in batch normalization.
'''
decay = []
no_decay = []
for name, param in net.named_parameters():
if ('bn' in name or 'bias' in name) and bn_wd_skip:
no_decay.append(param)
else:
decay.append(param)
per_param_args = [{'params': decay},
{'params': no_decay, 'weight_decay': 0.0}]
if optim_name == 'SGD':
optimizer = torch.optim.SGD(per_param_args, lr=lr, momentum=momentum, weight_decay=weight_decay,
nesterov=nesterov)
elif optim_name == 'AdamW':
optimizer = torch.optim.AdamW(per_param_args, lr=lr, weight_decay=weight_decay)
return optimizer
def get_cosine_schedule_with_warmup(optimizer,
num_training_steps,
num_cycles=7. / 16.,
num_warmup_steps=0,
last_epoch=-1):
'''
Get cosine scheduler (LambdaLR).
if warmup is needed, set num_warmup_steps (int) > 0.
'''
def _lr_lambda(current_step):
'''
_lr_lambda returns a multiplicative factor given an interger parameter epochs.
Decaying criteria: last_epoch
'''
if current_step < num_warmup_steps:
_lr = float(current_step) / float(max(1, num_warmup_steps))
else:
num_cos_steps = float(current_step - num_warmup_steps)
num_cos_steps = num_cos_steps / float(max(1, num_training_steps - num_warmup_steps))
_lr = max(0.0, math.cos(math.pi * num_cycles * num_cos_steps))
return _lr
return LambdaLR(optimizer, _lr_lambda, last_epoch)
class Vat:
def __init__(self, net_builder, num_classes, lambda_u,
num_eval_iter=1000, tb_log=None, ema_m=0.999, logger=None):
"""
class Vat contains setter of data_loader, optimizer, and model update methods.
Args:
net_builder: backbone network class (see net_builder in utils.py)
num_classes: # of label classes
lambda_u: ratio of unsupervised loss to supervised loss
it: initial iteration count
num_eval_iter: frequency of evaluation.
tb_log: tensorboard writer (see train_utils.py)
logger: logger (see utils.py)
"""
super(Vat, self).__init__()
# momentum update param
self.loader = {}
self.num_classes = num_classes
self.ema_m = ema_m
# create the encoders
# network is builded only by num_classes,
# other configs are covered in main.py
self.model = net_builder(num_classes=num_classes)
self.ema_model = deepcopy(self.model)
self.num_eval_iter = num_eval_iter
self.lambda_u = lambda_u
self.tb_log = tb_log
self.optimizer = None
self.scheduler = None
self.it = 0
self.logger = logger
self.print_fn = print if logger is None else logger.info
self.bn_controller = Bn_Controller()
def set_data_loader(self, loader_dict):
self.loader_dict = loader_dict
self.print_fn(f'[!] data loader keys: {self.loader_dict.keys()}')
def set_optimizer(self, optimizer, scheduler=None):
self.optimizer = optimizer
self.scheduler = scheduler
def train(self, args):
ngpus_per_node = torch.cuda.device_count()
# EMA init
self.model.train()
self.ema = EMA(self.model, self.ema_m)
self.ema.register()
if args.resume == True:
self.ema.load(self.ema_model)
# for gpu profiling
start_batch = torch.cuda.Event(enable_timing=True)
end_batch = torch.cuda.Event(enable_timing=True)
start_run = torch.cuda.Event(enable_timing=True)
end_run = torch.cuda.Event(enable_timing=True)
start_batch.record()
best_eval_acc, best_it = 0.0, 0
scaler = GradScaler()
amp_cm = autocast if args.amp else contextlib.nullcontext
# eval for once to verify if the checkpoint is loaded correctly
if args.resume == True:
eval_dict = self.evaluate(args=args)
print(eval_dict)
for (_, x_lb, y_lb), (_, x_ulb_w) in zip(self.loader_dict['train_lb'], self.loader_dict['train_ulb']):
# prevent the training iterations exceed args.num_train_iter
if self.it > args.num_train_iter:
break
unsup_warmup = np.clip(self.it / (args.unsup_warmup_pos * args.num_train_iter),
a_min=0.0, a_max=1.0)
end_batch.record()
torch.cuda.synchronize()
start_run.record()
x_lb, x_ulb_w = x_lb.cuda(args.gpu), x_ulb_w.cuda(args.gpu)
y_lb = y_lb.cuda(args.gpu)
num_lb = x_lb.shape[0]
# inference and calculate sup/unsup losses
with amp_cm():
logits_x_lb = self.model(x_lb)
sup_loss = ce_loss(logits_x_lb, y_lb, reduction='mean')
self.bn_controller.freeze_bn(self.model)
ul_y = self.model(x_ulb_w)
unsup_loss = vat_loss(self.model, x_ulb_w, ul_y, eps=args.vat_eps)
loss_entmin = entropy_loss(ul_y)
self.bn_controller.unfreeze_bn(self.model)
total_loss = sup_loss + self.lambda_u * unsup_loss * unsup_warmup + args.entmin_weight * loss_entmin
# parameter updates
if args.amp:
scaler.scale(total_loss).backward()
if (args.clip > 0):
scaler.unscale_(self.optimizer)
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
scaler.step(self.optimizer)
scaler.update()
else:
total_loss.backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
self.optimizer.step()
if args.optim == 'SGD':
self.scheduler.step()
self.ema.update()
self.model.zero_grad()
end_run.record()
torch.cuda.synchronize()
# tensorboard_dict update
tb_dict = {}
tb_dict['train/sup_loss'] = sup_loss.detach()
tb_dict['train/unsup_loss'] = unsup_loss.detach()
tb_dict['train/loss_entmin'] = loss_entmin.detach()
tb_dict['train/total_loss'] = total_loss.detach()
tb_dict['lr'] = self.optimizer.param_groups[0]['lr']
tb_dict['train/prefecth_time'] = start_batch.elapsed_time(end_batch) / 1000.
tb_dict['train/run_time'] = start_run.elapsed_time(end_run) / 1000.
# save model for each 10K steps and best model for each num_eval_iter steps
if self.it % 10000 == 0:
save_path = os.path.join(args.save_dir, args.save_name)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
self.save_model('latest_model.pth', save_path)
if self.it % self.num_eval_iter == 0:
eval_dict = self.evaluate(args=args)
tb_dict.update(eval_dict)
save_path = os.path.join(args.save_dir, args.save_name)
if tb_dict['eval/top-1-acc'] > best_eval_acc:
best_eval_acc = tb_dict['eval/top-1-acc']
best_it = self.it
self.print_fn(
f"{self.it} iteration, USE_EMA: {self.ema_m != 0}, {tb_dict}, BEST_EVAL_ACC: {best_eval_acc}, at {best_it} iters")
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
if self.it == best_it:
self.save_model('model_best.pth', save_path)
if not self.tb_log is None:
self.tb_log.update(tb_dict, self.it)
self.it += 1
del tb_dict
start_batch.record()
if self.it > 0.8 * args.num_train_iter:
self.num_eval_iter = 1000
eval_dict = self.evaluate(args=args)
eval_dict.update({'eval/best_acc': best_eval_acc, 'eval/best_it': best_it})
return eval_dict
def evaluate(self, eval_loader=None, args=None):
self.model.eval()
self.ema.apply_shadow()
if eval_loader is None:
eval_loader = self.loader_dict['eval']
total_loss = 0.0
total_num = 0.0
y_true = []
y_pred = []
y_logits = []
for _, x, y in eval_loader:
x, y = x.cuda(args.gpu), y.cuda(args.gpu)
num_batch = x.shape[0]
total_num += num_batch
logits = self.model(x)
loss = F.cross_entropy(logits, y, reduction='mean')
y_true.extend(y.cpu().tolist())
y_pred.extend(torch.max(logits, dim=-1)[1].cpu().tolist())
y_logits.extend(torch.softmax(logits, dim=-1).cpu().tolist())
total_loss += loss.detach() * num_batch
top1 = accuracy_score(y_true, y_pred)
top5 = top_k_accuracy_score(y_true, y_logits, k=5)
cf_mat = confusion_matrix(y_true, y_pred, normalize='true')
self.print_fn('confusion matrix:\n' + np.array_str(cf_mat))
self.ema.restore()
self.model.train()
return {'eval/loss': total_loss / total_num, 'eval/top-1-acc': top1, 'eval/top-5-acc': top5}
def save_model(self, save_name, save_path):
save_filename = os.path.join(save_path, save_name)
# copy EMA parameters to ema_model for saving with model as temp
self.model.eval()
self.ema.apply_shadow()
ema_model = self.model.state_dict()
self.ema.restore()
self.model.train()
torch.save({'model': self.model.state_dict(),
'optimizer': self.optimizer.state_dict(),
'scheduler': self.scheduler.state_dict(),
'it': self.it + 1,
'ema_model': ema_model},
save_filename)
self.print_fn(f"model saved: {save_filename}")
def load_model(self, load_path):
checkpoint = torch.load(load_path)
self.model.load_state_dict(checkpoint['model'])
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.scheduler.load_state_dict(checkpoint['scheduler'])
self.it = checkpoint['it']
self.ema_model.load_state_dict(checkpoint['ema_model'])
self.print_fn('model loaded')
# Abandoned in Pseudo Label
def interleave_offsets(self, batch, nu):
groups = [batch // (nu + 1)] * (nu + 1)
for x in range(batch - sum(groups)):
groups[-x - 1] += 1
offsets = [0]
for g in groups:
offsets.append(offsets[-1] + g)
assert offsets[-1] == batch
return offsets
def interleave(self, xy, batch):
nu = len(xy) - 1
offsets = self.interleave_offsets(batch, nu)
xy = [[v[offsets[p]:offsets[p + 1]] for p in range(nu + 1)] for v in xy]
for i in range(1, nu + 1):
xy[0][i], xy[i][i] = xy[i][i], xy[0][i]
return [torch.cat(v, dim=0) for v in xy]
class SSL_Dataset:
"""
SSL_Dataset class gets dataset from torchvision.datasets,
separates labeled and unlabeled data,
and return BasicDataset: torch.utils.data.Dataset (see datasets.dataset.py)
"""
def __init__(self,
args,
alg='fixmatch',
name='cifar10',
train=True,
num_classes=10,
data_dir='./data'):
"""
Args
alg: SSL algorithms
name: name of dataset in torchvision.datasets (cifar10, cifar100, svhn, stl10)
train: True means the dataset is training dataset (default=True)
num_classes: number of label classes
data_dir: path of directory, where data is downloaed or stored.
"""
self.args = args
self.alg = alg
self.name = name
self.train = train
self.num_classes = num_classes
self.data_dir = data_dir
crop_size = 96 if self.name.upper() == 'STL10' else 224 if self.name.upper() == 'IMAGENET' else 32
self.transform = get_transform(mean[name], std[name], crop_size, train)
def get_data(self, svhn_extra=True):
"""
get_data returns data (images) and targets (labels)
shape of data: B, H, W, C
shape of labels: B,
"""
dset = getattr(torchvision.datasets, self.name.upper())
if 'CIFAR' in self.name.upper():
dset = dset(self.data_dir, train=self.train, download=True)
data, targets = dset.data, dset.targets
return data, targets
elif self.name.upper() == 'SVHN':
if self.train:
if svhn_extra: # train+extra
dset_base = dset(self.data_dir, split='train', download=True)
data_b, targets_b = dset_base.data.transpose([0, 2, 3, 1]), dset_base.labels
dset_extra = dset(self.data_dir, split='extra', download=True)
data_e, targets_e = dset_extra.data.transpose([0, 2, 3, 1]), dset_extra.labels
data = np.concatenate([data_b, data_e])
targets = np.concatenate([targets_b, targets_e])
del data_b, data_e
del targets_b, targets_e
else: # train_only
dset = dset(self.data_dir, split='train', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
else: # test
dset = dset(self.data_dir, split='test', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
return data, targets
elif self.name.upper() == 'STL10':
split = 'train' if self.train else 'test'
dset_lb = dset(self.data_dir, split=split, download=True)
dset_ulb = dset(self.data_dir, split='unlabeled', download=True)
data, targets = dset_lb.data.transpose([0, 2, 3, 1]), dset_lb.labels.astype(np.int64)
ulb_data = dset_ulb.data.transpose([0, 2, 3, 1])
return data, targets, ulb_data
def get_dset(self, is_ulb=False,
strong_transform=None, onehot=False):
"""
get_dset returns class BasicDataset, containing the returns of get_data.
Args
is_ulb: If True, returned dataset generates a pair of weak and strong augmented images.
strong_transform: list of strong_transform (augmentation) if use_strong_transform is True。
onehot: If True, the label is not integer, but one-hot vector.
"""
if self.name.upper() == 'STL10':
data, targets, _ = self.get_data()
else:
data, targets = self.get_data()
num_classes = self.num_classes
transform = self.transform
return BasicDataset(self.alg, data, targets, num_classes, transform,
is_ulb, strong_transform, onehot)
def get_ssl_dset(self, num_labels, index=None, include_lb_to_ulb=True,
strong_transform=None, onehot=False):
"""
get_ssl_dset split training samples into labeled and unlabeled samples.
The labeled data is balanced samples over classes.
Args:
num_labels: number of labeled data.
index: If index of np.array is given, labeled data is not randomly sampled, but use index for sampling.
include_lb_to_ulb: If True, consistency regularization is also computed for the labeled data.
strong_transform: list of strong transform (RandAugment in FixMatch)
onehot: If True, the target is converted into onehot vector.
Returns:
BasicDataset (for labeled data), BasicDataset (for unlabeld data)
"""
# Supervised top line using all data as labeled data.
if self.alg == 'fullysupervised':
lb_data, lb_targets = self.get_data()
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
return lb_dset, None
if self.name.upper() == 'STL10':
lb_data, lb_targets, ulb_data = self.get_data()
if include_lb_to_ulb:
ulb_data = np.concatenate([ulb_data, lb_data], axis=0)
lb_data, lb_targets, _ = sample_labeled_data(self.args, lb_data, lb_targets, num_labels, self.num_classes)
ulb_targets = None
else:
data, targets = self.get_data()
lb_data, lb_targets, ulb_data, ulb_targets = split_ssl_data(self.args, data, targets,
num_labels, self.num_classes,
index, include_lb_to_ulb)
# output the distribution of labeled data for remixmatch
count = [0 for _ in range(self.num_classes)]
for c in lb_targets:
count[c] += 1
dist = np.array(count, dtype=float)
dist = dist / dist.sum()
dist = dist.tolist()
out = {"distribution": dist}
output_file = r"./data_statistics/"
output_path = output_file + str(self.name) + '_' + str(num_labels) + '.json'
if not os.path.exists(output_file):
os.makedirs(output_file, exist_ok=True)
with open(output_path, 'w') as w:
json.dump(out, w)
# print(Counter(ulb_targets.tolist()))
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
ulb_dset = BasicDataset(self.alg, ulb_data, ulb_targets, self.num_classes,
self.transform, True, strong_transform, onehot)
# print(lb_data.shape)
# print(ulb_data.shape)
return lb_dset, ulb_dset
def get_data_loader(dset,
batch_size=None,
shuffle=False,
num_workers=4,
pin_memory=False,
data_sampler=None,
replacement=True,
num_epochs=None,
num_iters=None,
generator=None,
drop_last=True,
distributed=False):
"""
get_data_loader returns torch.utils.data.DataLoader for a Dataset.
All arguments are comparable with those of pytorch DataLoader.
However, if distributed, DistributedProxySampler, which is a wrapper of data_sampler, is used.
Args
num_epochs: total batch -> (# of batches in dset) * num_epochs
num_iters: total batch -> num_iters
"""
assert batch_size is not None
if data_sampler is None:
return DataLoader(dset, batch_size=batch_size, shuffle=shuffle,
num_workers=num_workers, pin_memory=pin_memory)
else:
if isinstance(data_sampler, str):
data_sampler = get_sampler_by_name(data_sampler)
if distributed:
assert dist.is_available()
num_replicas = dist.get_world_size()
else:
num_replicas = 1
if (num_epochs is not None) and (num_iters is None):
num_samples = len(dset) * num_epochs
elif (num_epochs is None) and (num_iters is not None):
num_samples = batch_size * num_iters * num_replicas
else:
num_samples = len(dset)
if data_sampler.__name__ == 'RandomSampler':
data_sampler = data_sampler(dset, replacement, num_samples, generator)
else:
raise RuntimeError(f"{data_sampler.__name__} is not implemented.")
if distributed:
'''
Different with DistributedSampler,
the DistribuedProxySampler does not shuffle the data (just wrapper for dist).
'''
data_sampler = DistributedProxySampler(data_sampler)
batch_sampler = BatchSampler(data_sampler, batch_size, drop_last)
return DataLoader(dset, batch_sampler=batch_sampler,
num_workers=num_workers, pin_memory=pin_memory)
The provided code snippet includes necessary dependencies for implementing the `main_worker` function. Write a Python function `def main_worker(gpu, ngpus_per_node, args)` to solve the following problem:
main_worker is conducted on each GPU.
Here is the function:
def main_worker(gpu, ngpus_per_node, args):
'''
main_worker is conducted on each GPU.
'''
global best_acc1
args.gpu = gpu
# random seed has to be set for the syncronization of labeled data sampling in each process.
assert args.seed is not None
random.seed(args.seed )
torch.manual_seed(args.seed )
np.random.seed(args.seed )
cudnn.deterministic = True
# SET UP FOR DISTRIBUTED TRAINING
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
args.rank = args.rank * ngpus_per_node + gpu # compute global rank
# set distributed group:
dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
world_size=args.world_size, rank=args.rank)
# SET save_path and logger
save_path = os.path.join(args.save_dir, args.save_name)
logger_level = "WARNING"
tb_log = None
if args.rank % ngpus_per_node == 0:
tb_log = TBLog(save_path, 'tensorboard', use_tensorboard=args.use_tensorboard)
logger_level = "INFO"
logger = get_logger(args.save_name, save_path, logger_level)
logger.warning(f"USE GPU: {args.gpu} for training")
args.bn_momentum = 1.0 - 0.999
if 'imagenet' in args.dataset.lower():
_net_builder = net_builder('ResNet50', False, None, is_remix=False)
else:
_net_builder = net_builder(args.net,
args.net_from_name,
{'first_stride': 2 if 'stl' in args.dataset else 1,
'depth': args.depth,
'widen_factor': args.widen_factor,
'leaky_slope': args.leaky_slope,
'bn_momentum': args.bn_momentum,
'dropRate': args.dropout,
'use_embed': False,
'is_remix': False},
)
model = Vat(_net_builder,
args.num_classes,
args.vat_weight,
num_eval_iter=args.num_eval_iter,
tb_log=tb_log,
ema_m=args.ema_m,
logger=logger)
logger.info(f'Number of Trainable Params: {count_parameters(model.model)}')
# SET Optimizer & LR Scheduler
## construct SGD and cosine lr scheduler
optimizer = get_optimizer(model.model, args.optim, args.lr, args.momentum, args.weight_decay)
scheduler = get_cosine_schedule_with_warmup(optimizer,
args.num_train_iter,
num_warmup_steps=args.num_train_iter * 0)
## set SGD and cosine lr
model.set_optimizer(optimizer, scheduler)
# SET Devices for (Distributed) DataParallel
if not torch.cuda.is_available():
raise Exception('ONLY GPU TRAINING IS SUPPORTED')
elif args.distributed:
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
'''
batch_size: batch_size per node -> batch_size per gpu
workers: workers per node -> workers per gpu
'''
args.batch_size = int(args.batch_size / ngpus_per_node)
model.model.cuda(args.gpu)
model.model = nn.SyncBatchNorm.convert_sync_batchnorm(model.model)
model.model = torch.nn.parallel.DistributedDataParallel(model.model,
device_ids=[args.gpu],
broadcast_buffers=False,
find_unused_parameters=True)
else:
# if arg.gpu is None, DDP will divide and allocate batch_size
# to all available GPUs if device_ids are not set.
model.cuda()
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.model = model.model.cuda(args.gpu)
else:
model.model = torch.nn.DataParallel(model.model).cuda()
import copy
model.ema_model = copy.deepcopy(model.model)
logger.info(f"model_arch: {model}")
logger.info(f"Arguments: {args}")
cudnn.benchmark = True
if args.rank != 0 and args.distributed:
torch.distributed.barrier()
# Construct Dataset & DataLoader
if args.dataset != "imagenet":
if args.num_labels == 10 and args.dataset == 'cifar10':
fixmatch_index = [
[7408, 8148, 9850, 10361, 33949, 36506, 37018, 45044, 46443, 47447],
[5022, 8193, 8902, 9601, 25226, 26223, 34089, 35186, 40595, 48024],
[7510, 13186, 14043, 21305, 22805, 31288, 34508, 40470, 41493, 45506],
[9915, 9978, 16631, 19915, 28008, 35314, 35801, 36149, 39215, 42557],
[6695, 14891, 19726, 22715, 23999, 34230, 46511, 47457, 49181, 49397],
[12830, 20293, 26835, 30517, 30898, 31061, 43693, 46501, 47310, 48517],
[1156, 11501, 19974, 21963, 32103, 42189, 46789, 47690, 48229, 48675],
[4255, 6446, 8580, 11759, 12598, 29349, 29433, 33759, 35345, 38639]]
index = fixmatch_index[-args.seed - 1]
print("10 labels for cifar10")
else:
index = None
train_dset = SSL_Dataset(args, alg='vat', name=args.dataset, train=True,
num_classes=args.num_classes, data_dir=args.data_dir)
lb_dset, ulb_dset = train_dset.get_ssl_dset(args.num_labels,index=index)
_eval_dset = SSL_Dataset(args, alg='vat', name=args.dataset, train=False,
num_classes=args.num_classes, data_dir=args.data_dir)
eval_dset = _eval_dset.get_dset()
if args.rank == 0 and args.distributed:
torch.distributed.barrier()
loader_dict = {}
dset_dict = {'train_lb': lb_dset, 'train_ulb': ulb_dset, 'eval': eval_dset}
loader_dict['train_lb'] = get_data_loader(dset_dict['train_lb'],
args.batch_size,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=args.num_workers,
distributed=args.distributed)
loader_dict['train_ulb'] = get_data_loader(dset_dict['train_ulb'],
args.batch_size * args.uratio,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=4 * args.num_workers,
distributed=args.distributed)
loader_dict['eval'] = get_data_loader(dset_dict['eval'],
args.eval_batch_size,
num_workers=args.num_workers,
drop_last=False)
## set DataLoader
model.set_data_loader(loader_dict)
# If args.resume, load checkpoints from args.load_path
if args.resume:
model.load_model(args.load_path)
# START TRAINING
trainer = model.train
for epoch in range(args.epoch):
trainer(args)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
model.save_model('latest_model.pth', save_path)
logging.warning(f"GPU {args.rank} training is FINISHED") | main_worker is conducted on each GPU. |
157,491 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.vat.vat import Vat
from datasets.ssl_dataset import SSL_Dataset
from datasets.data_utils import get_data_loader
def str2bool(v):
if isinstance(v, bool):
return v
if v.lower() in ('yes', 'true', 't', 'y', '1'):
return True
elif v.lower() in ('no', 'false', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError('Boolean value expected.') | null |
157,492 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.pimodel.pimodel import PiModel
from datasets.ssl_dataset import SSL_Dataset
from datasets.data_utils import get_data_loader
def net_builder(net_name, from_name: bool, net_conf=None, is_remix=False):
"""
return **class** of backbone network (not instance).
Args
net_name: 'WideResNet' or network names in torchvision.models
from_name: If True, net_buidler takes models in torch.vision models. Then, net_conf is ignored.
net_conf: When from_name is False, net_conf is the configuration of backbone network (now, only WRN is supported).
"""
if from_name:
import torchvision.models as models
model_name_list = sorted(name for name in models.__dict__
if name.islower() and not name.startswith("__")
and callable(models.__dict__[name]))
if net_name not in model_name_list:
assert Exception(f"[!] Networks\' Name is wrong, check net config, \
expected: {model_name_list} \
received: {net_name}")
else:
return models.__dict__[net_name]
else:
if net_name == 'WideResNet':
import models.nets.wrn as net
builder = getattr(net, 'build_WideResNet')()
elif net_name == 'WideResNetVar':
import models.nets.wrn_var as net
builder = getattr(net, 'build_WideResNetVar')()
elif net_name == 'ResNet50':
import models.nets.resnet50 as net
builder = getattr(net, 'build_ResNet50')(is_remix)
else:
assert Exception("Not Implemented Error")
if net_name != 'ResNet50':
setattr_cls_from_kwargs(builder, net_conf)
return builder.build
def get_logger(name, save_path=None, level='INFO'):
logger = logging.getLogger(name)
logger.setLevel(getattr(logging, level))
log_format = logging.Formatter('[%(asctime)s %(levelname)s] %(message)s')
streamHandler = logging.StreamHandler()
streamHandler.setFormatter(log_format)
logger.addHandler(streamHandler)
if not save_path is None:
os.makedirs(save_path, exist_ok=True)
fileHandler = logging.FileHandler(os.path.join(save_path, 'log.txt'))
fileHandler.setFormatter(log_format)
logger.addHandler(fileHandler)
return logger
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
class TBLog:
"""
Construc tensorboard writer (self.writer).
The tensorboard is saved at os.path.join(tb_dir, file_name).
"""
def __init__(self, tb_dir, file_name, use_tensorboard=False):
self.tb_dir = tb_dir
self.use_tensorboard = use_tensorboard
if self.use_tensorboard:
self.writer = SummaryWriter(os.path.join(self.tb_dir, file_name))
else:
self.writer = CustomWriter(os.path.join(self.tb_dir, file_name))
def update(self, tb_dict, it, suffix=None, mode="train"):
"""
Args
tb_dict: contains scalar values for updating tensorboard
it: contains information of iteration (int).
suffix: If not None, the update key has the suffix.
"""
if suffix is None:
suffix = ''
if self.use_tensorboard:
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value, it)
else:
self.writer.set_epoch(it, mode)
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value)
self.writer.plot_stats()
self.writer.dump_stats()
def get_optimizer(net, optim_name='SGD', lr=0.1, momentum=0.9, weight_decay=0, nesterov=True, bn_wd_skip=True):
'''
return optimizer (name) in torch.optim.
If bn_wd_skip, the optimizer does not apply
weight decay regularization on parameters in batch normalization.
'''
decay = []
no_decay = []
for name, param in net.named_parameters():
if ('bn' in name or 'bias' in name) and bn_wd_skip:
no_decay.append(param)
else:
decay.append(param)
per_param_args = [{'params': decay},
{'params': no_decay, 'weight_decay': 0.0}]
if optim_name == 'SGD':
optimizer = torch.optim.SGD(per_param_args, lr=lr, momentum=momentum, weight_decay=weight_decay,
nesterov=nesterov)
elif optim_name == 'AdamW':
optimizer = torch.optim.AdamW(per_param_args, lr=lr, weight_decay=weight_decay)
return optimizer
def get_cosine_schedule_with_warmup(optimizer,
num_training_steps,
num_cycles=7. / 16.,
num_warmup_steps=0,
last_epoch=-1):
'''
Get cosine scheduler (LambdaLR).
if warmup is needed, set num_warmup_steps (int) > 0.
'''
def _lr_lambda(current_step):
'''
_lr_lambda returns a multiplicative factor given an interger parameter epochs.
Decaying criteria: last_epoch
'''
if current_step < num_warmup_steps:
_lr = float(current_step) / float(max(1, num_warmup_steps))
else:
num_cos_steps = float(current_step - num_warmup_steps)
num_cos_steps = num_cos_steps / float(max(1, num_training_steps - num_warmup_steps))
_lr = max(0.0, math.cos(math.pi * num_cycles * num_cos_steps))
return _lr
return LambdaLR(optimizer, _lr_lambda, last_epoch)
class PiModel:
def __init__(self, net_builder, num_classes, lambda_u,
num_eval_iter=1000, tb_log=None, ema_m=0.999, logger=None):
"""
class PiModel contains setter of data_loader, optimizer, and model update methods.
Args:
net_builder: backbone network class (see net_builder in utils.py)
num_classes: # of label classes
lambda_u: ratio of unsupervised loss to supervised loss
it: initial iteration count
num_eval_iter: frequency of evaluation.
tb_log: tensorboard writer (see train_utils.py)
logger: logger (see utils.py)
"""
super(PiModel, self).__init__()
# momentum update param
self.loader = {}
self.num_classes = num_classes
# create the encoders
# network is builded only by num_classes,
# other configs are covered in main.py
self.model = net_builder(num_classes=num_classes)
self.num_eval_iter = num_eval_iter
self.lambda_u = lambda_u
self.tb_log = tb_log
self.optimizer = None
self.scheduler = None
self.it = 0
self.logger = logger
self.print_fn = print if logger is None else logger.info
self.ema_m = ema_m
self.ema_model = deepcopy(self.model)
self.bn_controller = Bn_Controller()
def set_data_loader(self, loader_dict):
self.loader_dict = loader_dict
self.print_fn(f'[!] data loader keys: {self.loader_dict.keys()}')
def set_optimizer(self, optimizer, scheduler=None):
self.optimizer = optimizer
self.scheduler = scheduler
def train(self, args):
ngpus_per_node = torch.cuda.device_count()
# lb: labeled, ulb: unlabeled
self.model.train()
self.ema = EMA(self.model, self.ema_m)
self.ema.register()
if args.resume == True:
self.ema.load(self.ema_model)
# for gpu profiling
start_batch = torch.cuda.Event(enable_timing=True)
end_batch = torch.cuda.Event(enable_timing=True)
start_run = torch.cuda.Event(enable_timing=True)
end_run = torch.cuda.Event(enable_timing=True)
start_batch.record()
best_eval_acc, best_it = 0.0, 0
scaler = GradScaler()
amp_cm = autocast if args.amp else contextlib.nullcontext
# eval for once to verify if the checkpoint is loaded correctly
if args.resume == True:
eval_dict = self.evaluate(args=args)
print(eval_dict)
for (_, x_lb, y_lb), (_, x_ulb_w1, x_ulb_w2) in zip(self.loader_dict['train_lb'],
self.loader_dict['train_ulb']):
# prevent the training iterations exceed args.num_train_iter
if self.it > args.num_train_iter:
break
unsup_warmup = np.clip(self.it / (args.unsup_warmup_pos * args.num_train_iter),
a_min=0.0, a_max=1.0)
end_batch.record()
torch.cuda.synchronize()
start_run.record()
x_lb, x_ulb_w1, x_ulb_w2 = x_lb.cuda(args.gpu), x_ulb_w1.cuda(args.gpu), x_ulb_w2.cuda(args.gpu)
y_lb = y_lb.cuda(args.gpu)
num_lb = x_lb.shape[0]
# inference and calculate sup/unsup losses
with amp_cm():
logits_x_lb = self.model(x_lb)
# calculate BN only for the first batch
self.bn_controller.freeze_bn(self.model)
logits_x_ulb_w1 = self.model(x_ulb_w1)
logits_x_ulb_w2 = self.model(x_ulb_w2)
self.bn_controller.unfreeze_bn(self.model)
sup_loss = ce_loss(logits_x_lb, y_lb, reduction='mean')
unsup_loss = consistency_loss(logits_x_ulb_w1,
logits_x_ulb_w2)
total_loss = sup_loss + self.lambda_u * unsup_loss * unsup_warmup
# parameter updates
if args.amp:
scaler.scale(total_loss).backward()
if (args.clip > 0):
scaler.unscale_(self.optimizer)
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
scaler.step(self.optimizer)
scaler.update()
else:
total_loss.backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
self.optimizer.step()
self.scheduler.step()
self.ema.update()
self.model.zero_grad()
end_run.record()
torch.cuda.synchronize()
# tensorboard_dict update
tb_dict = {}
tb_dict['train/sup_loss'] = sup_loss.detach()
tb_dict['train/unsup_loss'] = unsup_loss.detach()
tb_dict['train/total_loss'] = total_loss.detach()
tb_dict['lr'] = self.optimizer.param_groups[0]['lr']
tb_dict['train/prefecth_time'] = start_batch.elapsed_time(end_batch) / 1000.
tb_dict['train/run_time'] = start_run.elapsed_time(end_run) / 1000.
# Save model for each 10K steps and best model for each 1K steps
if self.it % 10000 == 0:
save_path = os.path.join(args.save_dir, args.save_name)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
self.save_model('latest_model.pth', save_path)
if self.it % self.num_eval_iter == 0:
eval_dict = self.evaluate(args=args)
tb_dict.update(eval_dict)
save_path = os.path.join(args.save_dir, args.save_name)
if tb_dict['eval/top-1-acc'] > best_eval_acc:
best_eval_acc = tb_dict['eval/top-1-acc']
best_it = self.it
self.print_fn(
f"{self.it} iteration, {tb_dict}, BEST_EVAL_ACC: {best_eval_acc}, at {best_it} iters")
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
if self.it == best_it:
self.save_model('model_best.pth', save_path)
if not self.tb_log is None:
self.tb_log.update(tb_dict, self.it)
self.it += 1
del tb_dict
start_batch.record()
if self.it > 0.8 * args.num_train_iter:
self.num_eval_iter = 1000
eval_dict = self.evaluate(args=args)
eval_dict.update({'eval/best_acc': best_eval_acc, 'eval/best_it': best_it})
return eval_dict
def evaluate(self, eval_loader=None, args=None):
self.model.eval()
self.ema.apply_shadow()
if eval_loader is None:
eval_loader = self.loader_dict['eval']
total_loss = 0.0
total_num = 0.0
y_true = []
y_pred = []
y_logits = []
for _, x, y in eval_loader:
x, y = x.cuda(args.gpu), y.cuda(args.gpu)
num_batch = x.shape[0]
total_num += num_batch
logits = self.model(x)
loss = F.cross_entropy(logits, y, reduction='mean')
y_true.extend(y.cpu().tolist())
y_pred.extend(torch.max(logits, dim=-1)[1].cpu().tolist())
y_logits.extend(torch.softmax(logits, dim=-1).cpu().tolist())
total_loss += loss.detach() * num_batch
top1 = accuracy_score(y_true, y_pred)
top5 = top_k_accuracy_score(y_true, y_logits, k=5)
cf_mat = confusion_matrix(y_true, y_pred, normalize='true')
self.print_fn('confusion matrix:\n' + np.array_str(cf_mat))
self.ema.restore()
self.model.train()
return {'eval/loss': total_loss / total_num, 'eval/top-1-acc': top1, 'eval/top-5-acc': top5}
def save_model(self, save_name, save_path):
if self.it < 1000000:
return
save_filename = os.path.join(save_path, save_name)
# copy EMA parameters to ema_model for saving with model as temp
self.model.eval()
self.ema.apply_shadow()
ema_model = deepcopy(self.model)
self.ema.restore()
self.model.train()
torch.save({'model': self.model.state_dict(),
'optimizer': self.optimizer.state_dict(),
'scheduler': self.scheduler.state_dict(),
'it': self.it + 1,
'ema_model': ema_model.state_dict()},
save_filename)
self.print_fn(f"model saved: {save_filename}")
def load_model(self, load_path):
checkpoint = torch.load(load_path)
self.model.load_state_dict(checkpoint['model'])
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.scheduler.load_state_dict(checkpoint['scheduler'])
self.it = checkpoint['it']
self.ema_model.load_state_dict(checkpoint['ema_model'])
self.print_fn('model loaded')
# Abandoned in PiModel
def interleave_offsets(self, batch, nu):
groups = [batch // (nu + 1)] * (nu + 1)
for x in range(batch - sum(groups)):
groups[-x - 1] += 1
offsets = [0]
for g in groups:
offsets.append(offsets[-1] + g)
assert offsets[-1] == batch
return offsets
def interleave(self, xy, batch):
nu = len(xy) - 1
offsets = self.interleave_offsets(batch, nu)
xy = [[v[offsets[p]:offsets[p + 1]] for p in range(nu + 1)] for v in xy]
for i in range(1, nu + 1):
xy[0][i], xy[i][i] = xy[i][i], xy[0][i]
return [torch.cat(v, dim=0) for v in xy]
class SSL_Dataset:
"""
SSL_Dataset class gets dataset from torchvision.datasets,
separates labeled and unlabeled data,
and return BasicDataset: torch.utils.data.Dataset (see datasets.dataset.py)
"""
def __init__(self,
args,
alg='fixmatch',
name='cifar10',
train=True,
num_classes=10,
data_dir='./data'):
"""
Args
alg: SSL algorithms
name: name of dataset in torchvision.datasets (cifar10, cifar100, svhn, stl10)
train: True means the dataset is training dataset (default=True)
num_classes: number of label classes
data_dir: path of directory, where data is downloaed or stored.
"""
self.args = args
self.alg = alg
self.name = name
self.train = train
self.num_classes = num_classes
self.data_dir = data_dir
crop_size = 96 if self.name.upper() == 'STL10' else 224 if self.name.upper() == 'IMAGENET' else 32
self.transform = get_transform(mean[name], std[name], crop_size, train)
def get_data(self, svhn_extra=True):
"""
get_data returns data (images) and targets (labels)
shape of data: B, H, W, C
shape of labels: B,
"""
dset = getattr(torchvision.datasets, self.name.upper())
if 'CIFAR' in self.name.upper():
dset = dset(self.data_dir, train=self.train, download=True)
data, targets = dset.data, dset.targets
return data, targets
elif self.name.upper() == 'SVHN':
if self.train:
if svhn_extra: # train+extra
dset_base = dset(self.data_dir, split='train', download=True)
data_b, targets_b = dset_base.data.transpose([0, 2, 3, 1]), dset_base.labels
dset_extra = dset(self.data_dir, split='extra', download=True)
data_e, targets_e = dset_extra.data.transpose([0, 2, 3, 1]), dset_extra.labels
data = np.concatenate([data_b, data_e])
targets = np.concatenate([targets_b, targets_e])
del data_b, data_e
del targets_b, targets_e
else: # train_only
dset = dset(self.data_dir, split='train', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
else: # test
dset = dset(self.data_dir, split='test', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
return data, targets
elif self.name.upper() == 'STL10':
split = 'train' if self.train else 'test'
dset_lb = dset(self.data_dir, split=split, download=True)
dset_ulb = dset(self.data_dir, split='unlabeled', download=True)
data, targets = dset_lb.data.transpose([0, 2, 3, 1]), dset_lb.labels.astype(np.int64)
ulb_data = dset_ulb.data.transpose([0, 2, 3, 1])
return data, targets, ulb_data
def get_dset(self, is_ulb=False,
strong_transform=None, onehot=False):
"""
get_dset returns class BasicDataset, containing the returns of get_data.
Args
is_ulb: If True, returned dataset generates a pair of weak and strong augmented images.
strong_transform: list of strong_transform (augmentation) if use_strong_transform is True。
onehot: If True, the label is not integer, but one-hot vector.
"""
if self.name.upper() == 'STL10':
data, targets, _ = self.get_data()
else:
data, targets = self.get_data()
num_classes = self.num_classes
transform = self.transform
return BasicDataset(self.alg, data, targets, num_classes, transform,
is_ulb, strong_transform, onehot)
def get_ssl_dset(self, num_labels, index=None, include_lb_to_ulb=True,
strong_transform=None, onehot=False):
"""
get_ssl_dset split training samples into labeled and unlabeled samples.
The labeled data is balanced samples over classes.
Args:
num_labels: number of labeled data.
index: If index of np.array is given, labeled data is not randomly sampled, but use index for sampling.
include_lb_to_ulb: If True, consistency regularization is also computed for the labeled data.
strong_transform: list of strong transform (RandAugment in FixMatch)
onehot: If True, the target is converted into onehot vector.
Returns:
BasicDataset (for labeled data), BasicDataset (for unlabeld data)
"""
# Supervised top line using all data as labeled data.
if self.alg == 'fullysupervised':
lb_data, lb_targets = self.get_data()
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
return lb_dset, None
if self.name.upper() == 'STL10':
lb_data, lb_targets, ulb_data = self.get_data()
if include_lb_to_ulb:
ulb_data = np.concatenate([ulb_data, lb_data], axis=0)
lb_data, lb_targets, _ = sample_labeled_data(self.args, lb_data, lb_targets, num_labels, self.num_classes)
ulb_targets = None
else:
data, targets = self.get_data()
lb_data, lb_targets, ulb_data, ulb_targets = split_ssl_data(self.args, data, targets,
num_labels, self.num_classes,
index, include_lb_to_ulb)
# output the distribution of labeled data for remixmatch
count = [0 for _ in range(self.num_classes)]
for c in lb_targets:
count[c] += 1
dist = np.array(count, dtype=float)
dist = dist / dist.sum()
dist = dist.tolist()
out = {"distribution": dist}
output_file = r"./data_statistics/"
output_path = output_file + str(self.name) + '_' + str(num_labels) + '.json'
if not os.path.exists(output_file):
os.makedirs(output_file, exist_ok=True)
with open(output_path, 'w') as w:
json.dump(out, w)
# print(Counter(ulb_targets.tolist()))
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
ulb_dset = BasicDataset(self.alg, ulb_data, ulb_targets, self.num_classes,
self.transform, True, strong_transform, onehot)
# print(lb_data.shape)
# print(ulb_data.shape)
return lb_dset, ulb_dset
def get_data_loader(dset,
batch_size=None,
shuffle=False,
num_workers=4,
pin_memory=False,
data_sampler=None,
replacement=True,
num_epochs=None,
num_iters=None,
generator=None,
drop_last=True,
distributed=False):
"""
get_data_loader returns torch.utils.data.DataLoader for a Dataset.
All arguments are comparable with those of pytorch DataLoader.
However, if distributed, DistributedProxySampler, which is a wrapper of data_sampler, is used.
Args
num_epochs: total batch -> (# of batches in dset) * num_epochs
num_iters: total batch -> num_iters
"""
assert batch_size is not None
if data_sampler is None:
return DataLoader(dset, batch_size=batch_size, shuffle=shuffle,
num_workers=num_workers, pin_memory=pin_memory)
else:
if isinstance(data_sampler, str):
data_sampler = get_sampler_by_name(data_sampler)
if distributed:
assert dist.is_available()
num_replicas = dist.get_world_size()
else:
num_replicas = 1
if (num_epochs is not None) and (num_iters is None):
num_samples = len(dset) * num_epochs
elif (num_epochs is None) and (num_iters is not None):
num_samples = batch_size * num_iters * num_replicas
else:
num_samples = len(dset)
if data_sampler.__name__ == 'RandomSampler':
data_sampler = data_sampler(dset, replacement, num_samples, generator)
else:
raise RuntimeError(f"{data_sampler.__name__} is not implemented.")
if distributed:
'''
Different with DistributedSampler,
the DistribuedProxySampler does not shuffle the data (just wrapper for dist).
'''
data_sampler = DistributedProxySampler(data_sampler)
batch_sampler = BatchSampler(data_sampler, batch_size, drop_last)
return DataLoader(dset, batch_sampler=batch_sampler,
num_workers=num_workers, pin_memory=pin_memory)
The provided code snippet includes necessary dependencies for implementing the `main_worker` function. Write a Python function `def main_worker(gpu, ngpus_per_node, args)` to solve the following problem:
main_worker is conducted on each GPU.
Here is the function:
def main_worker(gpu, ngpus_per_node, args):
'''
main_worker is conducted on each GPU.
'''
global best_acc1
args.gpu = gpu
# random seed has to be set for the syncronization of labeled data sampling in each process.
assert args.seed is not None
random.seed(args.seed)
torch.manual_seed(args.seed)
np.random.seed(args.seed)
cudnn.deterministic = True
# SET UP FOR DISTRIBUTED TRAINING
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
args.rank = args.rank * ngpus_per_node + gpu # compute global rank
# set distributed group:
dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
world_size=args.world_size, rank=args.rank)
# SET save_path and logger
save_path = os.path.join(args.save_dir, args.save_name)
logger_level = "WARNING"
tb_log = None
if args.rank % ngpus_per_node == 0:
tb_log = TBLog(save_path, 'tensorboard', use_tensorboard=args.use_tensorboard)
logger_level = "INFO"
logger = get_logger(args.save_name, save_path, logger_level)
logger.warning(f"USE GPU: {args.gpu} for training")
args.bn_momentum = 1.0 - 0.999
if 'imagenet' in args.dataset.lower():
_net_builder = net_builder('ResNet50', False, None, is_remix=False)
else:
_net_builder = net_builder(args.net,
args.net_from_name,
{'first_stride': 2 if 'stl' in args.dataset else 1,
'depth': args.depth,
'widen_factor': args.widen_factor,
'leaky_slope': args.leaky_slope,
'bn_momentum': args.bn_momentum,
'dropRate': args.dropout,
'use_embed': False,
'is_remix': False},
)
model = PiModel(_net_builder,
args.num_classes,
args.ulb_loss_ratio,
num_eval_iter=args.num_eval_iter,
tb_log=tb_log,
ema_m=args.ema_m,
logger=logger)
logger.info(f'Number of Trainable Params: {count_parameters(model.model)}')
# SET Optimizer & LR Scheduler
## construct SGD and cosine lr scheduler
optimizer = get_optimizer(model.model, args.optim, args.lr, args.momentum, args.weight_decay)
scheduler = get_cosine_schedule_with_warmup(optimizer,
args.num_train_iter,
num_warmup_steps=args.num_train_iter * 0)
## set SGD and cosine lr
model.set_optimizer(optimizer, scheduler)
# SET Devices for (Distributed) DataParallel
if not torch.cuda.is_available():
raise Exception('ONLY GPU TRAINING IS SUPPORTED')
elif args.distributed:
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
'''
batch_size: batch_size per node -> batch_size per gpu
workers: workers per node -> workers per gpu
'''
args.batch_size = int(args.batch_size / ngpus_per_node)
model.model.cuda(args.gpu)
model.model = torch.nn.parallel.DistributedDataParallel(model.model,
device_ids=[args.gpu],
broadcast_buffers=False,
find_unused_parameters=True)
else:
# if arg.gpu is None, DDP will divide and allocate batch_size
# to all available GPUs if device_ids are not set.
model.cuda()
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.model = model.model.cuda(args.gpu)
else:
model.model = torch.nn.DataParallel(model.model).cuda()
import copy
model.ema_model = copy.deepcopy(model.model)
logger.info(f"model_arch: {model}")
logger.info(f"Arguments: {args}")
cudnn.benchmark = True
if args.rank != 0 and args.distributed:
torch.distributed.barrier()
# Construct Dataset & DataLoader
if args.dataset != "imagenet":
if args.num_labels == 10 and args.dataset == 'cifar10':
fixmatch_index = [
[7408, 8148, 9850, 10361, 33949, 36506, 37018, 45044, 46443, 47447],
[5022, 8193, 8902, 9601, 25226, 26223, 34089, 35186, 40595, 48024],
[7510, 13186, 14043, 21305, 22805, 31288, 34508, 40470, 41493, 45506],
[9915, 9978, 16631, 19915, 28008, 35314, 35801, 36149, 39215, 42557],
[6695, 14891, 19726, 22715, 23999, 34230, 46511, 47457, 49181, 49397],
[12830, 20293, 26835, 30517, 30898, 31061, 43693, 46501, 47310, 48517],
[1156, 11501, 19974, 21963, 32103, 42189, 46789, 47690, 48229, 48675],
[4255, 6446, 8580, 11759, 12598, 29349, 29433, 33759, 35345, 38639]]
index = fixmatch_index[-args.seed - 1]
print("10 labels for cifar10")
else:
index = None
# Construct Dataset & DataLoader
train_dset = SSL_Dataset(args, alg='pimodel', name=args.dataset, train=True,
num_classes=args.num_classes, data_dir=args.data_dir)
lb_dset, ulb_dset = train_dset.get_ssl_dset(args.num_labels,index=index)
_eval_dset = SSL_Dataset(args, alg='pimodel', name=args.dataset, train=False,
num_classes=args.num_classes, data_dir=args.data_dir)
eval_dset = _eval_dset.get_dset()
if args.rank == 0 and args.distributed:
torch.distributed.barrier()
loader_dict = {}
dset_dict = {'train_lb': lb_dset, 'train_ulb': ulb_dset, 'eval': eval_dset}
loader_dict['train_lb'] = get_data_loader(dset_dict['train_lb'],
args.batch_size,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=args.num_workers,
distributed=args.distributed)
loader_dict['train_ulb'] = get_data_loader(dset_dict['train_ulb'],
args.batch_size * args.uratio,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=4 * args.num_workers,
distributed=args.distributed)
loader_dict['eval'] = get_data_loader(dset_dict['eval'],
args.eval_batch_size,
num_workers=args.num_workers,
drop_last=False)
## set DataLoader
model.set_data_loader(loader_dict)
# If args.resume, load checkpoints from args.load_path
if args.resume:
model.load_model(args.load_path)
# START TRAINING
trainer = model.train
for epoch in range(args.epoch):
trainer(args)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
model.save_model('latest_model.pth', save_path)
logging.warning(f"GPU {args.rank} training is FINISHED") | main_worker is conducted on each GPU. |
157,493 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.pimodel.pimodel import PiModel
from datasets.ssl_dataset import SSL_Dataset
from datasets.data_utils import get_data_loader
def str2bool(v):
if isinstance(v, bool):
return v
if v.lower() in ('yes', 'true', 't', 'y', '1'):
return True
elif v.lower() in ('no', 'false', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError('Boolean value expected.') | null |
157,494 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.freematch_entropy.freematch import FreeMatch
from datasets.ssl_dataset import SSL_Dataset, ImageNetLoader
from datasets.data_utils import get_data_loader
def net_builder(net_name, from_name: bool, net_conf=None, is_remix=False):
"""
return **class** of backbone network (not instance).
Args
net_name: 'WideResNet' or network names in torchvision.models
from_name: If True, net_buidler takes models in torch.vision models. Then, net_conf is ignored.
net_conf: When from_name is False, net_conf is the configuration of backbone network (now, only WRN is supported).
"""
if from_name:
import torchvision.models as models
model_name_list = sorted(name for name in models.__dict__
if name.islower() and not name.startswith("__")
and callable(models.__dict__[name]))
if net_name not in model_name_list:
assert Exception(f"[!] Networks\' Name is wrong, check net config, \
expected: {model_name_list} \
received: {net_name}")
else:
return models.__dict__[net_name]
else:
if net_name == 'WideResNet':
import models.nets.wrn as net
builder = getattr(net, 'build_WideResNet')()
elif net_name == 'WideResNetVar':
import models.nets.wrn_var as net
builder = getattr(net, 'build_WideResNetVar')()
elif net_name == 'ResNet50':
import models.nets.resnet50 as net
builder = getattr(net, 'build_ResNet50')(is_remix)
else:
assert Exception("Not Implemented Error")
if net_name != 'ResNet50':
setattr_cls_from_kwargs(builder, net_conf)
return builder.build
def get_logger(name, save_path=None, level='INFO'):
logger = logging.getLogger(name)
logger.setLevel(getattr(logging, level))
log_format = logging.Formatter('[%(asctime)s %(levelname)s] %(message)s')
streamHandler = logging.StreamHandler()
streamHandler.setFormatter(log_format)
logger.addHandler(streamHandler)
if not save_path is None:
os.makedirs(save_path, exist_ok=True)
fileHandler = logging.FileHandler(os.path.join(save_path, 'log.txt'))
fileHandler.setFormatter(log_format)
logger.addHandler(fileHandler)
return logger
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
class TBLog:
"""
Construc tensorboard writer (self.writer).
The tensorboard is saved at os.path.join(tb_dir, file_name).
"""
def __init__(self, tb_dir, file_name, use_tensorboard=False):
self.tb_dir = tb_dir
self.use_tensorboard = use_tensorboard
if self.use_tensorboard:
self.writer = SummaryWriter(os.path.join(self.tb_dir, file_name))
else:
self.writer = CustomWriter(os.path.join(self.tb_dir, file_name))
def update(self, tb_dict, it, suffix=None, mode="train"):
"""
Args
tb_dict: contains scalar values for updating tensorboard
it: contains information of iteration (int).
suffix: If not None, the update key has the suffix.
"""
if suffix is None:
suffix = ''
if self.use_tensorboard:
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value, it)
else:
self.writer.set_epoch(it, mode)
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value)
self.writer.plot_stats()
self.writer.dump_stats()
def get_optimizer(net, optim_name='SGD', lr=0.1, momentum=0.9, weight_decay=0, nesterov=True, bn_wd_skip=True):
'''
return optimizer (name) in torch.optim.
If bn_wd_skip, the optimizer does not apply
weight decay regularization on parameters in batch normalization.
'''
decay = []
no_decay = []
for name, param in net.named_parameters():
if ('bn' in name or 'bias' in name) and bn_wd_skip:
no_decay.append(param)
else:
decay.append(param)
per_param_args = [{'params': decay},
{'params': no_decay, 'weight_decay': 0.0}]
if optim_name == 'SGD':
optimizer = torch.optim.SGD(per_param_args, lr=lr, momentum=momentum, weight_decay=weight_decay,
nesterov=nesterov)
elif optim_name == 'AdamW':
optimizer = torch.optim.AdamW(per_param_args, lr=lr, weight_decay=weight_decay)
return optimizer
def get_cosine_schedule_with_warmup(optimizer,
num_training_steps,
num_cycles=7. / 16.,
num_warmup_steps=0,
last_epoch=-1):
'''
Get cosine scheduler (LambdaLR).
if warmup is needed, set num_warmup_steps (int) > 0.
'''
def _lr_lambda(current_step):
'''
_lr_lambda returns a multiplicative factor given an interger parameter epochs.
Decaying criteria: last_epoch
'''
if current_step < num_warmup_steps:
_lr = float(current_step) / float(max(1, num_warmup_steps))
else:
num_cos_steps = float(current_step - num_warmup_steps)
num_cos_steps = num_cos_steps / float(max(1, num_training_steps - num_warmup_steps))
_lr = max(0.0, math.cos(math.pi * num_cycles * num_cos_steps))
return _lr
return LambdaLR(optimizer, _lr_lambda, last_epoch)
class FreeMatch:
def __init__(self, net_builder, num_classes, ema_m, lambda_u, lambda_e, \
hard_label=True, t_fn=None, p_fn=None, it=0, num_eval_iter=1000, tb_log=None, logger=None):
"""
class Freematch contains setter of data_loader, optimizer, and model update methods.
Args:
net_builder: backbone network class (see net_builder in utils.py)
num_classes: # of label classes
ema_m: momentum of exponential moving average for eval_model
lambda_u: ratio of unsupervised loss to supervised loss
hard_label: If True, consistency regularization use a hard pseudo label.
it: initial iteration count
num_eval_iter: freqeuncy of iteration (after 500,000 iters)
tb_log: tensorboard writer (see train_utils.py)
logger: logger (see utils.py)
"""
super(FreeMatch, self).__init__()
# momentum update param
self.loader = {}
self.num_classes = num_classes
self.ema_m = ema_m
# create the encoders
# network is builded only by num_classes,
# other configs are covered in main.py
self.model = net_builder(num_classes=num_classes)
self.ema_model = None
self.num_eval_iter = num_eval_iter
self.lambda_u = lambda_u
self.lambda_e = lambda_e
self.tb_log = tb_log
self.use_hard_label = hard_label
self.optimizer = None
self.scheduler = None
self.it = 0
self.lst = [[] for i in range(10)]
self.abs_lst = [[] for i in range(10)]
self.clsacc = [[] for i in range(10)]
self.logger = logger
self.print_fn = print if logger is None else logger.info
self.bn_controller = Bn_Controller()
def set_data_loader(self, loader_dict):
self.loader_dict = loader_dict
self.print_fn(f'[!] data loader keys: {self.loader_dict.keys()}')
def set_dset(self, dset):
self.ulb_dset = dset
def set_optimizer(self, optimizer, scheduler=None):
self.optimizer = optimizer
self.scheduler = scheduler
def warmup(self, args, logger=None):
ngpus_per_node = torch.cuda.device_count()
self.model.train()
# for gpu profiling
start_batch = torch.cuda.Event(enable_timing=True)
end_batch = torch.cuda.Event(enable_timing=True)
start_run = torch.cuda.Event(enable_timing=True)
end_run = torch.cuda.Event(enable_timing=True)
warmup_it = 0
start_batch.record()
scaler = GradScaler()
amp_cm = autocast if args.amp else contextlib.nullcontext
for _, x_lb, y_lb in self.loader_dict['train_lb']:
# prevent the training iterations exceed args.num_train_iter
if warmup_it > 2048:
break
end_batch.record()
torch.cuda.synchronize()
start_run.record()
x_lb = x_lb.cuda(args.gpu)
y_lb = y_lb.cuda(args.gpu)
num_lb = x_lb.shape[0]
# inference and calculate sup/unsup losses
with amp_cm():
logits_x_lb = self.model(x_lb)
sup_loss = ce_loss(logits_x_lb, y_lb, use_hard_labels=True, reduction='mean')
total_loss = sup_loss
# parameter updates
if args.amp:
scaler.scale(total_loss).backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
scaler.step(self.optimizer)
scaler.update()
else:
total_loss.backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
self.optimizer.step()
self.model.zero_grad()
end_run.record()
torch.cuda.synchronize()
# tensorboard_dict update
tb_dict = {}
tb_dict['train/sup_loss'] = sup_loss.item()
tb_dict['lr'] = self.optimizer.param_groups[0]['lr']
tb_dict['train/prefecth_time'] = start_batch.elapsed_time(end_batch) / 1000.
tb_dict['train/run_time'] = start_run.elapsed_time(end_run) / 1000.
if warmup_it % 1000 == 0:
self.print_fn(f"warmup {warmup_it} iteration, {tb_dict}")
del tb_dict
start_batch.record()
warmup_it += 1
# compute p_model, time_p,
self.model.eval()
probs = []
with torch.no_grad():
for _, x, y in self.loader_dict['eval']:
x = x.cuda(args.gpu)
y = y.cuda(args.gpu)
# inference and calculate sup/unsup losses
with amp_cm():
logits = self.model(x)
probs.append(logits.softmax(dim=-1).cpu())
probs = torch.cat(probs)
max_probs, max_idx = torch.max(probs, dim=-1)
self.time_p = max_probs.mean()
self.p_model = torch.mean(probs, dim=0)
label_hist = torch.bincount(max_idx, minlength=probs.shape[1]).to(probs.dtype)
self.label_hist = label_hist / label_hist.sum()
def train(self, args, logger=None):
ngpus_per_node = torch.cuda.device_count()
# EMA Init
self.model.train()
self.ema = EMA(self.model, self.ema_m)
self.ema.register()
if args.resume == True:
self.ema.load(self.ema_model)
# for gpu profiling
start_batch = torch.cuda.Event(enable_timing=True)
end_batch = torch.cuda.Event(enable_timing=True)
start_run = torch.cuda.Event(enable_timing=True)
end_run = torch.cuda.Event(enable_timing=True)
start_batch.record()
best_eval_acc, best_it = 0.0, 0
scaler = GradScaler()
amp_cm = autocast if args.amp else contextlib.nullcontext
# eval for once to verify if the checkpoint is loaded correctly
if args.resume == True:
eval_dict = self.evaluate(args=args)
print(eval_dict)
p_model = (torch.ones(args.num_classes) / args.num_classes).cuda()
label_hist = (torch.ones(args.num_classes) / args.num_classes).cuda()
time_p = p_model.mean()
for (_, x_lb, y_lb), (x_ulb_idx, x_ulb_w, x_ulb_s) in zip(self.loader_dict['train_lb'],
self.loader_dict['train_ulb']):
# prevent the training iterations exceed args.num_train_iter
if self.it > args.num_train_iter:
break
end_batch.record()
torch.cuda.synchronize()
start_run.record()
num_lb = x_lb.shape[0]
num_ulb = x_ulb_w.shape[0]
assert num_ulb == x_ulb_s.shape[0]
x_lb, x_ulb_w, x_ulb_s = x_lb.cuda(args.gpu), x_ulb_w.cuda(args.gpu), x_ulb_s.cuda(args.gpu)
y_lb = y_lb.cuda(args.gpu)
inputs = torch.cat((x_lb, x_ulb_w, x_ulb_s))
# inference and calculate sup/unsup losses
with amp_cm():
logits = self.model(inputs)
logits_x_lb = logits[:num_lb]
logits_x_ulb_w, logits_x_ulb_s = logits[num_lb:].chunk(2)
sup_loss = ce_loss(logits_x_lb, y_lb, reduction='mean')
# hyper-params for update
time_p, p_model, label_hist = self.cal_time_p_and_p_model(logits_x_ulb_w, time_p, p_model, label_hist)
unsup_loss, mask = consistency_loss(args.dataset, logits_x_ulb_s,logits_x_ulb_w,
time_p,p_model,
'ce', use_hard_labels=args.hard_label)
ent_loss, ps_label_hist = entropy_loss(mask, logits_x_ulb_s, logits_x_ulb_w, p_model, label_hist)
total_loss = sup_loss + self.lambda_u * unsup_loss + self.lambda_e * ent_loss
# parameter updates
if args.amp:
scaler.scale(total_loss).backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
scaler.step(self.optimizer)
scaler.update()
else:
total_loss.backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
self.optimizer.step()
self.scheduler.step()
self.ema.update()
self.model.zero_grad()
end_run.record()
torch.cuda.synchronize()
# tensorboard_dict update
tb_dict = {}
tb_dict['train/sup_loss'] = sup_loss.item()
tb_dict['train/unsup_loss'] = unsup_loss.item()
tb_dict['train/ent_loss'] = ent_loss.item()
tb_dict['train/total_loss'] = total_loss.item()
tb_dict['train/time_p'] = time_p.item()
tb_dict['train/mask_ratio'] = 1.0 - mask.float().mean().item()
tb_dict['train/p_model'] = p_model.mean().item()
tb_dict['train/label_hist'] = label_hist.mean().item()
tb_dict['train/ps_label_hist'] = ps_label_hist.mean().item()
tb_dict['lr'] = self.optimizer.param_groups[0]['lr']
tb_dict['train/prefecth_time'] = start_batch.elapsed_time(end_batch) / 1000.
tb_dict['train/run_time'] = start_run.elapsed_time(end_run) / 1000.
# Save model for each 10K steps and best model for each 1K steps
if self.it % 10000 == 0:
save_path = os.path.join(args.save_dir, args.save_name)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
self.save_model('latest_model.pth', save_path)
if self.it % self.num_eval_iter == 0:
eval_dict = self.evaluate(args=args)
tb_dict.update(eval_dict)
save_path = os.path.join(args.save_dir, args.save_name)
if tb_dict['eval/top-1-acc'] > best_eval_acc:
best_eval_acc = tb_dict['eval/top-1-acc']
best_it = self.it
self.print_fn(
f"{self.it} iteration, USE_EMA: {self.ema_m != 0}, {tb_dict}, BEST_EVAL_ACC: {best_eval_acc}, at {best_it} iters")
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
if self.it == best_it:
self.save_model('model_best.pth', save_path)
if not self.tb_log is None:
self.tb_log.update(tb_dict, self.it)
self.it += 1
del tb_dict
start_batch.record()
if self.it > 0.8 * args.num_train_iter:
self.num_eval_iter = 1000
eval_dict = self.evaluate(args=args)
eval_dict.update({'eval/best_acc': best_eval_acc, 'eval/best_it': best_it})
return eval_dict
def cal_time_p_and_p_model(self,logits_x_ulb_w, time_p, p_model, label_hist):
prob_w = torch.softmax(logits_x_ulb_w, dim=1)
max_probs, max_idx = torch.max(prob_w, dim=-1)
if time_p is None:
time_p = max_probs.mean()
else:
time_p = time_p * 0.999 + max_probs.mean() * 0.001
if p_model is None:
p_model = torch.mean(prob_w, dim=0)
else:
p_model = p_model * 0.999 + torch.mean(prob_w, dim=0) * 0.001
if label_hist is None:
label_hist = torch.bincount(max_idx, minlength=p_model.shape[0]).to(p_model.dtype)
label_hist = label_hist / label_hist.sum()
else:
hist = torch.bincount(max_idx, minlength=p_model.shape[0]).to(p_model.dtype)
label_hist = label_hist * 0.999 + (hist / hist.sum()) * 0.001
return time_p,p_model,label_hist
def evaluate(self, eval_loader=None, args=None):
self.model.eval()
self.ema.apply_shadow()
if eval_loader is None:
eval_loader = self.loader_dict['eval']
total_loss = 0.0
total_num = 0.0
y_true = []
y_pred = []
y_logits = []
for _, x, y in eval_loader:
x, y = x.cuda(args.gpu), y.cuda(args.gpu)
num_batch = x.shape[0]
total_num += num_batch
logits = self.model(x)
loss = F.cross_entropy(logits, y, reduction='mean')
y_true.extend(y.cpu().tolist())
y_pred.extend(torch.max(logits, dim=-1)[1].cpu().tolist())
y_logits.extend(torch.softmax(logits, dim=-1).cpu().tolist())
total_loss += loss.detach() * num_batch
top1 = accuracy_score(y_true, y_pred)
top5 = top_k_accuracy_score(y_true, y_logits, k=5)
precision = precision_score(y_true, y_pred, average='macro')
recall = recall_score(y_true, y_pred, average='macro')
F1 = f1_score(y_true, y_pred, average='macro')
AUC = roc_auc_score(y_true, y_logits, multi_class='ovo')
cf_mat = confusion_matrix(y_true, y_pred, normalize='true')
self.print_fn('confusion matrix:\n' + np.array_str(cf_mat))
self.ema.restore()
self.model.train()
return {'eval/loss': total_loss / total_num, 'eval/top-1-acc': top1, 'eval/top-5-acc': top5,
'eval/precision': precision, 'eval/recall': recall, 'eval/F1': F1, 'eval/AUC': AUC}
def save_model(self, save_name, save_path):
save_filename = os.path.join(save_path, save_name)
# copy EMA parameters to ema_model for saving with model as temp
self.model.eval()
self.ema.apply_shadow()
ema_model = self.model.state_dict()
self.ema.restore()
self.model.train()
torch.save({'model': self.model.state_dict(),
'optimizer': self.optimizer.state_dict(),
'scheduler': self.scheduler.state_dict(),
'it': self.it,
'ema_model': ema_model},
save_filename)
self.print_fn(f"model saved: {save_filename}")
def load_model(self, load_path):
checkpoint = torch.load(load_path)
self.model.load_state_dict(checkpoint['model'])
self.ema_model = deepcopy(self.model)
self.ema_model.load_state_dict(checkpoint['ema_model'])
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.scheduler.load_state_dict(checkpoint['scheduler'])
self.it = checkpoint['it']
self.print_fn('model loaded')
def interleave_offsets(self, batch, nu):
groups = [batch // (nu + 1)] * (nu + 1)
for x in range(batch - sum(groups)):
groups[-x - 1] += 1
offsets = [0]
for g in groups:
offsets.append(offsets[-1] + g)
assert offsets[-1] == batch
return offsets
def interleave(self, xy, batch):
nu = len(xy) - 1
offsets = self.interleave_offsets(batch, nu)
xy = [[v[offsets[p]:offsets[p + 1]] for p in range(nu + 1)] for v in xy]
for i in range(1, nu + 1):
xy[0][i], xy[i][i] = xy[i][i], xy[0][i]
return [torch.cat(v, dim=0) for v in xy]
class ImageNetLoader:
def __init__(self, root_path, num_labels=-1, num_class=1000):
self.root_path = os.path.join(root_path, 'imagenet')
self.num_labels = num_labels // num_class
def get_transform(self, train, ulb):
if train:
transform = transforms.Compose([
transforms.Resize([256, 256]),
transforms.RandomHorizontalFlip(),
transforms.RandomCrop(224, padding=4, padding_mode='reflect'),
transforms.ToTensor(),
transforms.Normalize(mean["imagenet"], std["imagenet"])])
else:
transform = transforms.Compose([
transforms.Resize([224, 224]),
transforms.ToTensor(),
transforms.Normalize(mean["imagenet"], std["imagenet"])])
return transform
def get_lb_train_data(self):
transform = self.get_transform(train=True, ulb=False)
data = ImagenetDataset(root=os.path.join(self.root_path, "train"), transform=transform, ulb=False,
num_labels=self.num_labels)
return data
def get_ulb_train_data(self):
transform = self.get_transform(train=True, ulb=True)
data = ImagenetDataset(root=os.path.join(self.root_path, "train"), transform=transform, ulb=True)
return data
def get_lb_test_data(self):
transform = self.get_transform(train=False, ulb=False)
data = ImagenetDataset(root=os.path.join(self.root_path, "val"), transform=transform, ulb=False)
return data
class SSL_Dataset:
"""
SSL_Dataset class gets dataset from torchvision.datasets,
separates labeled and unlabeled data,
and return BasicDataset: torch.utils.data.Dataset (see datasets.dataset.py)
"""
def __init__(self,
args,
alg='fixmatch',
name='cifar10',
train=True,
num_classes=10,
data_dir='./data'):
"""
Args
alg: SSL algorithms
name: name of dataset in torchvision.datasets (cifar10, cifar100, svhn, stl10)
train: True means the dataset is training dataset (default=True)
num_classes: number of label classes
data_dir: path of directory, where data is downloaed or stored.
"""
self.args = args
self.alg = alg
self.name = name
self.train = train
self.num_classes = num_classes
self.data_dir = data_dir
crop_size = 96 if self.name.upper() == 'STL10' else 224 if self.name.upper() == 'IMAGENET' else 32
self.transform = get_transform(mean[name], std[name], crop_size, train)
def get_data(self, svhn_extra=True):
"""
get_data returns data (images) and targets (labels)
shape of data: B, H, W, C
shape of labels: B,
"""
dset = getattr(torchvision.datasets, self.name.upper())
if 'CIFAR' in self.name.upper():
dset = dset(self.data_dir, train=self.train, download=True)
data, targets = dset.data, dset.targets
return data, targets
elif self.name.upper() == 'SVHN':
if self.train:
if svhn_extra: # train+extra
dset_base = dset(self.data_dir, split='train', download=True)
data_b, targets_b = dset_base.data.transpose([0, 2, 3, 1]), dset_base.labels
dset_extra = dset(self.data_dir, split='extra', download=True)
data_e, targets_e = dset_extra.data.transpose([0, 2, 3, 1]), dset_extra.labels
data = np.concatenate([data_b, data_e])
targets = np.concatenate([targets_b, targets_e])
del data_b, data_e
del targets_b, targets_e
else: # train_only
dset = dset(self.data_dir, split='train', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
else: # test
dset = dset(self.data_dir, split='test', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
return data, targets
elif self.name.upper() == 'STL10':
split = 'train' if self.train else 'test'
dset_lb = dset(self.data_dir, split=split, download=True)
dset_ulb = dset(self.data_dir, split='unlabeled', download=True)
data, targets = dset_lb.data.transpose([0, 2, 3, 1]), dset_lb.labels.astype(np.int64)
ulb_data = dset_ulb.data.transpose([0, 2, 3, 1])
return data, targets, ulb_data
def get_dset(self, is_ulb=False,
strong_transform=None, onehot=False):
"""
get_dset returns class BasicDataset, containing the returns of get_data.
Args
is_ulb: If True, returned dataset generates a pair of weak and strong augmented images.
strong_transform: list of strong_transform (augmentation) if use_strong_transform is True。
onehot: If True, the label is not integer, but one-hot vector.
"""
if self.name.upper() == 'STL10':
data, targets, _ = self.get_data()
else:
data, targets = self.get_data()
num_classes = self.num_classes
transform = self.transform
return BasicDataset(self.alg, data, targets, num_classes, transform,
is_ulb, strong_transform, onehot)
def get_ssl_dset(self, num_labels, index=None, include_lb_to_ulb=True,
strong_transform=None, onehot=False):
"""
get_ssl_dset split training samples into labeled and unlabeled samples.
The labeled data is balanced samples over classes.
Args:
num_labels: number of labeled data.
index: If index of np.array is given, labeled data is not randomly sampled, but use index for sampling.
include_lb_to_ulb: If True, consistency regularization is also computed for the labeled data.
strong_transform: list of strong transform (RandAugment in FixMatch)
onehot: If True, the target is converted into onehot vector.
Returns:
BasicDataset (for labeled data), BasicDataset (for unlabeld data)
"""
# Supervised top line using all data as labeled data.
if self.alg == 'fullysupervised':
lb_data, lb_targets = self.get_data()
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
return lb_dset, None
if self.name.upper() == 'STL10':
lb_data, lb_targets, ulb_data = self.get_data()
if include_lb_to_ulb:
ulb_data = np.concatenate([ulb_data, lb_data], axis=0)
lb_data, lb_targets, _ = sample_labeled_data(self.args, lb_data, lb_targets, num_labels, self.num_classes)
ulb_targets = None
else:
data, targets = self.get_data()
lb_data, lb_targets, ulb_data, ulb_targets = split_ssl_data(self.args, data, targets,
num_labels, self.num_classes,
index, include_lb_to_ulb)
# output the distribution of labeled data for remixmatch
count = [0 for _ in range(self.num_classes)]
for c in lb_targets:
count[c] += 1
dist = np.array(count, dtype=float)
dist = dist / dist.sum()
dist = dist.tolist()
out = {"distribution": dist}
output_file = r"./data_statistics/"
output_path = output_file + str(self.name) + '_' + str(num_labels) + '.json'
if not os.path.exists(output_file):
os.makedirs(output_file, exist_ok=True)
with open(output_path, 'w') as w:
json.dump(out, w)
# print(Counter(ulb_targets.tolist()))
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
ulb_dset = BasicDataset(self.alg, ulb_data, ulb_targets, self.num_classes,
self.transform, True, strong_transform, onehot)
# print(lb_data.shape)
# print(ulb_data.shape)
return lb_dset, ulb_dset
def get_data_loader(dset,
batch_size=None,
shuffle=False,
num_workers=4,
pin_memory=False,
data_sampler=None,
replacement=True,
num_epochs=None,
num_iters=None,
generator=None,
drop_last=True,
distributed=False):
"""
get_data_loader returns torch.utils.data.DataLoader for a Dataset.
All arguments are comparable with those of pytorch DataLoader.
However, if distributed, DistributedProxySampler, which is a wrapper of data_sampler, is used.
Args
num_epochs: total batch -> (# of batches in dset) * num_epochs
num_iters: total batch -> num_iters
"""
assert batch_size is not None
if data_sampler is None:
return DataLoader(dset, batch_size=batch_size, shuffle=shuffle,
num_workers=num_workers, pin_memory=pin_memory)
else:
if isinstance(data_sampler, str):
data_sampler = get_sampler_by_name(data_sampler)
if distributed:
assert dist.is_available()
num_replicas = dist.get_world_size()
else:
num_replicas = 1
if (num_epochs is not None) and (num_iters is None):
num_samples = len(dset) * num_epochs
elif (num_epochs is None) and (num_iters is not None):
num_samples = batch_size * num_iters * num_replicas
else:
num_samples = len(dset)
if data_sampler.__name__ == 'RandomSampler':
data_sampler = data_sampler(dset, replacement, num_samples, generator)
else:
raise RuntimeError(f"{data_sampler.__name__} is not implemented.")
if distributed:
'''
Different with DistributedSampler,
the DistribuedProxySampler does not shuffle the data (just wrapper for dist).
'''
data_sampler = DistributedProxySampler(data_sampler)
batch_sampler = BatchSampler(data_sampler, batch_size, drop_last)
return DataLoader(dset, batch_sampler=batch_sampler,
num_workers=num_workers, pin_memory=pin_memory)
The provided code snippet includes necessary dependencies for implementing the `main_worker` function. Write a Python function `def main_worker(gpu, ngpus_per_node, args)` to solve the following problem:
main_worker is conducted on each GPU.
Here is the function:
def main_worker(gpu, ngpus_per_node, args):
'''
main_worker is conducted on each GPU.
'''
global best_acc1
args.gpu = gpu
# random seed has to be set for the syncronization of labeled data sampling in each process.
assert args.seed is not None
random.seed(args.seed)
torch.manual_seed(args.seed)
np.random.seed(args.seed)
cudnn.deterministic = True
# SET UP FOR DISTRIBUTED TRAINING
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
args.rank = args.rank * ngpus_per_node + gpu # compute global rank
# set distributed group:
dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
world_size=args.world_size, rank=args.rank)
# SET save_path and logger
save_path = os.path.join(args.save_dir, args.save_name)
logger_level = "WARNING"
tb_log = None
if args.rank % ngpus_per_node == 0:
tb_log = TBLog(save_path, 'tensorboard', use_tensorboard=args.use_tensorboard)
logger_level = "INFO"
logger = get_logger(args.save_name, save_path, logger_level)
logger.warning(f"USE GPU: {args.gpu} for training")
# SET FreeMatch: class FreeMatch in models.freematch
args.bn_momentum = 1.0 - 0.999
if 'imagenet' in args.dataset.lower():
_net_builder = net_builder('ResNet50', False, None, is_remix=False)
args.lr = 0.1
else:
_net_builder = net_builder(args.net,
args.net_from_name,
{'first_stride': 2 if 'stl' in args.dataset else 1,
'depth': args.depth,
'widen_factor': args.widen_factor,
'leaky_slope': args.leaky_slope,
'bn_momentum': args.bn_momentum,
'dropRate': args.dropout,
'use_embed': False,
'is_remix': False},
)
model = FreeMatch(_net_builder,
args.num_classes,
args.ema_m,
args.ulb_loss_ratio,
args.ent_loss_ratio,
args.hard_label,
num_eval_iter=args.num_eval_iter,
tb_log=tb_log,
logger=logger)
logger.info(f'Number of Trainable Params: {count_parameters(model.model)}')
# SET Optimizer & LR Scheduler
## construct SGD and cosine lr scheduler
optimizer = get_optimizer(model.model, args.optim, args.lr, args.momentum, args.weight_decay)
scheduler = get_cosine_schedule_with_warmup(optimizer,
args.num_train_iter,
num_warmup_steps=args.num_train_iter * 0)
## set SGD and cosine lr on FreeMatch
model.set_optimizer(optimizer, scheduler)
# SET Devices for (Distributed) DataParallel
if not torch.cuda.is_available():
raise Exception('ONLY GPU TRAINING IS SUPPORTED')
elif args.distributed:
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
'''
batch_size: batch_size per node -> batch_size per gpu
workers: workers per node -> workers per gpu
'''
args.batch_size = int(args.batch_size / ngpus_per_node)
model.model.cuda(args.gpu)
model.model = nn.SyncBatchNorm.convert_sync_batchnorm(model.model)
model.model = torch.nn.parallel.DistributedDataParallel(model.model,
device_ids=[args.gpu],
broadcast_buffers=False,
find_unused_parameters=True)
else:
# if arg.gpu is None, DDP will divide and allocate batch_size
# to all available GPUs if device_ids are not set.
model.cuda()
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.model = model.model.cuda(args.gpu)
else:
model.model = torch.nn.DataParallel(model.model).cuda()
import copy
model.ema_model = copy.deepcopy(model.model)
logger.info(f"model_arch: {model}")
logger.info(f"Arguments: {args}")
cudnn.benchmark = True
if args.rank != 0:
torch.distributed.barrier()
# Construct Dataset & DataLoader
if args.dataset != "imagenet":
if args.num_labels == 10 and args.dataset == 'cifar10':
fixmatch_index = [
[7408, 8148, 9850, 10361, 33949, 36506, 37018, 45044, 46443, 47447],
[5022, 8193, 8902, 9601, 25226, 26223, 34089, 35186, 40595, 48024],
[7510, 13186, 14043, 21305, 22805, 31288, 34508, 40470, 41493, 45506],
[9915, 9978, 16631, 19915, 28008, 35314, 35801, 36149, 39215, 42557],
[6695, 14891, 19726, 22715, 23999, 34230, 46511, 47457, 49181, 49397],
[12830, 20293, 26835, 30517, 30898, 31061, 43693, 46501, 47310, 48517],
[1156, 11501, 19974, 21963, 32103, 42189, 46789, 47690, 48229, 48675],
[4255, 6446, 8580, 11759, 12598, 29349, 29433, 33759, 35345, 38639]]
index = fixmatch_index[-args.seed - 1]
print("10 labels for cifar10")
else:
index = None
train_dset = SSL_Dataset(args, alg='freematch', name=args.dataset, train=True,
num_classes=args.num_classes, data_dir=args.data_dir)
lb_dset, ulb_dset = train_dset.get_ssl_dset(args.num_labels, index=index)
_eval_dset = SSL_Dataset(args, alg='freematch', name=args.dataset, train=False,
num_classes=args.num_classes, data_dir=args.data_dir)
eval_dset = _eval_dset.get_dset()
else:
image_loader = ImageNetLoader(root_path=args.data_dir, num_labels=args.num_labels,
num_class=args.num_classes)
lb_dset = image_loader.get_lb_train_data()
ulb_dset = image_loader.get_ulb_train_data()
eval_dset = image_loader.get_lb_test_data()
if args.rank == 0:
torch.distributed.barrier()
loader_dict = {}
dset_dict = {'train_lb': lb_dset, 'train_ulb': ulb_dset, 'eval': eval_dset}
loader_dict['train_lb'] = get_data_loader(dset_dict['train_lb'],
args.batch_size,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=args.num_workers,
distributed=args.distributed)
loader_dict['train_ulb'] = get_data_loader(dset_dict['train_ulb'],
args.batch_size * args.uratio,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=4 * args.num_workers,
distributed=args.distributed)
loader_dict['eval'] = get_data_loader(dset_dict['eval'],
args.eval_batch_size,
num_workers=args.num_workers,
drop_last=False)
## set DataLoader on FreeMatch
model.set_data_loader(loader_dict)
model.set_dset(ulb_dset)
# If args.resume, load checkpoints from args.load_path
if args.resume:
model.load_model(args.load_path)
if args.dataset == 'svhn':
print('warm up stage')
model.warmup(args, logger=logger)
# START TRAINING of FreeMatch
trainer = model.train
for epoch in range(args.epoch):
trainer(args, logger=logger)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
model.save_model('latest_model.pth', save_path)
logging.warning(f"GPU {args.rank} training is FINISHED") | main_worker is conducted on each GPU. |
157,495 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.freematch_entropy.freematch import FreeMatch
from datasets.ssl_dataset import SSL_Dataset, ImageNetLoader
from datasets.data_utils import get_data_loader
def str2bool(v):
if isinstance(v, bool):
return v
if v.lower() in ('yes', 'true', 't', 'y', '1'):
return True
elif v.lower() in ('no', 'false', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError('Boolean value expected.') | null |
157,496 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.fixmatch.fixmatch import FixMatch
from datasets.ssl_dataset import SSL_Dataset, ImageNetLoader
from datasets.data_utils import get_data_loader
def net_builder(net_name, from_name: bool, net_conf=None, is_remix=False):
"""
return **class** of backbone network (not instance).
Args
net_name: 'WideResNet' or network names in torchvision.models
from_name: If True, net_buidler takes models in torch.vision models. Then, net_conf is ignored.
net_conf: When from_name is False, net_conf is the configuration of backbone network (now, only WRN is supported).
"""
if from_name:
import torchvision.models as models
model_name_list = sorted(name for name in models.__dict__
if name.islower() and not name.startswith("__")
and callable(models.__dict__[name]))
if net_name not in model_name_list:
assert Exception(f"[!] Networks\' Name is wrong, check net config, \
expected: {model_name_list} \
received: {net_name}")
else:
return models.__dict__[net_name]
else:
if net_name == 'WideResNet':
import models.nets.wrn as net
builder = getattr(net, 'build_WideResNet')()
elif net_name == 'WideResNetVar':
import models.nets.wrn_var as net
builder = getattr(net, 'build_WideResNetVar')()
elif net_name == 'ResNet50':
import models.nets.resnet50 as net
builder = getattr(net, 'build_ResNet50')(is_remix)
else:
assert Exception("Not Implemented Error")
if net_name != 'ResNet50':
setattr_cls_from_kwargs(builder, net_conf)
return builder.build
def get_logger(name, save_path=None, level='INFO'):
logger = logging.getLogger(name)
logger.setLevel(getattr(logging, level))
log_format = logging.Formatter('[%(asctime)s %(levelname)s] %(message)s')
streamHandler = logging.StreamHandler()
streamHandler.setFormatter(log_format)
logger.addHandler(streamHandler)
if not save_path is None:
os.makedirs(save_path, exist_ok=True)
fileHandler = logging.FileHandler(os.path.join(save_path, 'log.txt'))
fileHandler.setFormatter(log_format)
logger.addHandler(fileHandler)
return logger
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
class TBLog:
"""
Construc tensorboard writer (self.writer).
The tensorboard is saved at os.path.join(tb_dir, file_name).
"""
def __init__(self, tb_dir, file_name, use_tensorboard=False):
self.tb_dir = tb_dir
self.use_tensorboard = use_tensorboard
if self.use_tensorboard:
self.writer = SummaryWriter(os.path.join(self.tb_dir, file_name))
else:
self.writer = CustomWriter(os.path.join(self.tb_dir, file_name))
def update(self, tb_dict, it, suffix=None, mode="train"):
"""
Args
tb_dict: contains scalar values for updating tensorboard
it: contains information of iteration (int).
suffix: If not None, the update key has the suffix.
"""
if suffix is None:
suffix = ''
if self.use_tensorboard:
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value, it)
else:
self.writer.set_epoch(it, mode)
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value)
self.writer.plot_stats()
self.writer.dump_stats()
def get_optimizer(net, optim_name='SGD', lr=0.1, momentum=0.9, weight_decay=0, nesterov=True, bn_wd_skip=True):
'''
return optimizer (name) in torch.optim.
If bn_wd_skip, the optimizer does not apply
weight decay regularization on parameters in batch normalization.
'''
decay = []
no_decay = []
for name, param in net.named_parameters():
if ('bn' in name or 'bias' in name) and bn_wd_skip:
no_decay.append(param)
else:
decay.append(param)
per_param_args = [{'params': decay},
{'params': no_decay, 'weight_decay': 0.0}]
if optim_name == 'SGD':
optimizer = torch.optim.SGD(per_param_args, lr=lr, momentum=momentum, weight_decay=weight_decay,
nesterov=nesterov)
elif optim_name == 'AdamW':
optimizer = torch.optim.AdamW(per_param_args, lr=lr, weight_decay=weight_decay)
return optimizer
def get_cosine_schedule_with_warmup(optimizer,
num_training_steps,
num_cycles=7. / 16.,
num_warmup_steps=0,
last_epoch=-1):
'''
Get cosine scheduler (LambdaLR).
if warmup is needed, set num_warmup_steps (int) > 0.
'''
def _lr_lambda(current_step):
'''
_lr_lambda returns a multiplicative factor given an interger parameter epochs.
Decaying criteria: last_epoch
'''
if current_step < num_warmup_steps:
_lr = float(current_step) / float(max(1, num_warmup_steps))
else:
num_cos_steps = float(current_step - num_warmup_steps)
num_cos_steps = num_cos_steps / float(max(1, num_training_steps - num_warmup_steps))
_lr = max(0.0, math.cos(math.pi * num_cycles * num_cos_steps))
return _lr
return LambdaLR(optimizer, _lr_lambda, last_epoch)
class FixMatch:
def __init__(self, net_builder, num_classes, ema_m, T, p_cutoff, lambda_u, \
hard_label=True, t_fn=None, p_fn=None, it=0, num_eval_iter=1000, tb_log=None, logger=None):
"""
class Fixmatch contains setter of data_loader, optimizer, and model update methods.
Args:
net_builder: backbone network class (see net_builder in utils.py)
num_classes: # of label classes
ema_m: momentum of exponential moving average for eval_model
T: Temperature scaling parameter for output sharpening (only when hard_label = False)
p_cutoff: confidence cutoff parameters for loss masking
lambda_u: ratio of unsupervised loss to supervised loss
hard_label: If True, consistency regularization use a hard pseudo label.
it: initial iteration count
num_eval_iter: freqeuncy of iteration (after 500,000 iters)
tb_log: tensorboard writer (see train_utils.py)
logger: logger (see utils.py)
"""
super(FixMatch, self).__init__()
# momentum update param
self.loader = {}
self.num_classes = num_classes
self.ema_m = ema_m
# create the encoders
# network is builded only by num_classes,
# other configs are covered in main.py
self.model = net_builder(num_classes=num_classes)
self.ema_model = None
self.num_eval_iter = num_eval_iter
self.t_fn = Get_Scalar(T) # temperature params function
self.p_fn = Get_Scalar(p_cutoff) # confidence cutoff function
self.lambda_u = lambda_u
self.tb_log = tb_log
self.use_hard_label = hard_label
self.optimizer = None
self.scheduler = None
self.it = 0
self.lst = [[] for i in range(10)]
self.abs_lst = [[] for i in range(10)]
self.clsacc = [[] for i in range(10)]
self.logger = logger
self.print_fn = print if logger is None else logger.info
self.bn_controller = Bn_Controller()
def set_data_loader(self, loader_dict):
self.loader_dict = loader_dict
self.print_fn(f'[!] data loader keys: {self.loader_dict.keys()}')
def set_dset(self, dset):
self.ulb_dset = dset
def set_optimizer(self, optimizer, scheduler=None):
self.optimizer = optimizer
self.scheduler = scheduler
def train(self, args, logger=None):
ngpus_per_node = torch.cuda.device_count()
# EMA Init
self.model.train()
self.ema = EMA(self.model, self.ema_m)
self.ema.register()
if args.resume == True:
self.ema.load(self.ema_model)
# for gpu profiling
start_batch = torch.cuda.Event(enable_timing=True)
end_batch = torch.cuda.Event(enable_timing=True)
start_run = torch.cuda.Event(enable_timing=True)
end_run = torch.cuda.Event(enable_timing=True)
start_batch.record()
best_eval_acc, best_it = 0.0, 0
scaler = GradScaler()
amp_cm = autocast if args.amp else contextlib.nullcontext
# eval for once to verify if the checkpoint is loaded correctly
if args.resume == True:
eval_dict = self.evaluate(args=args)
print(eval_dict)
selected_label = torch.ones((len(self.ulb_dset),), dtype=torch.long, ) * -1
selected_label = selected_label.cuda(args.gpu)
classwise_acc = torch.zeros((args.num_classes,)).cuda(args.gpu)
for (_, x_lb, y_lb), (x_ulb_idx, x_ulb_w, x_ulb_s) in zip(self.loader_dict['train_lb'],
self.loader_dict['train_ulb']):
# prevent the training iterations exceed args.num_train_iter
if self.it > args.num_train_iter:
break
end_batch.record()
torch.cuda.synchronize()
start_run.record()
num_lb = x_lb.shape[0]
num_ulb = x_ulb_w.shape[0]
assert num_ulb == x_ulb_s.shape[0]
x_lb, x_ulb_w, x_ulb_s = x_lb.cuda(args.gpu), x_ulb_w.cuda(args.gpu), x_ulb_s.cuda(args.gpu)
y_lb = y_lb.cuda(args.gpu)
pseudo_counter = Counter(selected_label.tolist())
if max(pseudo_counter.values()) < len(self.ulb_dset): # not all(5w) -1
for i in range(args.num_classes):
classwise_acc[i] = pseudo_counter[i] / max(pseudo_counter.values())
inputs = torch.cat((x_lb, x_ulb_w, x_ulb_s))
# inference and calculate sup/unsup losses
with amp_cm():
logits = self.model(inputs)
logits_x_lb = logits[:num_lb]
logits_x_ulb_w, logits_x_ulb_s = logits[num_lb:].chunk(2)
sup_loss = ce_loss(logits_x_lb, y_lb, reduction='mean')
# hyper-params for update
T = self.t_fn(self.it)
p_cutoff = self.p_fn(self.it)
unsup_loss, mask, select, pseudo_lb = consistency_loss(logits_x_ulb_s,
logits_x_ulb_w,
'ce', T, p_cutoff,
use_hard_labels=args.hard_label)
total_loss = sup_loss + self.lambda_u * unsup_loss
# parameter updates
if args.amp:
scaler.scale(total_loss).backward()
if (args.clip > 0):
scaler.unscale_(self.optimizer)
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
scaler.step(self.optimizer)
scaler.update()
else:
total_loss.backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
self.optimizer.step()
self.scheduler.step()
self.ema.update()
self.model.zero_grad()
end_run.record()
torch.cuda.synchronize()
# tensorboard_dict update
tb_dict = {}
tb_dict['train/sup_loss'] = sup_loss.detach()
tb_dict['train/unsup_loss'] = unsup_loss.detach()
tb_dict['train/total_loss'] = total_loss.detach()
tb_dict['train/mask_ratio'] = 1.0 - mask.detach()
tb_dict['lr'] = self.optimizer.param_groups[0]['lr']
tb_dict['train/prefecth_time'] = start_batch.elapsed_time(end_batch) / 1000.
tb_dict['train/run_time'] = start_run.elapsed_time(end_run) / 1000.
# Save model for each 10K steps and best model for each 1K steps
if self.it % 10000 == 0:
save_path = os.path.join(args.save_dir, args.save_name)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
self.save_model('latest_model.pth', save_path)
if self.it % self.num_eval_iter == 0:
eval_dict = self.evaluate(args=args)
tb_dict.update(eval_dict)
save_path = os.path.join(args.save_dir, args.save_name)
if tb_dict['eval/top-1-acc'] > best_eval_acc:
best_eval_acc = tb_dict['eval/top-1-acc']
best_it = self.it
self.print_fn(
f"{self.it} iteration, USE_EMA: {self.ema_m != 0}, {tb_dict}, BEST_EVAL_ACC: {best_eval_acc}, at {best_it} iters")
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
if self.it == best_it:
self.save_model('model_best.pth', save_path)
if not self.tb_log is None:
self.tb_log.update(tb_dict, self.it)
self.it += 1
del tb_dict
start_batch.record()
if self.it > 0.8 * args.num_train_iter:
self.num_eval_iter = 1000
eval_dict = self.evaluate(args=args)
eval_dict.update({'eval/best_acc': best_eval_acc, 'eval/best_it': best_it})
return eval_dict
def evaluate(self, eval_loader=None, args=None):
self.model.eval()
self.ema.apply_shadow()
if eval_loader is None:
eval_loader = self.loader_dict['eval']
total_loss = 0.0
total_num = 0.0
y_true = []
y_pred = []
y_logits = []
for _, x, y in eval_loader:
x, y = x.cuda(args.gpu), y.cuda(args.gpu)
num_batch = x.shape[0]
total_num += num_batch
logits = self.model(x)
loss = F.cross_entropy(logits, y, reduction='mean')
y_true.extend(y.cpu().tolist())
y_pred.extend(torch.max(logits, dim=-1)[1].cpu().tolist())
y_logits.extend(torch.softmax(logits, dim=-1).cpu().tolist())
total_loss += loss.detach() * num_batch
top1 = accuracy_score(y_true, y_pred)
top5 = top_k_accuracy_score(y_true, y_logits, k=5)
precision = precision_score(y_true, y_pred, average='macro')
recall = recall_score(y_true, y_pred, average='macro')
F1 = f1_score(y_true, y_pred, average='macro')
AUC = roc_auc_score(y_true, y_logits, multi_class='ovo')
cf_mat = confusion_matrix(y_true, y_pred, normalize='true')
self.print_fn('confusion matrix:\n' + np.array_str(cf_mat))
self.ema.restore()
self.model.train()
return {'eval/loss': total_loss / total_num, 'eval/top-1-acc': top1, 'eval/top-5-acc': top5,
'eval/precision': precision, 'eval/recall': recall, 'eval/F1': F1, 'eval/AUC': AUC}
def save_model(self, save_name, save_path):
save_filename = os.path.join(save_path, save_name)
# copy EMA parameters to ema_model for saving with model as temp
self.model.eval()
self.ema.apply_shadow()
ema_model = self.model.state_dict()
self.ema.restore()
self.model.train()
torch.save({'model': self.model.state_dict(),
'optimizer': self.optimizer.state_dict(),
'scheduler': self.scheduler.state_dict(),
'it': self.it + 1,
'ema_model': ema_model},
save_filename)
self.print_fn(f"model saved: {save_filename}")
def load_model(self, load_path):
checkpoint = torch.load(load_path)
self.model.load_state_dict(checkpoint['model'])
self.ema_model = deepcopy(self.model)
self.ema_model.load_state_dict(checkpoint['ema_model'])
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.scheduler.load_state_dict(checkpoint['scheduler'])
self.it = checkpoint['it']
self.print_fn('model loaded')
def interleave_offsets(self, batch, nu):
groups = [batch // (nu + 1)] * (nu + 1)
for x in range(batch - sum(groups)):
groups[-x - 1] += 1
offsets = [0]
for g in groups:
offsets.append(offsets[-1] + g)
assert offsets[-1] == batch
return offsets
def interleave(self, xy, batch):
nu = len(xy) - 1
offsets = self.interleave_offsets(batch, nu)
xy = [[v[offsets[p]:offsets[p + 1]] for p in range(nu + 1)] for v in xy]
for i in range(1, nu + 1):
xy[0][i], xy[i][i] = xy[i][i], xy[0][i]
return [torch.cat(v, dim=0) for v in xy]
class ImageNetLoader:
def __init__(self, root_path, num_labels=-1, num_class=1000):
self.root_path = os.path.join(root_path, 'imagenet')
self.num_labels = num_labels // num_class
def get_transform(self, train, ulb):
if train:
transform = transforms.Compose([
transforms.Resize([256, 256]),
transforms.RandomHorizontalFlip(),
transforms.RandomCrop(224, padding=4, padding_mode='reflect'),
transforms.ToTensor(),
transforms.Normalize(mean["imagenet"], std["imagenet"])])
else:
transform = transforms.Compose([
transforms.Resize([224, 224]),
transforms.ToTensor(),
transforms.Normalize(mean["imagenet"], std["imagenet"])])
return transform
def get_lb_train_data(self):
transform = self.get_transform(train=True, ulb=False)
data = ImagenetDataset(root=os.path.join(self.root_path, "train"), transform=transform, ulb=False,
num_labels=self.num_labels)
return data
def get_ulb_train_data(self):
transform = self.get_transform(train=True, ulb=True)
data = ImagenetDataset(root=os.path.join(self.root_path, "train"), transform=transform, ulb=True)
return data
def get_lb_test_data(self):
transform = self.get_transform(train=False, ulb=False)
data = ImagenetDataset(root=os.path.join(self.root_path, "val"), transform=transform, ulb=False)
return data
class SSL_Dataset:
"""
SSL_Dataset class gets dataset from torchvision.datasets,
separates labeled and unlabeled data,
and return BasicDataset: torch.utils.data.Dataset (see datasets.dataset.py)
"""
def __init__(self,
args,
alg='fixmatch',
name='cifar10',
train=True,
num_classes=10,
data_dir='./data'):
"""
Args
alg: SSL algorithms
name: name of dataset in torchvision.datasets (cifar10, cifar100, svhn, stl10)
train: True means the dataset is training dataset (default=True)
num_classes: number of label classes
data_dir: path of directory, where data is downloaed or stored.
"""
self.args = args
self.alg = alg
self.name = name
self.train = train
self.num_classes = num_classes
self.data_dir = data_dir
crop_size = 96 if self.name.upper() == 'STL10' else 224 if self.name.upper() == 'IMAGENET' else 32
self.transform = get_transform(mean[name], std[name], crop_size, train)
def get_data(self, svhn_extra=True):
"""
get_data returns data (images) and targets (labels)
shape of data: B, H, W, C
shape of labels: B,
"""
dset = getattr(torchvision.datasets, self.name.upper())
if 'CIFAR' in self.name.upper():
dset = dset(self.data_dir, train=self.train, download=True)
data, targets = dset.data, dset.targets
return data, targets
elif self.name.upper() == 'SVHN':
if self.train:
if svhn_extra: # train+extra
dset_base = dset(self.data_dir, split='train', download=True)
data_b, targets_b = dset_base.data.transpose([0, 2, 3, 1]), dset_base.labels
dset_extra = dset(self.data_dir, split='extra', download=True)
data_e, targets_e = dset_extra.data.transpose([0, 2, 3, 1]), dset_extra.labels
data = np.concatenate([data_b, data_e])
targets = np.concatenate([targets_b, targets_e])
del data_b, data_e
del targets_b, targets_e
else: # train_only
dset = dset(self.data_dir, split='train', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
else: # test
dset = dset(self.data_dir, split='test', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
return data, targets
elif self.name.upper() == 'STL10':
split = 'train' if self.train else 'test'
dset_lb = dset(self.data_dir, split=split, download=True)
dset_ulb = dset(self.data_dir, split='unlabeled', download=True)
data, targets = dset_lb.data.transpose([0, 2, 3, 1]), dset_lb.labels.astype(np.int64)
ulb_data = dset_ulb.data.transpose([0, 2, 3, 1])
return data, targets, ulb_data
def get_dset(self, is_ulb=False,
strong_transform=None, onehot=False):
"""
get_dset returns class BasicDataset, containing the returns of get_data.
Args
is_ulb: If True, returned dataset generates a pair of weak and strong augmented images.
strong_transform: list of strong_transform (augmentation) if use_strong_transform is True。
onehot: If True, the label is not integer, but one-hot vector.
"""
if self.name.upper() == 'STL10':
data, targets, _ = self.get_data()
else:
data, targets = self.get_data()
num_classes = self.num_classes
transform = self.transform
return BasicDataset(self.alg, data, targets, num_classes, transform,
is_ulb, strong_transform, onehot)
def get_ssl_dset(self, num_labels, index=None, include_lb_to_ulb=True,
strong_transform=None, onehot=False):
"""
get_ssl_dset split training samples into labeled and unlabeled samples.
The labeled data is balanced samples over classes.
Args:
num_labels: number of labeled data.
index: If index of np.array is given, labeled data is not randomly sampled, but use index for sampling.
include_lb_to_ulb: If True, consistency regularization is also computed for the labeled data.
strong_transform: list of strong transform (RandAugment in FixMatch)
onehot: If True, the target is converted into onehot vector.
Returns:
BasicDataset (for labeled data), BasicDataset (for unlabeld data)
"""
# Supervised top line using all data as labeled data.
if self.alg == 'fullysupervised':
lb_data, lb_targets = self.get_data()
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
return lb_dset, None
if self.name.upper() == 'STL10':
lb_data, lb_targets, ulb_data = self.get_data()
if include_lb_to_ulb:
ulb_data = np.concatenate([ulb_data, lb_data], axis=0)
lb_data, lb_targets, _ = sample_labeled_data(self.args, lb_data, lb_targets, num_labels, self.num_classes)
ulb_targets = None
else:
data, targets = self.get_data()
lb_data, lb_targets, ulb_data, ulb_targets = split_ssl_data(self.args, data, targets,
num_labels, self.num_classes,
index, include_lb_to_ulb)
# output the distribution of labeled data for remixmatch
count = [0 for _ in range(self.num_classes)]
for c in lb_targets:
count[c] += 1
dist = np.array(count, dtype=float)
dist = dist / dist.sum()
dist = dist.tolist()
out = {"distribution": dist}
output_file = r"./data_statistics/"
output_path = output_file + str(self.name) + '_' + str(num_labels) + '.json'
if not os.path.exists(output_file):
os.makedirs(output_file, exist_ok=True)
with open(output_path, 'w') as w:
json.dump(out, w)
# print(Counter(ulb_targets.tolist()))
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
ulb_dset = BasicDataset(self.alg, ulb_data, ulb_targets, self.num_classes,
self.transform, True, strong_transform, onehot)
# print(lb_data.shape)
# print(ulb_data.shape)
return lb_dset, ulb_dset
def get_data_loader(dset,
batch_size=None,
shuffle=False,
num_workers=4,
pin_memory=False,
data_sampler=None,
replacement=True,
num_epochs=None,
num_iters=None,
generator=None,
drop_last=True,
distributed=False):
"""
get_data_loader returns torch.utils.data.DataLoader for a Dataset.
All arguments are comparable with those of pytorch DataLoader.
However, if distributed, DistributedProxySampler, which is a wrapper of data_sampler, is used.
Args
num_epochs: total batch -> (# of batches in dset) * num_epochs
num_iters: total batch -> num_iters
"""
assert batch_size is not None
if data_sampler is None:
return DataLoader(dset, batch_size=batch_size, shuffle=shuffle,
num_workers=num_workers, pin_memory=pin_memory)
else:
if isinstance(data_sampler, str):
data_sampler = get_sampler_by_name(data_sampler)
if distributed:
assert dist.is_available()
num_replicas = dist.get_world_size()
else:
num_replicas = 1
if (num_epochs is not None) and (num_iters is None):
num_samples = len(dset) * num_epochs
elif (num_epochs is None) and (num_iters is not None):
num_samples = batch_size * num_iters * num_replicas
else:
num_samples = len(dset)
if data_sampler.__name__ == 'RandomSampler':
data_sampler = data_sampler(dset, replacement, num_samples, generator)
else:
raise RuntimeError(f"{data_sampler.__name__} is not implemented.")
if distributed:
'''
Different with DistributedSampler,
the DistribuedProxySampler does not shuffle the data (just wrapper for dist).
'''
data_sampler = DistributedProxySampler(data_sampler)
batch_sampler = BatchSampler(data_sampler, batch_size, drop_last)
return DataLoader(dset, batch_sampler=batch_sampler,
num_workers=num_workers, pin_memory=pin_memory)
The provided code snippet includes necessary dependencies for implementing the `main_worker` function. Write a Python function `def main_worker(gpu, ngpus_per_node, args)` to solve the following problem:
main_worker is conducted on each GPU.
Here is the function:
def main_worker(gpu, ngpus_per_node, args):
'''
main_worker is conducted on each GPU.
'''
global best_acc1
args.gpu = gpu
# random seed has to be set for the syncronization of labeled data sampling in each process.
assert args.seed is not None
random.seed(args.seed)
torch.manual_seed(args.seed)
np.random.seed(args.seed)
cudnn.deterministic = True
# SET UP FOR DISTRIBUTED TRAINING
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
args.rank = args.rank * ngpus_per_node + gpu # compute global rank
# set distributed group:
dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
world_size=args.world_size, rank=args.rank)
# SET save_path and logger
save_path = os.path.join(args.save_dir, args.save_name)
logger_level = "WARNING"
tb_log = None
if args.rank % ngpus_per_node == 0:
tb_log = TBLog(save_path, 'tensorboard', use_tensorboard=args.use_tensorboard)
logger_level = "INFO"
logger = get_logger(args.save_name, save_path, logger_level)
logger.warning(f"USE GPU: {args.gpu} for training")
# SET FixMatch: class FixMatch in models.fixmatch
args.bn_momentum = 1.0 - 0.999
if 'imagenet' in args.dataset.lower():
_net_builder = net_builder('ResNet50', False, None, is_remix=False)
else:
_net_builder = net_builder(args.net,
args.net_from_name,
{'first_stride': 2 if 'stl' in args.dataset else 1,
'depth': args.depth,
'widen_factor': args.widen_factor,
'leaky_slope': args.leaky_slope,
'bn_momentum': args.bn_momentum,
'dropRate': args.dropout,
'use_embed': False,
'is_remix': False},
)
model = FixMatch(_net_builder,
args.num_classes,
args.ema_m,
args.T,
args.p_cutoff,
args.ulb_loss_ratio,
args.hard_label,
num_eval_iter=args.num_eval_iter,
tb_log=tb_log,
logger=logger)
logger.info(f'Number of Trainable Params: {count_parameters(model.model)}')
# SET Optimizer & LR Scheduler
## construct SGD and cosine lr scheduler
optimizer = get_optimizer(model.model, args.optim, args.lr, args.momentum, args.weight_decay)
scheduler = get_cosine_schedule_with_warmup(optimizer,
args.num_train_iter,
num_warmup_steps=args.num_train_iter * 0)
## set SGD and cosine lr on FixMatch
model.set_optimizer(optimizer, scheduler)
# SET Devices for (Distributed) DataParallel
if not torch.cuda.is_available():
raise Exception('ONLY GPU TRAINING IS SUPPORTED')
elif args.distributed:
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
'''
batch_size: batch_size per node -> batch_size per gpu
workers: workers per node -> workers per gpu
'''
args.batch_size = int(args.batch_size / ngpus_per_node)
model.model.cuda(args.gpu)
model.model = nn.SyncBatchNorm.convert_sync_batchnorm(model.model)
model.model = torch.nn.parallel.DistributedDataParallel(model.model,
device_ids=[args.gpu],
broadcast_buffers=False,
find_unused_parameters=True)
else:
# if arg.gpu is None, DDP will divide and allocate batch_size
# to all available GPUs if device_ids are not set.
model.cuda()
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.model = model.model.cuda(args.gpu)
else:
model.model = torch.nn.DataParallel(model.model).cuda()
import copy
model.ema_model = copy.deepcopy(model.model)
logger.info(f"model_arch: {model}")
logger.info(f"Arguments: {args}")
cudnn.benchmark = True
if args.rank != 0 and args.distributed:
torch.distributed.barrier()
# Construct Dataset & DataLoader
if args.dataset != "imagenet":
if args.num_labels == 10 and args.dataset == 'cifar10':
fixmatch_index = [
[7408, 8148, 9850, 10361, 33949, 36506, 37018, 45044, 46443, 47447],
[5022, 8193, 8902, 9601, 25226, 26223, 34089, 35186, 40595, 48024],
[7510, 13186, 14043, 21305, 22805, 31288, 34508, 40470, 41493, 45506],
[9915, 9978, 16631, 19915, 28008, 35314, 35801, 36149, 39215, 42557],
[6695, 14891, 19726, 22715, 23999, 34230, 46511, 47457, 49181, 49397],
[12830, 20293, 26835, 30517, 30898, 31061, 43693, 46501, 47310, 48517],
[1156, 11501, 19974, 21963, 32103, 42189, 46789, 47690, 48229, 48675],
[4255, 6446, 8580, 11759, 12598, 29349, 29433, 33759, 35345, 38639]]
index = fixmatch_index[-args.seed - 1]
print("10 labels for cifar10")
else:
index = None
train_dset = SSL_Dataset(args, alg='fixmatch', name=args.dataset, train=True,
num_classes=args.num_classes, data_dir=args.data_dir)
lb_dset, ulb_dset = train_dset.get_ssl_dset(args.num_labels,index=index)
_eval_dset = SSL_Dataset(args, alg='fixmatch', name=args.dataset, train=False,
num_classes=args.num_classes, data_dir=args.data_dir)
eval_dset = _eval_dset.get_dset()
else:
image_loader = ImageNetLoader(root_path=args.data_dir, num_labels=args.num_labels,
num_class=args.num_classes)
lb_dset = image_loader.get_lb_train_data()
ulb_dset = image_loader.get_ulb_train_data()
eval_dset = image_loader.get_lb_test_data()
if args.rank == 0 and args.distributed:
torch.distributed.barrier()
loader_dict = {}
dset_dict = {'train_lb': lb_dset, 'train_ulb': ulb_dset, 'eval': eval_dset}
loader_dict['train_lb'] = get_data_loader(dset_dict['train_lb'],
args.batch_size,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=args.num_workers,
distributed=args.distributed)
loader_dict['train_ulb'] = get_data_loader(dset_dict['train_ulb'],
args.batch_size * args.uratio,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=4 * args.num_workers,
distributed=args.distributed)
loader_dict['eval'] = get_data_loader(dset_dict['eval'],
args.eval_batch_size,
num_workers=args.num_workers,
drop_last=False)
## set DataLoader on FixMatch
model.set_data_loader(loader_dict)
model.set_dset(ulb_dset)
# If args.resume, load checkpoints from args.load_path
if args.resume:
model.load_model(args.load_path)
# START TRAINING of FixMatch
trainer = model.train
for epoch in range(args.epoch):
trainer(args, logger=logger)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
model.save_model('latest_model.pth', save_path)
logging.warning(f"GPU {args.rank} training is FINISHED") | main_worker is conducted on each GPU. |
157,497 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.fixmatch.fixmatch import FixMatch
from datasets.ssl_dataset import SSL_Dataset, ImageNetLoader
from datasets.data_utils import get_data_loader
def str2bool(v):
if isinstance(v, bool):
return v
if v.lower() in ('yes', 'true', 't', 'y', '1'):
return True
elif v.lower() in ('no', 'false', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError('Boolean value expected.') | null |
157,498 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.freematch.freematch import FreeMatch
from datasets.ssl_dataset import SSL_Dataset, ImageNetLoader
from datasets.data_utils import get_data_loader
def net_builder(net_name, from_name: bool, net_conf=None, is_remix=False):
"""
return **class** of backbone network (not instance).
Args
net_name: 'WideResNet' or network names in torchvision.models
from_name: If True, net_buidler takes models in torch.vision models. Then, net_conf is ignored.
net_conf: When from_name is False, net_conf is the configuration of backbone network (now, only WRN is supported).
"""
if from_name:
import torchvision.models as models
model_name_list = sorted(name for name in models.__dict__
if name.islower() and not name.startswith("__")
and callable(models.__dict__[name]))
if net_name not in model_name_list:
assert Exception(f"[!] Networks\' Name is wrong, check net config, \
expected: {model_name_list} \
received: {net_name}")
else:
return models.__dict__[net_name]
else:
if net_name == 'WideResNet':
import models.nets.wrn as net
builder = getattr(net, 'build_WideResNet')()
elif net_name == 'WideResNetVar':
import models.nets.wrn_var as net
builder = getattr(net, 'build_WideResNetVar')()
elif net_name == 'ResNet50':
import models.nets.resnet50 as net
builder = getattr(net, 'build_ResNet50')(is_remix)
else:
assert Exception("Not Implemented Error")
if net_name != 'ResNet50':
setattr_cls_from_kwargs(builder, net_conf)
return builder.build
def get_logger(name, save_path=None, level='INFO'):
logger = logging.getLogger(name)
logger.setLevel(getattr(logging, level))
log_format = logging.Formatter('[%(asctime)s %(levelname)s] %(message)s')
streamHandler = logging.StreamHandler()
streamHandler.setFormatter(log_format)
logger.addHandler(streamHandler)
if not save_path is None:
os.makedirs(save_path, exist_ok=True)
fileHandler = logging.FileHandler(os.path.join(save_path, 'log.txt'))
fileHandler.setFormatter(log_format)
logger.addHandler(fileHandler)
return logger
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
class TBLog:
"""
Construc tensorboard writer (self.writer).
The tensorboard is saved at os.path.join(tb_dir, file_name).
"""
def __init__(self, tb_dir, file_name, use_tensorboard=False):
self.tb_dir = tb_dir
self.use_tensorboard = use_tensorboard
if self.use_tensorboard:
self.writer = SummaryWriter(os.path.join(self.tb_dir, file_name))
else:
self.writer = CustomWriter(os.path.join(self.tb_dir, file_name))
def update(self, tb_dict, it, suffix=None, mode="train"):
"""
Args
tb_dict: contains scalar values for updating tensorboard
it: contains information of iteration (int).
suffix: If not None, the update key has the suffix.
"""
if suffix is None:
suffix = ''
if self.use_tensorboard:
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value, it)
else:
self.writer.set_epoch(it, mode)
for key, value in tb_dict.items():
self.writer.add_scalar(suffix + key, value)
self.writer.plot_stats()
self.writer.dump_stats()
def get_optimizer(net, optim_name='SGD', lr=0.1, momentum=0.9, weight_decay=0, nesterov=True, bn_wd_skip=True):
'''
return optimizer (name) in torch.optim.
If bn_wd_skip, the optimizer does not apply
weight decay regularization on parameters in batch normalization.
'''
decay = []
no_decay = []
for name, param in net.named_parameters():
if ('bn' in name or 'bias' in name) and bn_wd_skip:
no_decay.append(param)
else:
decay.append(param)
per_param_args = [{'params': decay},
{'params': no_decay, 'weight_decay': 0.0}]
if optim_name == 'SGD':
optimizer = torch.optim.SGD(per_param_args, lr=lr, momentum=momentum, weight_decay=weight_decay,
nesterov=nesterov)
elif optim_name == 'AdamW':
optimizer = torch.optim.AdamW(per_param_args, lr=lr, weight_decay=weight_decay)
return optimizer
def get_cosine_schedule_with_warmup(optimizer,
num_training_steps,
num_cycles=7. / 16.,
num_warmup_steps=0,
last_epoch=-1):
'''
Get cosine scheduler (LambdaLR).
if warmup is needed, set num_warmup_steps (int) > 0.
'''
def _lr_lambda(current_step):
'''
_lr_lambda returns a multiplicative factor given an interger parameter epochs.
Decaying criteria: last_epoch
'''
if current_step < num_warmup_steps:
_lr = float(current_step) / float(max(1, num_warmup_steps))
else:
num_cos_steps = float(current_step - num_warmup_steps)
num_cos_steps = num_cos_steps / float(max(1, num_training_steps - num_warmup_steps))
_lr = max(0.0, math.cos(math.pi * num_cycles * num_cos_steps))
return _lr
return LambdaLR(optimizer, _lr_lambda, last_epoch)
class FreeMatch:
def __init__(self, net_builder, num_classes, ema_m, lambda_u, lambda_e, \
hard_label=True, t_fn=None, p_fn=None, it=0, num_eval_iter=1000, tb_log=None, logger=None):
"""
class Freematch contains setter of data_loader, optimizer, and model update methods.
Args:
net_builder: backbone network class (see net_builder in utils.py)
num_classes: # of label classes
ema_m: momentum of exponential moving average for eval_model
lambda_u: ratio of unsupervised loss to supervised loss
hard_label: If True, consistency regularization use a hard pseudo label.
it: initial iteration count
num_eval_iter: freqeuncy of iteration (after 500,000 iters)
tb_log: tensorboard writer (see train_utils.py)
logger: logger (see utils.py)
"""
super(FreeMatch, self).__init__()
# momentum update param
self.loader = {}
self.num_classes = num_classes
self.ema_m = ema_m
# create the encoders
# network is builded only by num_classes,
# other configs are covered in main.py
self.model = net_builder(num_classes=num_classes)
self.ema_model = None
self.num_eval_iter = num_eval_iter
self.lambda_u = lambda_u
self.lambda_e = lambda_e
self.tb_log = tb_log
self.use_hard_label = hard_label
self.optimizer = None
self.scheduler = None
self.it = 0
self.lst = [[] for i in range(10)]
self.abs_lst = [[] for i in range(10)]
self.clsacc = [[] for i in range(10)]
self.logger = logger
self.print_fn = print if logger is None else logger.info
self.bn_controller = Bn_Controller()
def set_data_loader(self, loader_dict):
self.loader_dict = loader_dict
self.print_fn(f'[!] data loader keys: {self.loader_dict.keys()}')
def set_dset(self, dset):
self.ulb_dset = dset
def set_optimizer(self, optimizer, scheduler=None):
self.optimizer = optimizer
self.scheduler = scheduler
def warmup(self, args, logger=None):
ngpus_per_node = torch.cuda.device_count()
self.model.train()
# for gpu profiling
start_batch = torch.cuda.Event(enable_timing=True)
end_batch = torch.cuda.Event(enable_timing=True)
start_run = torch.cuda.Event(enable_timing=True)
end_run = torch.cuda.Event(enable_timing=True)
warmup_it = 0
start_batch.record()
scaler = GradScaler()
amp_cm = autocast if args.amp else contextlib.nullcontext
for _, x_lb, y_lb in self.loader_dict['train_lb']:
# prevent the training iterations exceed args.num_train_iter
if warmup_it > 2048:
break
end_batch.record()
torch.cuda.synchronize()
start_run.record()
x_lb = x_lb.cuda(args.gpu)
y_lb = y_lb.cuda(args.gpu)
num_lb = x_lb.shape[0]
# inference and calculate sup/unsup losses
with amp_cm():
logits_x_lb = self.model(x_lb)
sup_loss = ce_loss(logits_x_lb, y_lb, use_hard_labels=True, reduction='mean')
total_loss = sup_loss
# parameter updates
if args.amp:
scaler.scale(total_loss).backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
scaler.step(self.optimizer)
scaler.update()
else:
total_loss.backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
self.optimizer.step()
self.model.zero_grad()
end_run.record()
torch.cuda.synchronize()
# tensorboard_dict update
tb_dict = {}
tb_dict['train/sup_loss'] = sup_loss.item()
tb_dict['lr'] = self.optimizer.param_groups[0]['lr']
tb_dict['train/prefecth_time'] = start_batch.elapsed_time(end_batch) / 1000.
tb_dict['train/run_time'] = start_run.elapsed_time(end_run) / 1000.
if warmup_it % 1000 == 0:
self.print_fn(f"warmup {warmup_it} iteration, {tb_dict}")
del tb_dict
start_batch.record()
warmup_it += 1
# compute p_model, time_p,
self.model.eval()
probs = []
with torch.no_grad():
for _, x, y in self.loader_dict['eval']:
x = x.cuda(args.gpu)
y = y.cuda(args.gpu)
# inference and calculate sup/unsup losses
with amp_cm():
logits = self.model(x)
probs.append(logits.softmax(dim=-1).cpu())
probs = torch.cat(probs)
max_probs, max_idx = torch.max(probs, dim=-1)
self.time_p = max_probs.mean()
self.p_model = torch.mean(probs, dim=0)
label_hist = torch.bincount(max_idx, minlength=probs.shape[1]).to(probs.dtype)
self.label_hist = label_hist / label_hist.sum()
def train(self, args, logger=None):
ngpus_per_node = torch.cuda.device_count()
# EMA Init
self.model.train()
self.ema = EMA(self.model, self.ema_m)
self.ema.register()
if args.resume == True:
self.ema.load(self.ema_model)
# for gpu profiling
start_batch = torch.cuda.Event(enable_timing=True)
end_batch = torch.cuda.Event(enable_timing=True)
start_run = torch.cuda.Event(enable_timing=True)
end_run = torch.cuda.Event(enable_timing=True)
start_batch.record()
best_eval_acc, best_it = 0.0, 0
scaler = GradScaler()
amp_cm = autocast if args.amp else contextlib.nullcontext
# eval for once to verify if the checkpoint is loaded correctly
if args.resume == True:
eval_dict = self.evaluate(args=args)
print(eval_dict)
p_model = (torch.ones(args.num_classes) / args.num_classes).cuda()
label_hist = (torch.ones(args.num_classes) / args.num_classes).cuda()
time_p = p_model.mean()
for (_, x_lb, y_lb), (x_ulb_idx, x_ulb_w, x_ulb_s) in zip(self.loader_dict['train_lb'],
self.loader_dict['train_ulb']):
# prevent the training iterations exceed args.num_train_iter
if self.it > args.num_train_iter:
break
end_batch.record()
torch.cuda.synchronize()
start_run.record()
num_lb = x_lb.shape[0]
num_ulb = x_ulb_w.shape[0]
assert num_ulb == x_ulb_s.shape[0]
x_lb, x_ulb_w, x_ulb_s = x_lb.cuda(args.gpu), x_ulb_w.cuda(args.gpu), x_ulb_s.cuda(args.gpu)
y_lb = y_lb.cuda(args.gpu)
inputs = torch.cat((x_lb, x_ulb_w, x_ulb_s))
# inference and calculate sup/unsup losses
with amp_cm():
logits = self.model(inputs)
logits_x_lb = logits[:num_lb]
logits_x_ulb_w, logits_x_ulb_s = logits[num_lb:].chunk(2)
sup_loss = ce_loss(logits_x_lb, y_lb, reduction='mean')
# hyper-params for update
time_p, p_model, label_hist = self.cal_time_p_and_p_model(logits_x_ulb_w, time_p, p_model, label_hist)
unsup_loss, mask = consistency_loss(args.dataset,logits_x_ulb_s,logits_x_ulb_w,
time_p,p_model,
'ce', use_hard_labels=args.hard_label)
total_loss = sup_loss + self.lambda_u * unsup_loss
# parameter updates
if args.amp:
scaler.scale(total_loss).backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
scaler.step(self.optimizer)
scaler.update()
else:
total_loss.backward()
if (args.clip > 0):
torch.nn.utils.clip_grad_norm_(self.model.parameters(), args.clip)
self.optimizer.step()
self.scheduler.step()
self.ema.update()
self.model.zero_grad()
end_run.record()
torch.cuda.synchronize()
# tensorboard_dict update
tb_dict = {}
tb_dict['train/sup_loss'] = sup_loss.item()
tb_dict['train/unsup_loss'] = unsup_loss.item()
tb_dict['train/total_loss'] = total_loss.item()
tb_dict['train/time_p'] = time_p.item()
tb_dict['train/mask_ratio'] = 1.0 - mask.float().mean().item()
tb_dict['train/p_model'] = p_model.mean().item()
tb_dict['train/label_hist'] = label_hist.mean().item()
tb_dict['lr'] = self.optimizer.param_groups[0]['lr']
tb_dict['train/prefecth_time'] = start_batch.elapsed_time(end_batch) / 1000.
tb_dict['train/run_time'] = start_run.elapsed_time(end_run) / 1000.
# Save model for each 10K steps and best model for each 1K steps
if self.it % 10000 == 0:
save_path = os.path.join(args.save_dir, args.save_name)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
self.save_model('latest_model.pth', save_path)
if self.it % self.num_eval_iter == 0:
eval_dict = self.evaluate(args=args)
tb_dict.update(eval_dict)
save_path = os.path.join(args.save_dir, args.save_name)
if tb_dict['eval/top-1-acc'] > best_eval_acc:
best_eval_acc = tb_dict['eval/top-1-acc']
best_it = self.it
self.print_fn(
f"{self.it} iteration, USE_EMA: {self.ema_m != 0}, {tb_dict}, BEST_EVAL_ACC: {best_eval_acc}, at {best_it} iters")
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
if self.it == best_it:
self.save_model('model_best.pth', save_path)
if not self.tb_log is None:
self.tb_log.update(tb_dict, self.it)
self.it += 1
del tb_dict
start_batch.record()
if self.it > 0.8 * args.num_train_iter:
self.num_eval_iter = 1000
eval_dict = self.evaluate(args=args)
eval_dict.update({'eval/best_acc': best_eval_acc, 'eval/best_it': best_it})
return eval_dict
def cal_time_p_and_p_model(self,logits_x_ulb_w, time_p, p_model, label_hist):
prob_w = torch.softmax(logits_x_ulb_w, dim=1)
max_probs, max_idx = torch.max(prob_w, dim=-1)
if time_p is None:
time_p = max_probs.mean()
else:
time_p = time_p * 0.999 + max_probs.mean() * 0.001
if p_model is None:
p_model = torch.mean(prob_w, dim=0)
else:
p_model = p_model * 0.999 + torch.mean(prob_w, dim=0) * 0.001
if label_hist is None:
label_hist = torch.bincount(max_idx, minlength=p_model.shape[0]).to(p_model.dtype)
label_hist = label_hist / label_hist.sum()
else:
hist = torch.bincount(max_idx, minlength=p_model.shape[0]).to(p_model.dtype)
label_hist = label_hist * 0.999 + (hist / hist.sum()) * 0.001
return time_p,p_model,label_hist
def evaluate(self, eval_loader=None, args=None):
self.model.eval()
self.ema.apply_shadow()
if eval_loader is None:
eval_loader = self.loader_dict['eval']
total_loss = 0.0
total_num = 0.0
y_true = []
y_pred = []
y_logits = []
for _, x, y in eval_loader:
x, y = x.cuda(args.gpu), y.cuda(args.gpu)
num_batch = x.shape[0]
total_num += num_batch
logits = self.model(x)
loss = F.cross_entropy(logits, y, reduction='mean')
y_true.extend(y.cpu().tolist())
y_pred.extend(torch.max(logits, dim=-1)[1].cpu().tolist())
y_logits.extend(torch.softmax(logits, dim=-1).cpu().tolist())
total_loss += loss.detach() * num_batch
top1 = accuracy_score(y_true, y_pred)
top5 = top_k_accuracy_score(y_true, y_logits, k=5)
precision = precision_score(y_true, y_pred, average='macro')
recall = recall_score(y_true, y_pred, average='macro')
F1 = f1_score(y_true, y_pred, average='macro')
AUC = roc_auc_score(y_true, y_logits, multi_class='ovo')
cf_mat = confusion_matrix(y_true, y_pred, normalize='true')
self.print_fn('confusion matrix:\n' + np.array_str(cf_mat))
self.ema.restore()
self.model.train()
return {'eval/loss': total_loss / total_num, 'eval/top-1-acc': top1, 'eval/top-5-acc': top5,
'eval/precision': precision, 'eval/recall': recall, 'eval/F1': F1, 'eval/AUC': AUC}
def save_model(self, save_name, save_path):
save_filename = os.path.join(save_path, save_name)
# copy EMA parameters to ema_model for saving with model as temp
self.model.eval()
self.ema.apply_shadow()
ema_model = self.model.state_dict()
self.ema.restore()
self.model.train()
torch.save({'model': self.model.state_dict(),
'optimizer': self.optimizer.state_dict(),
'scheduler': self.scheduler.state_dict(),
'it': self.it,
'ema_model': ema_model},
save_filename)
self.print_fn(f"model saved: {save_filename}")
def load_model(self, load_path):
checkpoint = torch.load(load_path)
self.model.load_state_dict(checkpoint['model'])
self.ema_model = deepcopy(self.model)
self.ema_model.load_state_dict(checkpoint['ema_model'])
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.scheduler.load_state_dict(checkpoint['scheduler'])
self.it = checkpoint['it']
self.print_fn('model loaded')
def interleave_offsets(self, batch, nu):
groups = [batch // (nu + 1)] * (nu + 1)
for x in range(batch - sum(groups)):
groups[-x - 1] += 1
offsets = [0]
for g in groups:
offsets.append(offsets[-1] + g)
assert offsets[-1] == batch
return offsets
def interleave(self, xy, batch):
nu = len(xy) - 1
offsets = self.interleave_offsets(batch, nu)
xy = [[v[offsets[p]:offsets[p + 1]] for p in range(nu + 1)] for v in xy]
for i in range(1, nu + 1):
xy[0][i], xy[i][i] = xy[i][i], xy[0][i]
return [torch.cat(v, dim=0) for v in xy]
class ImageNetLoader:
def __init__(self, root_path, num_labels=-1, num_class=1000):
self.root_path = os.path.join(root_path, 'imagenet')
self.num_labels = num_labels // num_class
def get_transform(self, train, ulb):
if train:
transform = transforms.Compose([
transforms.Resize([256, 256]),
transforms.RandomHorizontalFlip(),
transforms.RandomCrop(224, padding=4, padding_mode='reflect'),
transforms.ToTensor(),
transforms.Normalize(mean["imagenet"], std["imagenet"])])
else:
transform = transforms.Compose([
transforms.Resize([224, 224]),
transforms.ToTensor(),
transforms.Normalize(mean["imagenet"], std["imagenet"])])
return transform
def get_lb_train_data(self):
transform = self.get_transform(train=True, ulb=False)
data = ImagenetDataset(root=os.path.join(self.root_path, "train"), transform=transform, ulb=False,
num_labels=self.num_labels)
return data
def get_ulb_train_data(self):
transform = self.get_transform(train=True, ulb=True)
data = ImagenetDataset(root=os.path.join(self.root_path, "train"), transform=transform, ulb=True)
return data
def get_lb_test_data(self):
transform = self.get_transform(train=False, ulb=False)
data = ImagenetDataset(root=os.path.join(self.root_path, "val"), transform=transform, ulb=False)
return data
class SSL_Dataset:
"""
SSL_Dataset class gets dataset from torchvision.datasets,
separates labeled and unlabeled data,
and return BasicDataset: torch.utils.data.Dataset (see datasets.dataset.py)
"""
def __init__(self,
args,
alg='fixmatch',
name='cifar10',
train=True,
num_classes=10,
data_dir='./data'):
"""
Args
alg: SSL algorithms
name: name of dataset in torchvision.datasets (cifar10, cifar100, svhn, stl10)
train: True means the dataset is training dataset (default=True)
num_classes: number of label classes
data_dir: path of directory, where data is downloaed or stored.
"""
self.args = args
self.alg = alg
self.name = name
self.train = train
self.num_classes = num_classes
self.data_dir = data_dir
crop_size = 96 if self.name.upper() == 'STL10' else 224 if self.name.upper() == 'IMAGENET' else 32
self.transform = get_transform(mean[name], std[name], crop_size, train)
def get_data(self, svhn_extra=True):
"""
get_data returns data (images) and targets (labels)
shape of data: B, H, W, C
shape of labels: B,
"""
dset = getattr(torchvision.datasets, self.name.upper())
if 'CIFAR' in self.name.upper():
dset = dset(self.data_dir, train=self.train, download=True)
data, targets = dset.data, dset.targets
return data, targets
elif self.name.upper() == 'SVHN':
if self.train:
if svhn_extra: # train+extra
dset_base = dset(self.data_dir, split='train', download=True)
data_b, targets_b = dset_base.data.transpose([0, 2, 3, 1]), dset_base.labels
dset_extra = dset(self.data_dir, split='extra', download=True)
data_e, targets_e = dset_extra.data.transpose([0, 2, 3, 1]), dset_extra.labels
data = np.concatenate([data_b, data_e])
targets = np.concatenate([targets_b, targets_e])
del data_b, data_e
del targets_b, targets_e
else: # train_only
dset = dset(self.data_dir, split='train', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
else: # test
dset = dset(self.data_dir, split='test', download=True)
data, targets = dset.data.transpose([0, 2, 3, 1]), dset.labels
return data, targets
elif self.name.upper() == 'STL10':
split = 'train' if self.train else 'test'
dset_lb = dset(self.data_dir, split=split, download=True)
dset_ulb = dset(self.data_dir, split='unlabeled', download=True)
data, targets = dset_lb.data.transpose([0, 2, 3, 1]), dset_lb.labels.astype(np.int64)
ulb_data = dset_ulb.data.transpose([0, 2, 3, 1])
return data, targets, ulb_data
def get_dset(self, is_ulb=False,
strong_transform=None, onehot=False):
"""
get_dset returns class BasicDataset, containing the returns of get_data.
Args
is_ulb: If True, returned dataset generates a pair of weak and strong augmented images.
strong_transform: list of strong_transform (augmentation) if use_strong_transform is True。
onehot: If True, the label is not integer, but one-hot vector.
"""
if self.name.upper() == 'STL10':
data, targets, _ = self.get_data()
else:
data, targets = self.get_data()
num_classes = self.num_classes
transform = self.transform
return BasicDataset(self.alg, data, targets, num_classes, transform,
is_ulb, strong_transform, onehot)
def get_ssl_dset(self, num_labels, index=None, include_lb_to_ulb=True,
strong_transform=None, onehot=False):
"""
get_ssl_dset split training samples into labeled and unlabeled samples.
The labeled data is balanced samples over classes.
Args:
num_labels: number of labeled data.
index: If index of np.array is given, labeled data is not randomly sampled, but use index for sampling.
include_lb_to_ulb: If True, consistency regularization is also computed for the labeled data.
strong_transform: list of strong transform (RandAugment in FixMatch)
onehot: If True, the target is converted into onehot vector.
Returns:
BasicDataset (for labeled data), BasicDataset (for unlabeld data)
"""
# Supervised top line using all data as labeled data.
if self.alg == 'fullysupervised':
lb_data, lb_targets = self.get_data()
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
return lb_dset, None
if self.name.upper() == 'STL10':
lb_data, lb_targets, ulb_data = self.get_data()
if include_lb_to_ulb:
ulb_data = np.concatenate([ulb_data, lb_data], axis=0)
lb_data, lb_targets, _ = sample_labeled_data(self.args, lb_data, lb_targets, num_labels, self.num_classes)
ulb_targets = None
else:
data, targets = self.get_data()
lb_data, lb_targets, ulb_data, ulb_targets = split_ssl_data(self.args, data, targets,
num_labels, self.num_classes,
index, include_lb_to_ulb)
# output the distribution of labeled data for remixmatch
count = [0 for _ in range(self.num_classes)]
for c in lb_targets:
count[c] += 1
dist = np.array(count, dtype=float)
dist = dist / dist.sum()
dist = dist.tolist()
out = {"distribution": dist}
output_file = r"./data_statistics/"
output_path = output_file + str(self.name) + '_' + str(num_labels) + '.json'
if not os.path.exists(output_file):
os.makedirs(output_file, exist_ok=True)
with open(output_path, 'w') as w:
json.dump(out, w)
# print(Counter(ulb_targets.tolist()))
lb_dset = BasicDataset(self.alg, lb_data, lb_targets, self.num_classes,
self.transform, False, None, onehot)
ulb_dset = BasicDataset(self.alg, ulb_data, ulb_targets, self.num_classes,
self.transform, True, strong_transform, onehot)
# print(lb_data.shape)
# print(ulb_data.shape)
return lb_dset, ulb_dset
def get_data_loader(dset,
batch_size=None,
shuffle=False,
num_workers=4,
pin_memory=False,
data_sampler=None,
replacement=True,
num_epochs=None,
num_iters=None,
generator=None,
drop_last=True,
distributed=False):
"""
get_data_loader returns torch.utils.data.DataLoader for a Dataset.
All arguments are comparable with those of pytorch DataLoader.
However, if distributed, DistributedProxySampler, which is a wrapper of data_sampler, is used.
Args
num_epochs: total batch -> (# of batches in dset) * num_epochs
num_iters: total batch -> num_iters
"""
assert batch_size is not None
if data_sampler is None:
return DataLoader(dset, batch_size=batch_size, shuffle=shuffle,
num_workers=num_workers, pin_memory=pin_memory)
else:
if isinstance(data_sampler, str):
data_sampler = get_sampler_by_name(data_sampler)
if distributed:
assert dist.is_available()
num_replicas = dist.get_world_size()
else:
num_replicas = 1
if (num_epochs is not None) and (num_iters is None):
num_samples = len(dset) * num_epochs
elif (num_epochs is None) and (num_iters is not None):
num_samples = batch_size * num_iters * num_replicas
else:
num_samples = len(dset)
if data_sampler.__name__ == 'RandomSampler':
data_sampler = data_sampler(dset, replacement, num_samples, generator)
else:
raise RuntimeError(f"{data_sampler.__name__} is not implemented.")
if distributed:
'''
Different with DistributedSampler,
the DistribuedProxySampler does not shuffle the data (just wrapper for dist).
'''
data_sampler = DistributedProxySampler(data_sampler)
batch_sampler = BatchSampler(data_sampler, batch_size, drop_last)
return DataLoader(dset, batch_sampler=batch_sampler,
num_workers=num_workers, pin_memory=pin_memory)
The provided code snippet includes necessary dependencies for implementing the `main_worker` function. Write a Python function `def main_worker(gpu, ngpus_per_node, args)` to solve the following problem:
main_worker is conducted on each GPU.
Here is the function:
def main_worker(gpu, ngpus_per_node, args):
'''
main_worker is conducted on each GPU.
'''
global best_acc1
args.gpu = gpu
# random seed has to be set for the syncronization of labeled data sampling in each process.
assert args.seed is not None
random.seed(args.seed)
torch.manual_seed(args.seed)
np.random.seed(args.seed)
cudnn.deterministic = True
# SET UP FOR DISTRIBUTED TRAINING
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
args.rank = args.rank * ngpus_per_node + gpu # compute global rank
# set distributed group:
dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
world_size=args.world_size, rank=args.rank)
# SET save_path and logger
save_path = os.path.join(args.save_dir, args.save_name)
logger_level = "WARNING"
tb_log = None
if args.rank % ngpus_per_node == 0:
tb_log = TBLog(save_path, 'tensorboard', use_tensorboard=args.use_tensorboard)
logger_level = "INFO"
logger = get_logger(args.save_name, save_path, logger_level)
logger.warning(f"USE GPU: {args.gpu} for training")
# SET FreeMatch: class FreeMatch in models.freematch
args.bn_momentum = 1.0 - 0.999
if 'imagenet' in args.dataset.lower():
_net_builder = net_builder('ResNet50', False, None, is_remix=False)
args.lr = 0.1
else:
_net_builder = net_builder(args.net,
args.net_from_name,
{'first_stride': 2 if 'stl' in args.dataset else 1,
'depth': args.depth,
'widen_factor': args.widen_factor,
'leaky_slope': args.leaky_slope,
'bn_momentum': args.bn_momentum,
'dropRate': args.dropout,
'use_embed': False,
'is_remix': False},
)
model = FreeMatch(_net_builder,
args.num_classes,
args.ema_m,
args.ulb_loss_ratio,
args.ent_loss_ratio,
args.hard_label,
num_eval_iter=args.num_eval_iter,
tb_log=tb_log,
logger=logger)
logger.info(f'Number of Trainable Params: {count_parameters(model.model)}')
# SET Optimizer & LR Scheduler
## construct SGD and cosine lr scheduler
optimizer = get_optimizer(model.model, args.optim, args.lr, args.momentum, args.weight_decay)
scheduler = get_cosine_schedule_with_warmup(optimizer,
args.num_train_iter,
num_warmup_steps=args.num_train_iter * 0)
## set SGD and cosine lr on FreeMatch
model.set_optimizer(optimizer, scheduler)
# SET Devices for (Distributed) DataParallel
if not torch.cuda.is_available():
raise Exception('ONLY GPU TRAINING IS SUPPORTED')
elif args.distributed:
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
'''
batch_size: batch_size per node -> batch_size per gpu
workers: workers per node -> workers per gpu
'''
args.batch_size = int(args.batch_size / ngpus_per_node)
model.model.cuda(args.gpu)
model.model = nn.SyncBatchNorm.convert_sync_batchnorm(model.model)
model.model = torch.nn.parallel.DistributedDataParallel(model.model,
device_ids=[args.gpu],
broadcast_buffers=False,
find_unused_parameters=True)
else:
# if arg.gpu is None, DDP will divide and allocate batch_size
# to all available GPUs if device_ids are not set.
model.cuda()
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.model = model.model.cuda(args.gpu)
else:
model.model = torch.nn.DataParallel(model.model).cuda()
import copy
model.ema_model = copy.deepcopy(model.model)
logger.info(f"model_arch: {model}")
logger.info(f"Arguments: {args}")
cudnn.benchmark = True
if args.rank != 0:
torch.distributed.barrier()
# Construct Dataset & DataLoader
if args.dataset != "imagenet":
if args.num_labels == 10 and args.dataset == 'cifar10':
fixmatch_index = [
[7408, 8148, 9850, 10361, 33949, 36506, 37018, 45044, 46443, 47447],
[5022, 8193, 8902, 9601, 25226, 26223, 34089, 35186, 40595, 48024],
[7510, 13186, 14043, 21305, 22805, 31288, 34508, 40470, 41493, 45506],
[9915, 9978, 16631, 19915, 28008, 35314, 35801, 36149, 39215, 42557],
[6695, 14891, 19726, 22715, 23999, 34230, 46511, 47457, 49181, 49397],
[12830, 20293, 26835, 30517, 30898, 31061, 43693, 46501, 47310, 48517],
[1156, 11501, 19974, 21963, 32103, 42189, 46789, 47690, 48229, 48675],
[4255, 6446, 8580, 11759, 12598, 29349, 29433, 33759, 35345, 38639]]
index = fixmatch_index[-args.seed - 1]
print("10 labels for cifar10")
else:
index = None
train_dset = SSL_Dataset(args, alg='freematch', name=args.dataset, train=True,
num_classes=args.num_classes, data_dir=args.data_dir)
lb_dset, ulb_dset = train_dset.get_ssl_dset(args.num_labels)
_eval_dset = SSL_Dataset(args, alg='freematch', name=args.dataset, train=False,
num_classes=args.num_classes, data_dir=args.data_dir)
eval_dset = _eval_dset.get_dset()
else:
image_loader = ImageNetLoader(root_path=args.data_dir, num_labels=args.num_labels,
num_class=args.num_classes)
lb_dset = image_loader.get_lb_train_data()
ulb_dset = image_loader.get_ulb_train_data()
eval_dset = image_loader.get_lb_test_data()
if args.rank == 0:
torch.distributed.barrier()
loader_dict = {}
dset_dict = {'train_lb': lb_dset, 'train_ulb': ulb_dset, 'eval': eval_dset}
loader_dict['train_lb'] = get_data_loader(dset_dict['train_lb'],
args.batch_size,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=args.num_workers,
distributed=args.distributed)
loader_dict['train_ulb'] = get_data_loader(dset_dict['train_ulb'],
args.batch_size * args.uratio,
data_sampler=args.train_sampler,
num_iters=args.num_train_iter,
num_workers=4 * args.num_workers,
distributed=args.distributed)
loader_dict['eval'] = get_data_loader(dset_dict['eval'],
args.eval_batch_size,
num_workers=args.num_workers,
drop_last=False)
## set DataLoader on FreeMatch
model.set_data_loader(loader_dict)
model.set_dset(ulb_dset)
# If args.resume, load checkpoints from args.load_path
if args.resume:
model.load_model(args.load_path)
if args.dataset == 'svhn':
print('warm up stage')
model.warmup(args, logger=logger)
# START TRAINING of FreeMatch
trainer = model.train
for epoch in range(args.epoch):
trainer(args, logger=logger)
if not args.multiprocessing_distributed or \
(args.multiprocessing_distributed and args.rank % ngpus_per_node == 0):
model.save_model('latest_model.pth', save_path)
logging.warning(f"GPU {args.rank} training is FINISHED") | main_worker is conducted on each GPU. |
157,499 | import os
import logging
import random
import warnings
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.multiprocessing as mp
from utils import net_builder, get_logger, count_parameters, over_write_args_from_file
from train_utils import TBLog, get_optimizer, get_cosine_schedule_with_warmup
from models.freematch.freematch import FreeMatch
from datasets.ssl_dataset import SSL_Dataset, ImageNetLoader
from datasets.data_utils import get_data_loader
def str2bool(v):
if isinstance(v, bool):
return v
if v.lower() in ('yes', 'true', 't', 'y', '1'):
return True
elif v.lower() in ('no', 'false', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError('Boolean value expected.') | null |
157,500 | import torch
import torch.nn as nn
from torch.utils.tensorboard import SummaryWriter
from torch.optim.lr_scheduler import LambdaLR
import torch.nn.functional as F
import math
import time
import os
from copy import deepcopy
from torch.optim.optimizer import Optimizer, required
import copy
from custom_writer import CustomWriter
def wd_loss(net):
loss = 0
for name, param in net.named_parameters():
if ('bn' in name or 'bias' in name):
continue
elif ('weight' in name):
loss = loss + torch.sum(param ** 2) / 2
return loss | null |
157,501 | import torch
import torch.nn as nn
from torch.utils.tensorboard import SummaryWriter
from torch.optim.lr_scheduler import LambdaLR
import torch.nn.functional as F
import math
import time
import os
from copy import deepcopy
from torch.optim.optimizer import Optimizer, required
import copy
from custom_writer import CustomWriter
def get_imagenet_schedule(optimizer, num_training_steps, num_labels, batch_size):
def iter2epoch(iter):
iter_per_ep = num_labels // batch_size
ep = iter // iter_per_ep
return ep
def epoch2iter(epoch):
iter_per_ep = num_labels // batch_size
iter = epoch * iter_per_ep
return iter
def _lr_lambda(iter):
return None | null |
157,502 | import torch
import torch.nn as nn
from torch.utils.tensorboard import SummaryWriter
from torch.optim.lr_scheduler import LambdaLR
import torch.nn.functional as F
import math
import time
import os
from copy import deepcopy
from torch.optim.optimizer import Optimizer, required
import copy
from custom_writer import CustomWriter
The provided code snippet includes necessary dependencies for implementing the `accuracy` function. Write a Python function `def accuracy(output, target, topk=(1,))` to solve the following problem:
Computes the accuracy over the k top predictions for the specified values of k Args output: logits or probs (num of batch, num of classes) target: (num of batch, 1) or (num of batch, ) topk: list of returned k refer: https://github.com/pytorch/examples/blob/master/imagenet/main.py
Here is the function:
def accuracy(output, target, topk=(1,)):
"""
Computes the accuracy over the k top predictions for the specified values of k
Args
output: logits or probs (num of batch, num of classes)
target: (num of batch, 1) or (num of batch, )
topk: list of returned k
refer: https://github.com/pytorch/examples/blob/master/imagenet/main.py
"""
with torch.no_grad():
maxk = max(topk) # get k in top-k
batch_size = target.size(0) # get batch size of target
# torch.topk(input, k, dim=None, largest=True, sorted=True, out=None)
# return: value, index
_, pred = output.topk(k=maxk, dim=1, largest=True, sorted=True) # pred: [num of batch, k]
pred = pred.t() # pred: [k, num of batch]
# [1, num of batch] -> [k, num_of_batch] : bool
correct = pred.eq(target.view(1, -1).expand_as(pred))
res = []
for k in topk:
correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)
res.append(correct_k.mul_(100.0 / batch_size))
# np.shape(res): [k, 1]
return res | Computes the accuracy over the k top predictions for the specified values of k Args output: logits or probs (num of batch, num of classes) target: (num of batch, 1) or (num of batch, ) topk: list of returned k refer: https://github.com/pytorch/examples/blob/master/imagenet/main.py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.