Datasets:

---

bigcode

/

jupyter-parsed

like 4

Follow

BigCode 1.35k

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "#default_exp core", "_____no_output_____" ], [ "#export\nfrom local.test import *\nfrom local.imports import *\nfrom local.notebook.showdoc import show_doc", "_____no_output_____" ], [ "#export\ntorch.cuda.set_device(int(os.environ.get('DEFAULT_GPU') or 0))", "_____no_output_____" ] ], [ [ "# Core\n\n> Basic functions used in the fastai library", "_____no_output_____" ] ], [ [ "# export\ndefaults = SimpleNamespace()", "_____no_output_____" ] ], [ [ "## Metaclasses", "_____no_output_____" ] ], [ [ "#export\nclass PrePostInitMeta(type):\n \"A metaclass that calls optional `__pre_init__` and `__post_init__` methods\"\n def __new__(cls, name, bases, dct):\n x = super().__new__(cls, name, bases, dct)\n def _pass(self, *args,**kwargs): pass\n for o in ('__init__', '__pre_init__', '__post_init__'):\n if not hasattr(x,o): setattr(x,o,_pass)\n old_init = x.__init__\n \n @functools.wraps(old_init)\n def _init(self,*args,**kwargs):\n self.__pre_init__()\n old_init(self, *args,**kwargs)\n self.__post_init__()\n setattr(x, '__init__', _init)\n return x", "_____no_output_____" ], [ "show_doc(PrePostInitMeta, title_level=3)", "_____no_output_____" ], [ "class _T(metaclass=PrePostInitMeta):\n def __pre_init__(self): self.a = 0; assert self.a==0\n def __init__(self): self.a += 1; assert self.a==1\n def __post_init__(self): self.a += 1; assert self.a==2\n\nt = _T()\nt.a", "_____no_output_____" ], [ "#export\nclass BaseObj(metaclass=PrePostInitMeta):\n \"Base class that provides `PrePostInitMeta` metaclass to subclasses\"\n pass", "_____no_output_____" ], [ "class _T(BaseObj):\n def __pre_init__(self): self.a = 0; assert self.a==0\n def __init__(self): self.a += 1; assert self.a==1\n def __post_init__(self): self.a += 1; assert self.a==2\n\nt = _T()\nt.a", "_____no_output_____" ], [ "#export\nclass NewChkMeta(PrePostInitMeta):\n \"Metaclass to avoid recreating object passed to constructor (plus all `PrePostInitMeta` functionality)\"\n def __new__(cls, name, bases, dct):\n x = super().__new__(cls, name, bases, dct)\n old_init,old_new = x.__init__,x.__new__\n\n @functools.wraps(old_init)\n def _new(cls, x=None, *args, **kwargs):\n if x is not None and isinstance(x,cls):\n x._newchk = 1\n return x\n res = old_new(cls)\n res._newchk = 0\n return res\n\n @functools.wraps(old_init)\n def _init(self,*args,**kwargs):\n if self._newchk: return\n old_init(self, *args, **kwargs)\n\n x.__init__,x.__new__ = _init,_new\n return x", "_____no_output_____" ], [ "class _T(metaclass=NewChkMeta):\n \"Testing\"\n def __init__(self, o=None): self.foo = getattr(o,'foo',0) + 1\n\nclass _T2():\n def __init__(self, o): self.foo = getattr(o,'foo',0) + 1\n\nt = _T(1)\ntest_eq(t.foo,1)\nt2 = _T(t)\ntest_eq(t2.foo,1)\ntest_is(t,t2)\n\nt = _T2(1)\ntest_eq(t.foo,1)\nt2 = _T2(t)\ntest_eq(t2.foo,2)\n\ntest_eq(_T.__doc__, \"Testing\")\ntest_eq(str(inspect.signature(_T)), '(o=None)')", "_____no_output_____" ], [ "#export\nclass BypassNewMeta(type):\n \"Metaclass: casts `x` to this class, initializing with `_new_meta` if available\"\n def __call__(cls, x, *args, **kwargs):\n if hasattr(cls, '_new_meta'): x = cls._new_meta(x, *args, **kwargs)\n if cls!=x.__class__: x.__class__ = cls\n return x", "_____no_output_____" ], [ "class T0: pass\nclass _T(T0, metaclass=BypassNewMeta): pass\n\nt = T0()\nt.a = 1\nt2 = _T(t)\ntest_eq(type(t2), _T)\ntest_eq(t2.a,1)", "_____no_output_____" ] ], [ [ "## Foundational functions", "_____no_output_____" ], [ "### Decorators", "_____no_output_____" ] ], [ [ "#export\ndef patch_to(cls, as_prop=False):\n \"Decorator: add `f` to `cls`\"\n def _inner(f):\n nf = copy(f)\n # `functools.update_wrapper` when passing patched function to `Pipeline`, so we do it manually\n for o in functools.WRAPPER_ASSIGNMENTS: setattr(nf, o, getattr(f,o))\n nf.__qualname__ = f\"{cls.__name__}.{f.__name__}\"\n setattr(cls, f.__name__, property(nf) if as_prop else nf)\n return f\n return _inner", "_____no_output_____" ], [ "class _T3(int): pass\n\n@patch_to(_T3)\ndef func1(x, a:bool): return x+2\n\nt = _T3(1)\ntest_eq(t.func1(1), 3)", "_____no_output_____" ], [ "#export\ndef patch(f):\n \"Decorator: add `f` to the first parameter's class (based on f's type annotations)\"\n cls = next(iter(f.__annotations__.values()))\n return patch_to(cls)(f)", "_____no_output_____" ], [ "@patch\ndef func(x:_T3, a:bool):\n \"test\"\n return x+2\n\nt = _T3(1)\ntest_eq(t.func(1), 3)\ntest_eq(t.func.__qualname__, '_T3.func')", "_____no_output_____" ], [ "#export\ndef patch_property(f):\n \"Decorator: add `f` as a property to the first parameter's class (based on f's type annotations)\"\n cls = next(iter(f.__annotations__.values()))\n return patch_to(cls, as_prop=True)(f)", "_____no_output_____" ], [ "@patch_property\ndef prop(x:_T3): return x+1\n\nt = _T3(1)\ntest_eq(t.prop, 2)", "_____no_output_____" ], [ "#export\ndef _mk_param(n,d=None): return inspect.Parameter(n, inspect.Parameter.KEYWORD_ONLY, default=d)", "_____no_output_____" ], [ "def test_sig(f, b): test_eq(str(inspect.signature(f)), b)", "_____no_output_____" ], [ "#export\ndef use_kwargs(names, keep=False):\n \"Decorator: replace `**kwargs` in signature with `names` params\"\n def _f(f):\n sig = inspect.signature(f)\n sigd = dict(sig.parameters)\n k = sigd.pop('kwargs')\n s2 = {n:_mk_param(n) for n in names if n not in sigd}\n sigd.update(s2)\n if keep: sigd['kwargs'] = k\n f.__signature__ = sig.replace(parameters=sigd.values())\n return f\n return _f", "_____no_output_____" ], [ "@use_kwargs(['y', 'z'])\ndef foo(a, b=1, **kwargs): pass\ntest_sig(foo, '(a, b=1, *, y=None, z=None)')\n\n@use_kwargs(['y', 'z'], keep=True)\ndef foo(a, *args, b=1, **kwargs): pass\ntest_sig(foo, '(a, *args, b=1, y=None, z=None, **kwargs)')", "_____no_output_____" ], [ "#export\ndef delegates(to=None, keep=False):\n \"Decorator: replace `**kwargs` in signature with params from `to`\"\n def _f(f):\n if to is None: to_f,from_f = f.__base__.__init__,f.__init__\n else: to_f,from_f = to,f\n sig = inspect.signature(from_f)\n sigd = dict(sig.parameters)\n k = sigd.pop('kwargs')\n s2 = {k:v for k,v in inspect.signature(to_f).parameters.items()\n if v.default != inspect.Parameter.empty and k not in sigd}\n sigd.update(s2)\n if keep: sigd['kwargs'] = k\n from_f.__signature__ = sig.replace(parameters=sigd.values())\n return f\n return _f", "_____no_output_____" ], [ "def basefoo(e, c=2): pass\n\n@delegates(basefoo)\ndef foo(a, b=1, **kwargs): pass\ntest_sig(foo, '(a, b=1, c=2)')\n\n@delegates(basefoo, keep=True)\ndef foo(a, b=1, **kwargs): pass\ntest_sig(foo, '(a, b=1, c=2, **kwargs)')", "_____no_output_____" ], [ "class BaseFoo:\n def __init__(self, e, c=2): pass\n\n@delegates()\nclass Foo(BaseFoo):\n def __init__(self, a, b=1, **kwargs): super().__init__(**kwargs)\n\ntest_sig(Foo, '(a, b=1, c=2)')", "_____no_output_____" ], [ "#export\ndef funcs_kwargs(cls):\n \"Replace methods in `self._methods` with those from `kwargs`\"\n old_init = cls.__init__\n def _init(self, *args, **kwargs):\n for k in cls._methods:\n arg = kwargs.pop(k,None)\n if arg is not None:\n if isinstance(arg,types.MethodType): arg = types.MethodType(arg.__func__, self)\n setattr(self, k, arg)\n old_init(self, *args, **kwargs)\n functools.update_wrapper(_init, old_init)\n cls.__init__ = use_kwargs(cls._methods)(_init)\n return cls", "_____no_output_____" ], [ "#export\ndef method(f):\n \"Mark `f` as a method\"\n # `1` is a dummy instance since Py3 doesn't allow `None` any more\n return types.MethodType(f, 1)", "_____no_output_____" ], [ "@funcs_kwargs\nclass T:\n _methods=['b']\n def __init__(self, f=1, **kwargs): assert not kwargs\n def a(self): return 1\n def b(self): return 2\n \nt = T()\ntest_eq(t.a(), 1)\ntest_eq(t.b(), 2)\nt = T(b = lambda:3)\ntest_eq(t.b(), 3)\ntest_sig(T, '(f=1, *, b=None)')\ntest_fail(lambda: T(a = lambda:3))\n\n@method\ndef _f(self,a=1): return a+1\nt = T(b = _f)\ntest_eq(t.b(2), 3)\n\nclass T2(T):\n def __init__(self,a):\n super().__init__(b = lambda:3)\n self.a=a\nt = T2(a=1)\ntest_eq(t.b(), 3)\ntest_sig(T2, '(a)')\n\ndef _g(a=1): return a+1\nclass T3(T): b = staticmethod(_g)\nt = T3()\ntest_eq(t.b(2), 3)", "_____no_output_____" ] ], [ [ "### Type checking", "_____no_output_____" ], [ "Runtime type checking is handy, so let's make it easy!", "_____no_output_____" ] ], [ [ "#export core\n#NB: Please don't move this to a different line or module, since it's used in testing `get_source_link`\ndef chk(f): return typechecked(always=True)(f)", "_____no_output_____" ] ], [ [ "Decorator for a function to check that type-annotated arguments receive arguments of the right type.", "_____no_output_____" ] ], [ [ "@chk\ndef test_chk(a:int=1): return a\n\ntest_eq(test_chk(2), 2)\ntest_eq(test_chk(), 1)\ntest_fail(lambda: test_chk('a'), contains='\"a\" must be int')", "_____no_output_____" ] ], [ [ "Decorated functions will pickle correctly.", "_____no_output_____" ] ], [ [ "t = pickle.loads(pickle.dumps(test_chk))\ntest_eq(t(2), 2)\ntest_eq(t(), 1)", "_____no_output_____" ] ], [ [ "### Context managers", "_____no_output_____" ] ], [ [ "@contextmanager\ndef working_directory(path):\n \"Change working directory to `path` and return to previous on exit.\"\n prev_cwd = Path.cwd()\n os.chdir(path)\n try: yield\n finally: os.chdir(prev_cwd)", "_____no_output_____" ] ], [ [ "### Monkey-patching", "_____no_output_____" ] ], [ [ "def is_listy(x): return isinstance(x,(list,tuple,Generator))", "_____no_output_____" ], [ "#export\ndef tensor(x, *rest, **kwargs):\n \"Like `torch.as_tensor`, but handle lists too, and can pass multiple vector elements directly.\"\n if len(rest): x = (x,)+rest\n # Pytorch bug in dataloader using num_workers>0\n if isinstance(x, (tuple,list)) and len(x)==0: return tensor(0)\n res = (torch.tensor(x, **kwargs) if isinstance(x, (tuple,list))\n else as_tensor(x, **kwargs) if hasattr(x, '__array__')\n else as_tensor(x, **kwargs) if is_listy(x)\n else as_tensor(x, **kwargs) if is_iter(x)\n else None)\n if res is None:\n res = as_tensor(array(x), **kwargs)\n if res.dtype is torch.float64: return res.float()\n if res.dtype is torch.int32:\n warn('Tensor is int32: upgrading to int64; for better performance use int64 input')\n return res.long()\n return res", "_____no_output_____" ], [ "test_eq(tensor(array([1,2,3])), torch.tensor([1,2,3]))\ntest_eq(tensor(1,2,3), torch.tensor([1,2,3]))\ntest_eq_type(tensor(1.0), torch.tensor(1.0))", "_____no_output_____" ] ], [ [ "#### `Tensor.ndim`", "_____no_output_____" ], [ "We add an `ndim` property to `Tensor` with same semantics as [numpy ndim](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.ndim.html), which allows tensors to be used in matplotlib and other places that assume this property exists.", "_____no_output_____" ] ], [ [ "test_eq(torch.tensor([1,2]).ndim,1)\ntest_eq(torch.tensor(1).ndim,0)\ntest_eq(torch.tensor([[1]]).ndim,2)", "_____no_output_____" ] ], [ [ "### Documentation functions", "_____no_output_____" ] ], [ [ "#export core\ndef add_docs(cls, cls_doc=None, **docs):\n \"Copy values from `docs` to `cls` docstrings, and confirm all public methods are documented\"\n if cls_doc is not None: cls.__doc__ = cls_doc\n for k,v in docs.items():\n f = getattr(cls,k)\n if hasattr(f,'__func__'): f = f.__func__ # required for class methods\n f.__doc__ = v\n # List of public callables without docstring\n nodoc = [c for n,c in vars(cls).items() if isinstance(c,Callable)\n and not n.startswith('_') and c.__doc__ is None]\n assert not nodoc, f\"Missing docs: {nodoc}\"\n assert cls.__doc__ is not None, f\"Missing class docs: {cls}\"", "_____no_output_____" ], [ "#export core\ndef docs(cls):\n \"Decorator version of `add_docs`, using `_docs` dict\"\n add_docs(cls, **cls._docs)\n return cls", "_____no_output_____" ], [ "class _T:\n def f(self): pass\n @classmethod\n def g(cls): pass\nadd_docs(_T, \"a\", f=\"f\", g=\"g\")\n\ntest_eq(_T.__doc__, \"a\")\ntest_eq(_T.f.__doc__, \"f\")\ntest_eq(_T.g.__doc__, \"g\")", "_____no_output_____" ], [ "#export\ndef custom_dir(c, add:List):\n \"Implement custom `__dir__`, adding `add` to `cls`\"\n return dir(type(c)) + list(c.__dict__.keys()) + add", "_____no_output_____" ], [ "show_doc(is_iter)", "_____no_output_____" ], [ "assert is_iter([1])\nassert not is_iter(torch.tensor(1))\nassert is_iter(torch.tensor([1,2]))\nassert (o for o in range(3))", "_____no_output_____" ] ], [ [ "## GetAttr -", "_____no_output_____" ] ], [ [ "#export\nclass GetAttr(BaseObj):\n \"Inherit from this to have all attr accesses in `self._xtra` passed down to `self.default`\"\n @property\n def _xtra(self): return [o for o in dir(self.default) if not o.startswith('_')]\n def __getattr__(self,k):\n if k in self._xtra: return getattr(self.default, k)\n raise AttributeError(k)\n def __dir__(self): return custom_dir(self, self._xtra)", "_____no_output_____" ], [ "class _C(GetAttr): default,_xtra = 'Hi',['lower']\n\nt = _C()\ntest_eq(t.lower(), 'hi')\ntest_fail(lambda: t.upper())\nassert 'lower' in dir(t)", "_____no_output_____" ], [ "#export\ndef delegate_attr(self, k, to):\n \"Use in `__getattr__` to delegate to attr `to` without inheriting from `GetAttr`\"\n if k.startswith('_') or k==to: raise AttributeError(k)\n try: return getattr(getattr(self,to), k)\n except AttributeError: raise AttributeError(k) from None", "_____no_output_____" ], [ "class _C:\n f = 'Hi'\n def __getattr__(self, k): return delegate_attr(self, k, 'f')\n\nt = _C()\ntest_eq(t.lower(), 'hi')", "_____no_output_____" ] ], [ [ "## L -", "_____no_output_____" ] ], [ [ "# export\ndef coll_repr(c, max_n=10):\n \"String repr of up to `max_n` items of (possibly lazy) collection `c`\"\n return f'(#{len(c)}) [' + ','.join(itertools.islice(map(str,c), max_n)) + ('...'\n if len(c)>10 else '') + ']'", "_____no_output_____" ], [ "test_eq(coll_repr(range(1000), 5), '(#1000) [0,1,2,3,4...]')", "_____no_output_____" ], [ "# export\ndef mask2idxs(mask):\n \"Convert bool mask or index list to index `L`\"\n mask = list(mask)\n if len(mask)==0: return []\n if isinstance(mask[0],bool): return [i for i,m in enumerate(mask) if m]\n return [int(i) for i in mask]", "_____no_output_____" ], [ "test_eq(mask2idxs([False,True,False,True]), [1,3])\ntest_eq(mask2idxs(torch.tensor([1,2,3])), [1,2,3])", "_____no_output_____" ], [ "# export\ndef _listify(o):\n if o is None: return []\n if isinstance(o, list): return o\n if isinstance(o, (str,np.ndarray,Tensor)): return [o]\n if is_iter(o): return list(o)\n return [o]", "_____no_output_____" ], [ "#export\nclass CollBase(GetAttr, metaclass=NewChkMeta):\n \"Base class for composing a list of `items`\"\n _xtra = [o for o in dir([]) if not o.startswith('_')]\n\n def __init__(self, items): self.items = items\n def __len__(self): return len(self.items)\n def __getitem__(self, k): return self.items[k]\n def __setitem__(self, k, v): self.items[k] = v\n def __delitem__(self, i): del(self.items[i])\n def __repr__(self): return self.items.__repr__()\n def __iter__(self): return self.items.__iter__()\n def _new(self, items, *args, **kwargs): return self.__class__(items, *args, **kwargs)\n @property\n def default(self): return self.items", "_____no_output_____" ], [ "#export\nclass L(CollBase):\n \"Behaves like a list of `items` but can also index with list of indices or masks\"\n def __init__(self, items=None, *rest, use_list=False, match=None):\n if rest: items = (items,)+rest\n if items is None: items = []\n if (use_list is not None) or not isinstance(items,(Tensor,ndarray,pd.DataFrame,pd.Series)):\n items = list(items) if use_list else _listify(items)\n if match is not None:\n if len(items)==1: items = items*len(match)\n else: assert len(items)==len(match), 'Match length mismatch'\n super().__init__(items)\n \n def __getitem__(self, idx): return L(self._gets(idx), use_list=None) if is_iter(idx) else self._get(idx)\n def _get(self, i): return getattr(self.items,'iloc',self.items)[i]\n def _gets(self, i):\n i = mask2idxs(i)\n return (self.items.iloc[list(i)] if hasattr(self.items,'iloc')\n else self.items.__array__()[(i,)] if hasattr(self.items,'__array__')\n else [self.items[i_] for i_ in i])\n \n def __setitem__(self, idx, o):\n \"Set `idx` (can be list of indices, or mask, or int) items to `o` (which is broadcast if not iterable)\"\n idx = idx if isinstance(idx,L) else _listify(idx) \n if not is_iter(o): o = [o]*len(idx)\n for i,o_ in zip(idx,o): self.items[i] = o_\n \n def __repr__(self): return coll_repr(self)\n def __eq__(self,b): return all_equal(b,self)\n def __iter__(self): return (self[i] for i in range(len(self)))\n \n def __invert__(self): return self._new(not i for i in self)\n def __mul__ (a,b): return a._new(a.items*b)\n def __add__ (a,b): return a._new(a.items+_listify(b))\n def __radd__(a,b): return a._new(b)+a\n def __addi__(a,b):\n a.items += list(b)\n return a\n\n def sorted(self, key=None, reverse=False):\n \"New `L` sorted by `key`. If key is str then use `attrgetter`. If key is int then use `itemgetter`.\"\n if isinstance(key,str): k=lambda o:getattr(o,key,0)\n elif isinstance(key,int): k=itemgetter(key)\n else: k=key\n return self._new(sorted(self.items, key=k, reverse=reverse))\n \n @classmethod\n def range(cls, a, b=None, step=None):\n \"Same as builtin `range`, but returns an `L`. Can pass a collection for `a`, to use `len(a)`\"\n if is_coll(a): a = len(a)\n return cls(range(a,b,step) if step is not None else range(a,b) if b is not None else range(a))\n \n def itemgot(self, idx): return self.mapped(itemgetter(idx))\n def attrgot(self, k, default=None): return self.mapped(lambda o:getattr(o,k,default))\n def tensored(self): return self.mapped(tensor)\n def stack(self, dim=0): return torch.stack(list(self.tensored()), dim=dim)\n def cat (self, dim=0): return torch.cat (list(self.tensored()), dim=dim)\n def cycle(self): return itertools.cycle(self) if len(self) > 0 else itertools.cycle([None])\n def filtered(self, f, *args, **kwargs): return self._new(filter(partial(f,*args,**kwargs), self))\n def mapped(self, f, *args, **kwargs): return self._new(map(partial(f,*args,**kwargs), self))\n def mapped_dict(self, f, *args, **kwargs): return {k:f(k, *args,**kwargs) for k in self}\n def starmapped(self, f, *args, **kwargs): return self._new(itertools.starmap(partial(f,*args,**kwargs), self))\n def zipped(self, longest=False): return self._new((zip_longest if longest else zip)(*self))\n def zipwith(self, *rest, longest=False): return self._new([self, *rest]).zipped(longest=longest)\n def mapped_zip(self, f, longest=False): return self.zipped(longest=longest).starmapped(f)\n def mapped_zipwith(self, f, *rest, longest=False): return self.zipwith(*rest, longest=longest).starmapped(f)\n def shuffled(self):\n it = copy(self.items)\n random.shuffle(it)\n return self._new(it)", "_____no_output_____" ], [ "#export\nadd_docs(L,\n __getitem__=\"Retrieve `idx` (can be list of indices, or mask, or int) items\",\n filtered=\"Create new `L` filtered by predicate `f`, passing `args` and `kwargs` to `f`\",\n mapped=\"Create new `L` with `f` applied to all `items`, passing `args` and `kwargs` to `f`\",\n mapped_dict=\"Like `mapped`, but creates a dict from `items` to function results\",\n starmapped=\"Like `mapped`, but use `itertools.starmap`\",\n itemgot=\"Create new `L` with item `idx` of all `items`\",\n attrgot=\"Create new `L` with attr `k` of all `items`\",\n tensored=\"`mapped(tensor)`\",\n cycle=\"Same as `itertools.cycle`\",\n stack=\"Same as `torch.stack`\",\n cat=\"Same as `torch.cat`\",\n zipped=\"Create new `L` with `zip(*items)`\",\n zipwith=\"Create new `L` with `self` zipped with each of `*rest`\",\n mapped_zip=\"Combine `zipped` and `starmapped`\",\n mapped_zipwith=\"Combine `zipwith` and `starmapped`\",\n shuffled=\"Same as `random.shuffle`, but not inplace\")", "_____no_output_____" ] ], [ [ "You can create an `L` from an existing iterable (e.g. a list, range, etc) and access or modify it with an int list/tuple index, mask, int, or slice. All `list` methods can also be used with `L`.", "_____no_output_____" ] ], [ [ "t = L(range(12))\ntest_eq(t, list(range(12)))\ntest_ne(t, list(range(11)))\nt.reverse()\ntest_eq(t[0], 11)\nt[3] = \"h\"\ntest_eq(t[3], \"h\")\nt[3,5] = (\"j\",\"k\")\ntest_eq(t[3,5], [\"j\",\"k\"])\ntest_eq(t, L(t))\nt", "_____no_output_____" ] ], [ [ "There are optimized indexers for arrays, tensors, and DataFrames.", "_____no_output_____" ] ], [ [ "arr = np.arange(9).reshape(3,3)\nt = L(arr, use_list=None)\ntest_eq(t[1,2], arr[[1,2]])\n\narr = torch.arange(9).view(3,3)\nt = L(arr, use_list=None)\ntest_eq(t[1,2], arr[[1,2]])\n\ndf = pd.DataFrame({'a':[1,2,3]})\nt = L(df, use_list=None)\ntest_eq(t[1,2], L(pd.DataFrame({'a':[2,3]}), use_list=None))", "_____no_output_____" ] ], [ [ "You can also modify an `L` with `append`, `+`, and `*`.", "_____no_output_____" ] ], [ [ "t = L()\ntest_eq(t, [])\nt.append(1)\ntest_eq(t, [1])\nt += [3,2]\ntest_eq(t, [1,3,2])\nt = t + [4]\ntest_eq(t, [1,3,2,4])\nt = 5 + t\ntest_eq(t, [5,1,3,2,4])\ntest_eq(L(1,2,3), [1,2,3])\ntest_eq(L(1,2,3), L(1,2,3))\nt = L(1)*5\nt = t.mapped(operator.neg)\ntest_eq(t,[-1]*5)\ntest_eq(~L([True,False,False]), L([False,True,True]))\nt = L(range(4))\ntest_eq(zip(t, L(1).cycle()), zip(range(4),(1,1,1,1)))\nt = L.range(100)\nt2 = t.shuffled()\ntest_ne(t,t2)\ntest_eq(L.range(100), t)\ntest_eq(set(t),set(t2))", "_____no_output_____" ], [ "def _f(x,a=0): return x+a\nt = L(1)*5\ntest_eq(t.mapped(_f), t)\ntest_eq(t.mapped(_f,1), [2]*5)\ntest_eq(t.mapped(_f,a=2), [3]*5)", "_____no_output_____" ] ], [ [ "An `L` can be constructed from anything iterable, although tensors and arrays will not be iterated over on construction, unless you pass `use_list` to the constructor.", "_____no_output_____" ] ], [ [ "test_eq(L([1,2,3]),[1,2,3])\ntest_eq(L(L([1,2,3])),[1,2,3])\ntest_ne(L([1,2,3]),[1,2,])\ntest_eq(L('abc'),['abc'])\ntest_eq(L(range(0,3)),[0,1,2])\ntest_eq(L(o for o in range(0,3)),[0,1,2])\ntest_eq(L(tensor(0)),[tensor(0)])\ntest_eq(L([tensor(0),tensor(1)]),[tensor(0),tensor(1)])\ntest_eq(L(tensor([0.,1.1]))[0],tensor([0.,1.1]))\ntest_eq(L(tensor([0.,1.1]), use_list=True), [0.,1.1]) # `use_list=True` to unwrap arrays/tensors", "_____no_output_____" ] ], [ [ "If `match` is not `None` then the created list is same len as `match`, either by:\n\n- If `len(items)==1` then `items` is replicated,\n- Otherwise an error is raised if `match` and `items` are not already the same size.", "_____no_output_____" ] ], [ [ "test_eq(L(1,match=[1,2,3]),[1,1,1])\ntest_eq(L([1,2],match=[2,3]),[1,2])\ntest_fail(lambda: L([1,2],match=[1,2,3]))", "_____no_output_____" ] ], [ [ "If you create an `L` from an existing `L` then you'll get back the original object (since `L` uses the `NewChkMeta` metaclass).", "_____no_output_____" ] ], [ [ "test_is(L(t), t)", "_____no_output_____" ] ], [ [ "### Methods", "_____no_output_____" ] ], [ [ "show_doc(L.__getitem__)", "_____no_output_____" ], [ "t = L(range(12))\ntest_eq(t[1,2], [1,2]) # implicit tuple\ntest_eq(t[[1,2]], [1,2]) # list\ntest_eq(t[:3], [0,1,2]) # slice\ntest_eq(t[[False]*11 + [True]], [11]) # mask\ntest_eq(t[tensor(3)], 3)", "_____no_output_____" ], [ "show_doc(L.__setitem__)", "_____no_output_____" ], [ "t[4,6] = 0\ntest_eq(t[4,6], [0,0])\nt[4,6] = [1,2]\ntest_eq(t[4,6], [1,2])", "_____no_output_____" ], [ "show_doc(L.filtered)", "_____no_output_____" ], [ "test_eq(t.filtered(lambda o:o<5), [0,1,2,3,1,2])", "_____no_output_____" ], [ "show_doc(L.mapped)", "_____no_output_____" ], [ "test_eq(L(range(4)).mapped(operator.neg), [0,-1,-2,-3])", "_____no_output_____" ], [ "show_doc(L.mapped_dict)", "_____no_output_____" ], [ "test_eq(L(range(1,5)).mapped_dict(operator.neg), {1:-1, 2:-2, 3:-3, 4:-4})", "_____no_output_____" ], [ "show_doc(L.zipped)", "_____no_output_____" ], [ "t = L([[1,2,3],'abc'])\ntest_eq(t.zipped(), [(1, 'a'),(2, 'b'),(3, 'c')])", "_____no_output_____" ], [ "t = L([[1,2],'abc'])\ntest_eq(t.zipped(longest=True ), [(1, 'a'),(2, 'b'),(None, 'c')])\ntest_eq(t.zipped(longest=False), [(1, 'a'),(2, 'b')])", "_____no_output_____" ], [ "show_doc(L.mapped_zip)", "_____no_output_____" ], [ "t = L([1,2,3],[2,3,4])\ntest_eq(t.mapped_zip(operator.mul), [2,6,12])", "_____no_output_____" ], [ "show_doc(L.zipwith)", "_____no_output_____" ], [ "b = [[0],[1],[2,2]]\nt = L([1,2,3]).zipwith(b)\ntest_eq(t, [(1,[0]), (2,[1]), (3,[2,2])])", "_____no_output_____" ], [ "show_doc(L.mapped_zipwith)", "_____no_output_____" ], [ "test_eq(L(1,2,3).mapped_zipwith(operator.mul, [2,3,4]), [2,6,12])", "_____no_output_____" ], [ "show_doc(L.itemgot)", "_____no_output_____" ], [ "test_eq(t.itemgot(1), b)", "_____no_output_____" ], [ "show_doc(L.attrgot)", "_____no_output_____" ], [ "a = [SimpleNamespace(a=3,b=4),SimpleNamespace(a=1,b=2)]\ntest_eq(L(a).attrgot('b'), [4,2])", "_____no_output_____" ], [ "show_doc(L.sorted)", "_____no_output_____" ], [ "test_eq(L(a).sorted('a').attrgot('b'), [2,4])", "_____no_output_____" ], [ "show_doc(L.range)", "_____no_output_____" ], [ "test_eq_type(L.range([1,1,1]), L(range(3)))\ntest_eq_type(L.range(5,2,2), L(range(5,2,2)))", "_____no_output_____" ], [ "show_doc(L.tensored)", "_____no_output_____" ] ], [ [ "There are shortcuts for `torch.stack` and `torch.cat` if your `L` contains tensors or something convertible. You can manually convert with `tensored`.", "_____no_output_____" ] ], [ [ "t = L(([1,2],[3,4]))\ntest_eq(t.tensored(), [tensor(1,2),tensor(3,4)])", "_____no_output_____" ], [ "show_doc(L.stack)", "_____no_output_____" ], [ "test_eq(t.stack(), tensor([[1,2],[3,4]]))", "_____no_output_____" ], [ "show_doc(L.cat)", "_____no_output_____" ], [ "test_eq(t.cat(), tensor([1,2,3,4]))", "_____no_output_____" ] ], [ [ "## Utility functions", "_____no_output_____" ], [ "### Basics", "_____no_output_____" ] ], [ [ "# export\ndef ifnone(a, b):\n \"`b` if `a` is None else `a`\"\n return b if a is None else a", "_____no_output_____" ] ], [ [ "Since `b if a is None else a` is such a common pattern, we wrap it in a function. However, be careful, because python will evaluate *both* `a` and `b` when calling `ifnone` (which it doesn't do if using the `if` version directly).", "_____no_output_____" ] ], [ [ "test_eq(ifnone(None,1), 1)\ntest_eq(ifnone(2 ,1), 2)", "_____no_output_____" ], [ "#export\ndef get_class(nm, *fld_names, sup=None, doc=None, funcs=None, **flds):\n \"Dynamically create a class, optionally inheriting from `sup`, containing `fld_names`\"\n attrs = {}\n for f in fld_names: attrs[f] = None\n for f in L(funcs): attrs[f.__name__] = f\n for k,v in flds.items(): attrs[k] = v\n sup = ifnone(sup, ())\n if not isinstance(sup, tuple): sup=(sup,)\n \n def _init(self, *args, **kwargs):\n for i,v in enumerate(args): setattr(self, list(attrs.keys())[i], v)\n for k,v in kwargs.items(): setattr(self,k,v)\n \n def _repr(self):\n return '\\n'.join(f'{o}: {getattr(self,o)}' for o in set(dir(self))\n if not o.startswith('_') and not isinstance(getattr(self,o), types.MethodType))\n \n if not sup: attrs['__repr__'] = _repr\n attrs['__init__'] = _init\n res = type(nm, sup, attrs)\n if doc is not None: res.__doc__ = doc\n return res", "_____no_output_____" ], [ "_t = get_class('_t', 'a', b=2)\nt = _t()\ntest_eq(t.a, None)\ntest_eq(t.b, 2)\nt = _t(1, b=3)\ntest_eq(t.a, 1)\ntest_eq(t.b, 3)\nt = _t(1, 3)\ntest_eq(t.a, 1)\ntest_eq(t.b, 3)", "_____no_output_____" ] ], [ [ "Most often you'll want to call `mk_class`, since it adds the class to your module. See `mk_class` for more details and examples of use (which also apply to `get_class`).", "_____no_output_____" ] ], [ [ "#export\ndef mk_class(nm, *fld_names, sup=None, doc=None, funcs=None, mod=None, **flds):\n \"Create a class using `get_class` and add to the caller's module\"\n if mod is None: mod = inspect.currentframe().f_back.f_locals\n res = get_class(nm, *fld_names, sup=sup, doc=doc, funcs=funcs, **flds)\n mod[nm] = res", "_____no_output_____" ] ], [ [ "Any `kwargs` will be added as class attributes, and `sup` is an optional (tuple of) base classes.", "_____no_output_____" ] ], [ [ "mk_class('_t', a=1, sup=GetAttr)\nt = _t()\ntest_eq(t.a, 1)\nassert(isinstance(t,GetAttr))", "_____no_output_____" ] ], [ [ "A `__init__` is provided that sets attrs for any `kwargs`, and for any `args` (matching by position to fields), along with a `__repr__` which prints all attrs. The docstring is set to `doc`. You can pass `funcs` which will be added as attrs with the function names.", "_____no_output_____" ] ], [ [ "def foo(self): return 1\nmk_class('_t', 'a', sup=GetAttr, doc='test doc', funcs=foo)\n\nt = _t(3, b=2)\ntest_eq(t.a, 3)\ntest_eq(t.b, 2)\ntest_eq(t.foo(), 1)\ntest_eq(t.__doc__, 'test doc')\nt", "_____no_output_____" ], [ "#export\ndef wrap_class(nm, *fld_names, sup=None, doc=None, funcs=None, **flds):\n \"Decorator: makes function a method of a new class `nm` passing parameters to `mk_class`\"\n def _inner(f):\n mk_class(nm, *fld_names, sup=sup, doc=doc, funcs=L(funcs)+f, mod=f.__globals__, **flds)\n return f\n return _inner", "_____no_output_____" ], [ "@wrap_class('_t', a=2)\ndef bar(self,x): return x+1\n\nt = _t()\ntest_eq(t.a, 2)\ntest_eq(t.bar(3), 4)", "_____no_output_____" ], [ "show_doc(noop)", "_____no_output_____" ], [ "noop()\ntest_eq(noop(1),1)", "_____no_output_____" ], [ "show_doc(noops)", "_____no_output_____" ], [ "mk_class('_t', foo=noops)\ntest_eq(_t().foo(1),1)", "_____no_output_____" ], [ "#export\ndef set_seed(s):\n \"Set random seed for `random`, `torch`, and `numpy` (where available)\"\n try: torch.manual_seed(s)\n except NameError: pass\n try: np.random.seed(s%(2**32-1))\n except NameError: pass\n random.seed(s)", "_____no_output_____" ], [ "set_seed(2*33)\na1 = np.random.random()\na2 = torch.rand(())\na3 = random.random()\nset_seed(2*33)\nb1 = np.random.random()\nb2 = torch.rand(())\nb3 = random.random()\ntest_eq(a1,b1)\ntest_eq(a2,b2)\ntest_eq(a3,b3)", "_____no_output_____" ], [ "#export\ndef store_attr(self, nms):\n \"Store params named in comma-separated `nms` from calling context into attrs in `self`\"\n mod = inspect.currentframe().f_back.f_locals\n for n in re.split(', *', nms): setattr(self,n,mod[n])", "_____no_output_____" ], [ "class T:\n def __init__(self, a,b,c): store_attr(self, 'a,b, c')\n\nt = T(1,c=2,b=3)\nassert t.a==1 and t.b==3 and t.c==2", "_____no_output_____" ] ], [ [ "### Subclassing `Tensor`", "_____no_output_____" ] ], [ [ "#export\nclass TensorBase(Tensor, metaclass=BypassNewMeta):\n def _new_meta(self, *args, **kwargs): return tensor(self)", "_____no_output_____" ], [ "#export\ndef _patch_tb():\n def get_f(fn):\n def _f(self, *args, **kwargs):\n cls = self.__class__\n res = getattr(super(TensorBase, self), fn)(*args, **kwargs)\n return cls(res) if isinstance(res,Tensor) else res\n return _f\n \n t = tensor([1])\n skips = '__class__ __deepcopy__ __delattr__ __dir__ __doc__ __getattribute__ __hash__ __init__ \\\n __init_subclass__ __new__ __reduce__ __module__ __setstate__'.split()\n\n for fn in dir(t):\n if fn in skips: continue\n f = getattr(t, fn)\n if isinstance(f, (types.MethodWrapperType, types.BuiltinFunctionType, types.BuiltinMethodType, types.MethodType, types.FunctionType)):\n setattr(TensorBase, fn, get_f(fn))\n\n_patch_tb()", "_____no_output_____" ], [ "t = TensorBase(range(5))\ntest_eq_type(t[0], TensorBase(0))\ntest_eq_type(t[:2], TensorBase([0,1]))\ntest_eq_type(t+1, TensorBase(range(1,6)))", "_____no_output_____" ], [ "class _T(TensorBase): pass\n\nt = _T(range(5))\ntest_eq_type(t[0], _T(0))\ntest_eq_type(t[:2], _T([0,1]))\ntest_eq_type(t+1, _T(range(1,6)))", "_____no_output_____" ], [ "#export\ndef retain_type(new, old=None, typ=None):\n \"Cast `new` to type of `old` if it's a superclass\"\n # e.g. old is TensorImage, new is Tensor - if not subclass then do nothing\n assert old is not None or typ is not None\n if typ is None:\n if not isinstance(old, type(new)): return new\n typ = old if isinstance(old,type) else type(old)\n # Do nothing the new type is already an instance of requested type (i.e. same type)\n return typ(new) if typ!=NoneType and not isinstance(new, typ) else new", "_____no_output_____" ], [ "class _T(tuple): pass\na = _T((1,2))\nb = tuple((1,2))\ntest_eq_type(retain_type(b, typ=_T), a)", "_____no_output_____" ], [ "#export\ndef retain_types(new, old=None, typs=None):\n \"Cast each item of `new` to type of matching item in `old` if it's a superclass\"\n assert old is not None or typs is not None\n return tuple(L(new,L(old),L(typs)).mapped_zip(retain_type, longest=True))", "_____no_output_____" ], [ "class T(tuple): pass\n\nt1,t2 = retain_types((tensor(1),(tensor(1),)), (TensorBase(2),T((2,))))\ntest_eq_type(t1, TensorBase(1))\ntest_eq_type(t2, T((tensor(1),)))", "_____no_output_____" ] ], [ [ "### Collection functions", "_____no_output_____" ] ], [ [ "#export\ndef tuplify(o, use_list=False, match=None):\n \"Make `o` a tuple\"\n return tuple(L(o, use_list=use_list, match=match))", "_____no_output_____" ], [ "test_eq(tuplify(None),())\ntest_eq(tuplify([1,2,3]),(1,2,3))\ntest_eq(tuplify(1,match=[1,2,3]),(1,1,1))", "_____no_output_____" ], [ "#export\ndef replicate(item,match):\n \"Create tuple of `item` copied `len(match)` times\"\n return (item,)*len(match)", "_____no_output_____" ], [ "t = [1,1]\ntest_eq(replicate([1,2], t),([1,2],[1,2]))\ntest_eq(replicate(1, t),(1,1))", "_____no_output_____" ], [ "#export\ndef uniqueify(x, sort=False, bidir=False, start=None):\n \"Return the unique elements in `x`, optionally `sort`-ed, optionally return the reverse correspondance.\"\n res = list(OrderedDict.fromkeys(x).keys())\n if start is not None: res = L(start)+res\n if sort: res.sort()\n if bidir: return res, {v:k for k,v in enumerate(res)}\n return res", "_____no_output_____" ], [ "# test\ntest_eq(set(uniqueify([1,1,0,5,0,3])),{0,1,3,5})\ntest_eq(uniqueify([1,1,0,5,0,3], sort=True),[0,1,3,5])\nv,o = uniqueify([1,1,0,5,0,3], bidir=True)\ntest_eq(v,[1,0,5,3])\ntest_eq(o,{1:0, 0: 1, 5: 2, 3: 3})\nv,o = uniqueify([1,1,0,5,0,3], sort=True, bidir=True)\ntest_eq(v,[0,1,3,5])\ntest_eq(o,{0:0, 1: 1, 3: 2, 5: 3})", "_____no_output_____" ], [ "# export\ndef setify(o): return o if isinstance(o,set) else set(L(o))", "_____no_output_____" ], [ "# test\ntest_eq(setify(None),set())\ntest_eq(setify('abc'),{'abc'})\ntest_eq(setify([1,2,2]),{1,2})\ntest_eq(setify(range(0,3)),{0,1,2})\ntest_eq(setify({1,2}),{1,2})", "_____no_output_____" ], [ "#export\ndef is_listy(x):\n \"`isinstance(x, (tuple,list,L))`\"\n return isinstance(x, (tuple,list,L,slice,Generator))", "_____no_output_____" ], [ "assert is_listy([1])\nassert is_listy(L([1]))\nassert is_listy(slice(2))\nassert not is_listy(torch.tensor([1]))", "_____no_output_____" ], [ "#export\ndef range_of(x):\n \"All indices of collection `x` (i.e. `list(range(len(x)))`)\"\n return list(range(len(x)))", "_____no_output_____" ], [ "test_eq(range_of([1,1,1,1]), [0,1,2,3])", "_____no_output_____" ], [ "#export\ndef groupby(x, key):\n \"Like `itertools.groupby` but doesn't need to be sorted, and isn't lazy\"\n res = {}\n for o in x: res.setdefault(key(o), []).append(o)\n return res", "_____no_output_____" ], [ "test_eq(groupby('aa ab bb'.split(), itemgetter(0)), {'a':['aa','ab'], 'b':['bb']})", "_____no_output_____" ], [ "#export\ndef merge(*ds):\n \"Merge all dictionaries in `ds`\"\n return {k:v for d in ds for k,v in d.items()}", "_____no_output_____" ], [ "test_eq(merge(), {})\ntest_eq(merge(dict(a=1,b=2)), dict(a=1,b=2))\ntest_eq(merge(dict(a=1,b=2), dict(b=3,c=4)), dict(a=1, b=3, c=4))", "_____no_output_____" ], [ "#export\ndef shufflish(x, pct=0.04):\n \"Randomly relocate items of `x` up to `pct` of `len(x)` from their starting location\"\n n = len(x)\n return L(x[i] for i in sorted(range_of(x), key=lambda o: o+n*(1+random.random()*pct)))", "_____no_output_____" ], [ "l = list(range(100))\nl2 = array(shufflish(l))\ntest_close(l2[:50 ].mean(), 25, eps=5)\ntest_close(l2[-50:].mean(), 75, eps=5)\ntest_ne(l,l2)", "_____no_output_____" ], [ "#export\nclass IterLen:\n \"Base class to add iteration to anything supporting `len` and `__getitem__`\"\n def __iter__(self): return (self[i] for i in range_of(self))", "_____no_output_____" ], [ "#export\n@docs\nclass ReindexCollection(GetAttr, IterLen):\n \"Reindexes collection `coll` with indices `idxs` and optional LRU cache of size `cache`\"\n def __init__(self, coll, idxs=None, cache=None):\n self.default,self.coll,self.idxs,self.cache = coll,coll,ifnone(idxs,L.range(coll)),cache\n def _get(self, i): return self.coll[i]\n self._get = types.MethodType(_get,self)\n if cache is not None: self._get = functools.lru_cache(maxsize=cache)(self._get)\n\n def __getitem__(self, i): return self._get(self.idxs[i])\n def __len__(self): return len(self.coll)\n def reindex(self, idxs): self.idxs = idxs\n def shuffle(self): random.shuffle(self.idxs)\n def cache_clear(self): self._get.cache_clear()\n \n _docs = dict(reindex=\"Replace `self.idxs` with idxs\",\n shuffle=\"Randomly shuffle indices\",\n cache_clear=\"Clear LRU cache\")", "_____no_output_____" ], [ "sz = 50\nt = ReindexCollection(L.range(sz), cache=2)\ntest_eq(list(t), range(sz))\ntest_eq(t[sz-1], sz-1)\ntest_eq(t._get.cache_info().hits, 1)\nt.shuffle()\ntest_eq(t._get.cache_info().hits, 1)\ntest_ne(list(t), range(sz))\ntest_eq(set(t), set(range(sz)))\nt.cache_clear()\ntest_eq(t._get.cache_info().hits, 0)\ntest_eq(t.count(0), 1)", "_____no_output_____" ], [ "#export\ndef _oper(op,a,b=None): return (lambda o:op(o,a)) if b is None else op(a,b)\n\ndef _mk_op(nm, mod=None):\n \"Create an operator using `oper` and add to the caller's module\"\n if mod is None: mod = inspect.currentframe().f_back.f_locals\n op = getattr(operator,nm)\n def _inner(a,b=None): return _oper(op, a,b)\n _inner.__name__ = _inner.__qualname__ = nm\n _inner.__doc__ = f'Same as `operator.{nm}`, or returns partial if 1 arg'\n mod[nm] = _inner", "_____no_output_____" ], [ "#export\n_all_ = ['lt', 'gt', 'le', 'ge', 'eq', 'ne', 'add', 'sub', 'mul', 'truediv']", "_____no_output_____" ], [ "#export\nfor op in 'lt gt le ge eq ne add sub mul truediv'.split(): _mk_op(op)", "_____no_output_____" ] ], [ [ "The following functions are provided matching the behavior of the equivalent versions in `operator`:\n\n - *lt gt le ge eq ne add sub mul truediv*", "_____no_output_____" ] ], [ [ "lt(3,5),gt(3,5)", "_____no_output_____" ] ], [ [ "However, they also have additional functionality: if you only pass one param, they return a partial function that passes that param as the second positional parameter.", "_____no_output_____" ] ], [ [ "lt(5)(3),gt(5)(3)", "_____no_output_____" ], [ "#export\nclass _InfMeta(type):\n @property\n def count(self): return itertools.count()\n @property\n def zeros(self): return itertools.cycle([0])\n @property\n def ones(self): return itertools.cycle([1])\n @property\n def nones(self): return itertools.cycle([None])", "_____no_output_____" ], [ "#export\nclass Inf(metaclass=_InfMeta):\n \"Infinite lists\"\n pass", "_____no_output_____" ] ], [ [ "`Inf` defines the following properties:\n \n- `count: itertools.count()`\n- `zeros: itertools.cycle([0])`\n- `ones : itertools.cycle([1])`\n- `nones: itertools.cycle([None])`", "_____no_output_____" ] ], [ [ "test_eq([o for i,o in zip(range(5), Inf.count)],\n [0, 1, 2, 3, 4])\n\ntest_eq([o for i,o in zip(range(5), Inf.zeros)],\n [0, 0, 0, 0, 0])", "_____no_output_____" ], [ "#export\ndef true(*args, **kwargs):\n \"Predicate: always `True`\"\n return True", "_____no_output_____" ], [ "#export\ndef stop(e=StopIteration):\n \"Raises exception `e` (by default `StopException`) even if in an expression\"\n raise e", "_____no_output_____" ], [ "#export\ndef gen(func, seq, cond=true):\n \"Like `(func(o) for o in seq if cond(func(o)))` but handles `StopIteration`\"\n return itertools.takewhile(cond, map(func,seq))", "_____no_output_____" ], [ "test_eq(gen(noop, Inf.count, lt(5)),\n range(5))\ntest_eq(gen(operator.neg, Inf.count, gt(-5)),\n [0,-1,-2,-3,-4])\ntest_eq(gen(lambda o:o if o<5 else stop(), Inf.count),\n range(5))", "_____no_output_____" ], [ "#export\ndef chunked(it, cs, drop_last=False):\n if not isinstance(it, Iterator): it = iter(it)\n while True:\n res = list(itertools.islice(it, cs))\n if res and (len(res)==cs or not drop_last): yield res\n if len(res)<cs: return", "_____no_output_____" ], [ "t = L.range(10)\ntest_eq(chunked(t,3), [[0,1,2], [3,4,5], [6,7,8], [9]])\ntest_eq(chunked(t,3,True), [[0,1,2], [3,4,5], [6,7,8], ])\n\nt = map(lambda o:stop() if o==6 else o, Inf.count)\ntest_eq(chunked(t,3), [[0, 1, 2], [3, 4, 5]])\nt = map(lambda o:stop() if o==7 else o, Inf.count)\ntest_eq(chunked(t,3), [[0, 1, 2], [3, 4, 5], [6]])\n\nt = tensor(range(10))\ntest_eq(chunked(t,3), [[0,1,2], [3,4,5], [6,7,8], [9]])\ntest_eq(chunked(t,3,True), [[0,1,2], [3,4,5], [6,7,8], ])", "_____no_output_____" ], [ "#export\ndef concat(*ls):\n \"Concatenate tensors, arrays, lists, or tuples\"\n if not len(ls): return []\n it = ls[0]\n if isinstance(it,torch.Tensor): res = torch.cat(ls) \n elif isinstance(it,ndarray): res = np.concatenate(ls)\n else:\n res = [o for x in ls for o in L(x)]\n if isinstance(it,(tuple,list)): res = type(it)(res)\n else: res = L(res)\n return retain_type(res, it)", "_____no_output_____" ], [ "a,b,c = [1],[1,2],[1,1,2]\ntest_eq(concat(a,b), c)\ntest_eq_type(concat(tuple (a),tuple (b)), tuple (c))\ntest_eq_type(concat(array (a),array (b)), array (c))\ntest_eq_type(concat(tensor(a),tensor(b)), tensor(c))\ntest_eq_type(concat(TensorBase(a),TensorBase(b)), TensorBase(c))\ntest_eq_type(concat([1,1],1), [1,1,1])\ntest_eq_type(concat(1,1,1), L(1,1,1))\ntest_eq_type(concat(L(1,2),1), L(1,2,1))", "_____no_output_____" ] ], [ [ "### Chunks -", "_____no_output_____" ] ], [ [ "#export\nclass Chunks:\n \"Slice and int indexing into a list of lists\"\n def __init__(self, chunks, lens=None):\n self.chunks = chunks\n self.lens = L(map(len,self.chunks) if lens is None else lens)\n self.cumlens = np.cumsum(0+self.lens)\n self.totlen = self.cumlens[-1]\n\n def __getitem__(self,i):\n if isinstance(i,slice): return self.getslice(i)\n di,idx = self.doc_idx(i)\n return self.chunks[di][idx]\n\n def getslice(self, i):\n st_d,st_i = self.doc_idx(ifnone(i.start,0))\n en_d,en_i = self.doc_idx(ifnone(i.stop,self.totlen+1))\n res = [self.chunks[st_d][st_i:(en_i if st_d==en_d else sys.maxsize)]]\n for b in range(st_d+1,en_d): res.append(self.chunks[b])\n if st_d!=en_d and en_d<len(self.chunks): res.append(self.chunks[en_d][:en_i])\n return concat(*res)\n \n def doc_idx(self, i):\n if i<0: i=self.totlen+i # count from end\n docidx = np.searchsorted(self.cumlens, i+1)-1\n cl = self.cumlens[docidx]\n return docidx,i-cl", "_____no_output_____" ], [ "docs = L(list(string.ascii_lowercase[a:b]) for a,b in ((0,3),(3,7),(7,8),(8,16),(16,24),(24,26)))\n\nb = Chunks(docs)\ntest_eq([b[ o] for o in range(0,5)], ['a','b','c','d','e'])\ntest_eq([b[-o] for o in range(1,6)], ['z','y','x','w','v'])\ntest_eq(b[6:13], 'g,h,i,j,k,l,m'.split(','))\ntest_eq(b[20:77], 'u,v,w,x,y,z'.split(','))\ntest_eq(b[:5], 'a,b,c,d,e'.split(','))\ntest_eq(b[:2], 'a,b'.split(','))", "_____no_output_____" ], [ "t = torch.arange(26)\ndocs = L(t[a:b] for a,b in ((0,3),(3,7),(7,8),(8,16),(16,24),(24,26)))\nb = Chunks(docs)\ntest_eq([b[ o] for o in range(0,5)], range(0,5))\ntest_eq([b[-o] for o in range(1,6)], [25,24,23,22,21])\ntest_eq(b[6:13], torch.arange(6,13))\ntest_eq(b[20:77], torch.arange(20,26))\ntest_eq(b[:5], torch.arange(5))\ntest_eq(b[:2], torch.arange(2))", "_____no_output_____" ], [ "docs = L(TensorBase(t[a:b]) for a,b in ((0,3),(3,7),(7,8),(8,16),(16,24),(24,26)))\nb = Chunks(docs)\ntest_eq_type(b[:2], TensorBase(range(2)))\ntest_eq_type(b[:5], TensorBase(range(5)))\ntest_eq_type(b[9:13], TensorBase(range(9,13)))", "_____no_output_____" ], [ "type(b[9:13])", "_____no_output_____" ] ], [ [ "### Functions on functions", "_____no_output_____" ] ], [ [ "#export\ndef trace(f):\n \"Add `set_trace` to an existing function `f`\"\n def _inner(*args,**kwargs):\n set_trace()\n return f(*args,**kwargs)\n return _inner", "_____no_output_____" ], [ "# export\ndef compose(*funcs, order=None):\n \"Create a function that composes all functions in `funcs`, passing along remaining `*args` and `**kwargs` to all\"\n funcs = L(funcs)\n if order is not None: funcs = funcs.sorted(order)\n def _inner(x, *args, **kwargs):\n for f in L(funcs): x = f(x, *args, **kwargs)\n return x\n return _inner", "_____no_output_____" ], [ "f1 = lambda o,p=0: (o*2)+p\nf2 = lambda o,p=1: (o+1)/p\ntest_eq(f2(f1(3)), compose(f1,f2)(3))\ntest_eq(f2(f1(3,p=3),p=3), compose(f1,f2)(3,p=3))\ntest_eq(f2(f1(3, 3), 3), compose(f1,f2)(3, 3))\n\nf1.order = 1\ntest_eq(f1(f2(3)), compose(f1,f2, order=\"order\")(3))", "_____no_output_____" ], [ "#export\ndef maps(*args, retain=noop):\n \"Like `map`, except funcs are composed first\"\n f = compose(*args[:-1])\n def _f(b): return retain(f(b), b)\n return map(_f, args[-1])", "_____no_output_____" ], [ "test_eq(maps([1]), [1])\ntest_eq(maps(operator.neg, [1,2]), [-1,-2])\ntest_eq(maps(operator.neg, operator.neg, [1,2]), [1,2])\n\ntest_eq_type(list(maps(operator.neg, [TensorBase(1), 2], retain=retain_type)), \n [TensorBase(-1), -2])", "_____no_output_____" ], [ "#export\ndef mapper(f):\n \"Create a function that maps `f` over an input collection\"\n return lambda o: [f(o_) for o_ in o]", "_____no_output_____" ], [ "func = mapper(lambda o:o*2)\ntest_eq(func(range(3)),[0,2,4])", "_____no_output_____" ], [ "#export\ndef partialler(f, *args, order=None, **kwargs):\n \"Like `functools.partial` but also copies over docstring\"\n fnew = partial(f,*args,**kwargs)\n fnew.__doc__ = f.__doc__\n if order is not None: fnew.order=order\n elif hasattr(f,'order'): fnew.order=f.order\n return fnew", "_____no_output_____" ], [ "def _f(x,a=1):\n \"test func\"\n return x+a\n_f.order=1\n\nf = partialler(_f, a=2)\ntest_eq(f.order, 1)\nf = partialler(_f, a=2, order=3)\ntest_eq(f.__doc__, \"test func\")\ntest_eq(f.order, 3)\ntest_eq(f(3), _f(3,2))", "_____no_output_____" ], [ "#export\ndef instantiate(t):\n \"Instantiate `t` if it's a type, otherwise do nothing\"\n return t() if isinstance(t, type) else t", "_____no_output_____" ], [ "test_eq_type(instantiate(int), 0)\ntest_eq_type(instantiate(1), 1)", "_____no_output_____" ], [ "#export\nmk_class('_Arg', 'i')\n_0,_1,_2,_3,_4 = _Arg(0),_Arg(1),_Arg(2),_Arg(3),_Arg(4)", "_____no_output_____" ], [ "#export\nclass bind:\n \"Same as `partial`, except you can use `_0` `_1` etc param placeholders\"\n def __init__(self, fn, *pargs, **pkwargs):\n store_attr(self, 'fn,pargs,pkwargs')\n self.maxi = max((x.i for x in pargs if isinstance(x, _Arg)), default=-1)\n\n def __call__(self, *args, **kwargs):\n fargs = L(args[x.i] if isinstance(x, _Arg) else x for x in self.pargs) + args[self.maxi+1:]\n return self.fn(*fargs, **{**self.pkwargs, **kwargs})", "_____no_output_____" ], [ "def myfn(a,b,c,d=1,e=2): return(a,b,c,d,e)\ntest_eq(bind(myfn, _1, 17, _0, e=3)(19,14), (14,17,19,1,3))\ntest_eq(bind(myfn, 17, _0, e=3)(19,14), (17,19,14,1,3))\ntest_eq(bind(myfn, 17, e=3)(19,14), (17,19,14,1,3))\ntest_eq(bind(myfn)(17,19,14), (17,19,14,1,2))", "_____no_output_____" ] ], [ [ "### File and network functions", "_____no_output_____" ] ], [ [ "#export\n#NB: Please don't move this to a different line or module, since it's used in testing `get_source_link`\n@patch\ndef ls(self:Path, file_type=None, file_exts=None):\n \"Contents of path as a list\"\n extns=L(file_exts)\n if file_type: extns += L(k for k,v in mimetypes.types_map.items() if v.startswith(file_type))\n return L(self.iterdir()).filtered(lambda x: len(extns)==0 or x.suffix in extns)", "_____no_output_____" ] ], [ [ "We add an `ls()` method to `pathlib.Path` which is simply defined as `list(Path.iterdir())`, mainly for convenience in REPL environments such as notebooks.", "_____no_output_____" ] ], [ [ "path = Path()\nt = path.ls()\nassert len(t)>0\nt[0]", "_____no_output_____" ] ], [ [ "You can also pass an optional `file_type` MIME prefix and/or a list of file extensions.", "_____no_output_____" ] ], [ [ "txt_files=path.ls(file_type='text')\nassert len(txt_files) > 0 and txt_files[0].suffix=='.py'\nipy_files=path.ls(file_exts=['.ipynb'])\nassert len(ipy_files) > 0 and ipy_files[0].suffix=='.ipynb'\ntxt_files[0],ipy_files[0]", "_____no_output_____" ], [ "#hide\npkl = pickle.dumps(path)\np2 =pickle.loads(pkl)\ntest_eq(path.ls()[0], p2.ls()[0])", "_____no_output_____" ], [ "def bunzip(fn):\n \"bunzip `fn`, raising exception if output already exists\"\n fn = Path(fn)\n assert fn.exists(), f\"{fn} doesn't exist\"\n out_fn = fn.with_suffix('')\n assert not out_fn.exists(), f\"{out_fn} already exists\"\n with bz2.BZ2File(fn, 'rb') as src, out_fn.open('wb') as dst:\n for d in iter(lambda: src.read(1024*1024), b''): dst.write(d)", "_____no_output_____" ], [ "f = Path('files/test.txt')\nif f.exists(): f.unlink()\nbunzip('files/test.txt.bz2')\nt = f.open().readlines()\ntest_eq(len(t),1)\ntest_eq(t[0], 'test\\n')\nf.unlink()", "_____no_output_____" ] ], [ [ "### Tensor functions", "_____no_output_____" ] ], [ [ "#export\ndef apply(func, x, *args, **kwargs):\n \"Apply `func` recursively to `x`, passing on args\"\n if is_listy(x): return type(x)(apply(func, o, *args, **kwargs) for o in x)\n if isinstance(x,dict): return {k: apply(func, v, *args, **kwargs) for k,v in x.items()}\n return retain_type(func(x, *args, **kwargs), x)", "_____no_output_____" ], [ "#export\ndef to_detach(b, cpu=True):\n \"Recursively detach lists of tensors in `b `; put them on the CPU if `cpu=True`.\"\n def _inner(x, cpu=True):\n if not isinstance(x,Tensor): return x\n x = x.detach()\n return x.cpu() if cpu else x\n return apply(_inner, b, cpu=cpu)", "_____no_output_____" ], [ "#export\ndef to_half(b):\n \"Recursively map lists of tensors in `b ` to FP16.\"\n return apply(lambda x: x.half() if torch.is_floating_point(x) else x, b)", "_____no_output_____" ], [ "#export\ndef to_float(b):\n \"Recursively map lists of int tensors in `b ` to float.\"\n return apply(lambda x: x.float() if torch.is_floating_point(x) else x, b)", "_____no_output_____" ], [ "#export\n# None: True if available; True: error if not availabe; False: use CPU\ndefaults.use_cuda = None", "_____no_output_____" ], [ "#export\ndef default_device(use_cuda=-1):\n \"Return or set default device; `use_cuda`: None - CUDA if available; True - error if not availabe; False - CPU\"\n if use_cuda != -1: defaults.use_cuda=use_cuda\n use = defaults.use_cuda or (torch.cuda.is_available() and defaults.use_cuda is None)\n assert torch.cuda.is_available() or not use\n return torch.device(torch.cuda.current_device()) if use else torch.device('cpu')", "_____no_output_____" ], [ "#cuda\n_td = torch.device(torch.cuda.current_device())\ntest_eq(default_device(None), _td)\ntest_eq(default_device(True), _td)\ntest_eq(default_device(False), torch.device('cpu'))\ndefault_device(None);", "_____no_output_____" ], [ "#export\ndef to_device(b, device=None):\n \"Recursively put `b` on `device`.\"\n if device is None: device=default_device()\n def _inner(o): return o.to(device, non_blocking=True) if isinstance(o,Tensor) else o\n return apply(_inner, b)", "_____no_output_____" ], [ "t = to_device((3,(tensor(3),tensor(2))))\nt1,(t2,t3) = t\ntest_eq_type(t,(3,(tensor(3).cuda(),tensor(2).cuda())))\ntest_eq(t2.type(), \"torch.cuda.LongTensor\")\ntest_eq(t3.type(), \"torch.cuda.LongTensor\")", "_____no_output_____" ], [ "#export\ndef to_cpu(b):\n \"Recursively map lists of tensors in `b ` to the cpu.\"\n return to_device(b,'cpu')", "_____no_output_____" ], [ "t3 = to_cpu(t3)\ntest_eq(t3.type(), \"torch.LongTensor\")\ntest_eq(t3, 2)", "_____no_output_____" ], [ "def to_np(x):\n \"Convert a tensor to a numpy array.\"\n return x.data.cpu().numpy()", "_____no_output_____" ], [ "t3 = to_np(t3)\ntest_eq(type(t3), np.ndarray)\ntest_eq(t3, 2)", "_____no_output_____" ], [ "#export\ndef item_find(x, idx=0):\n \"Recursively takes the `idx`-th element of `x`\"\n if is_listy(x): return item_find(x[idx])\n if isinstance(x,dict): \n key = list(x.keys())[idx] if isinstance(idx, int) else idx\n return item_find(x[key])\n return x", "_____no_output_____" ], [ "#export\ndef find_device(b):\n \"Recursively search the device of `b`.\"\n return item_find(b).device", "_____no_output_____" ], [ "dev = default_device()\ntest_eq(find_device(t2), dev)\ntest_eq(find_device([t2,t2]), dev)\ntest_eq(find_device({'a':t2,'b':t2}), dev)\ntest_eq(find_device({'a':[[t2],[t2]],'b':t2}), dev)", "_____no_output_____" ], [ "#export\ndef find_bs(b):\n \"Recursively search the batch size of `b`.\"\n return item_find(b).shape[0]", "_____no_output_____" ], [ "x = torch.randn(4,5)\ntest_eq(find_bs(x), 4)\ntest_eq(find_bs([x, x]), 4)\ntest_eq(find_bs({'a':x,'b':x}), 4)\ntest_eq(find_bs({'a':[[x],[x]],'b':x}), 4)", "_____no_output_____" ], [ "def np_func(f):\n \"Convert a function taking and returning numpy arrays to one taking and returning tensors\"\n def _inner(*args, **kwargs):\n nargs = [to_np(arg) if isinstance(arg,Tensor) else arg for arg in args]\n return tensor(f(*nargs, **kwargs))\n functools.update_wrapper(_inner, f)\n return _inner", "_____no_output_____" ] ], [ [ "This decorator is particularly useful for using numpy functions as fastai metrics, for instance:", "_____no_output_____" ] ], [ [ "from sklearn.metrics import f1_score\n\n@np_func\ndef f1(inp,targ): return f1_score(targ, inp)\n\na1,a2 = array([0,1,1]),array([1,0,1])\nt = f1(tensor(a1),tensor(a2))\ntest_eq(f1_score(a1,a2), t)\nassert isinstance(t,Tensor)", "_____no_output_____" ], [ "class Module(nn.Module, metaclass=PrePostInitMeta):\n \"Same as `nn.Module`, but no need for subclasses to call `super().__init__`\"\n def __pre_init__(self): super().__init__()\n def __init__(self): pass", "_____no_output_____" ], [ "show_doc(Module, title_level=3)", "_____no_output_____" ], [ "class _T(Module):\n def __init__(self): self.f = nn.Linear(1,1)\n def forward(self,x): return self.f(x)\n\nt = _T()\nt(tensor([1.]))", "_____no_output_____" ] ], [ [ "### Sorting objects from before/after", "_____no_output_____" ], [ "Transforms and callbacks will have run_after/run_before attributes, this function will sort them to respect those requirements (if it's possible). Also, sometimes we want a tranform/callback to be run at the end, but still be able to use run_after/run_before behaviors. For those, the function checks for a toward_end attribute (that needs to be True).", "_____no_output_____" ] ], [ [ "#export\ndef _is_instance(f, gs):\n tst = [g if type(g) in [type, 'function'] else g.__class__ for g in gs]\n for g in tst:\n if isinstance(f, g) or f==g: return True\n return False\n\ndef _is_first(f, gs):\n for o in L(getattr(f, 'run_after', None)): \n if _is_instance(o, gs): return False\n for g in gs:\n if _is_instance(f, L(getattr(g, 'run_before', None))): return False\n return True\n\ndef sort_by_run(fs):\n end = L(getattr(f, 'toward_end', False) for f in fs)\n inp,res = L(fs)[~end] + L(fs)[end], []\n while len(inp) > 0:\n for i,o in enumerate(inp):\n if _is_first(o, inp): \n res.append(inp.pop(i))\n break\n else: raise Exception(\"Impossible to sort\")\n return res", "_____no_output_____" ], [ "class Tst(): pass \nclass Tst1():\n run_before=[Tst]\nclass Tst2():\n run_before=Tst\n run_after=Tst1\n \ntsts = [Tst(), Tst1(), Tst2()]\ntest_eq(sort_by_run(tsts), [tsts[1], tsts[2], tsts[0]])\n\nTst2.run_before,Tst2.run_after = Tst1,Tst\ntest_fail(lambda: sort_by_run([Tst(), Tst1(), Tst2()]))\n\ndef tst1(x): return x\ntst1.run_before = Tst\ntest_eq(sort_by_run([tsts[0], tst1]), [tst1, tsts[0]])\n \nclass Tst1():\n toward_end=True\nclass Tst2():\n toward_end=True\n run_before=Tst1\ntsts = [Tst(), Tst1(), Tst2()]\ntest_eq(sort_by_run(tsts), [tsts[0], tsts[2], tsts[1]])", "_____no_output_____" ] ], [ [ "### Other helpers", "_____no_output_____" ] ], [ [ "#export\ndef round_multiple(x, mult, round_down=False):\n \"Round `x` to nearest multiple of `mult`\"\n def _f(x_): return (int if round_down else round)(x_/mult)*mult\n res = L(x).mapped(_f)\n return res if is_listy(x) else res[0]", "_____no_output_____" ], [ "test_eq(round_multiple(63,32), 64)\ntest_eq(round_multiple(50,32), 64)\ntest_eq(round_multiple(40,32), 32)\ntest_eq(round_multiple( 0,32), 0)\ntest_eq(round_multiple(63,32, round_down=True), 32)\ntest_eq(round_multiple((63,40),32), (64,32))", "_____no_output_____" ], [ "#export\ndef num_cpus():\n \"Get number of cpus\"\n try: return len(os.sched_getaffinity(0))\n except AttributeError: return os.cpu_count()\n \ndefaults.cpus = min(16, num_cpus())", "_____no_output_____" ], [ "#export\ndef add_props(f, n=2):\n \"Create properties passing each of `range(n)` to f\"\n return (property(partial(f,i)) for i in range(n))", "_____no_output_____" ], [ "class _T(): a,b = add_props(lambda i,x:i*2)\n\nt = _T()\ntest_eq(t.a,0)\ntest_eq(t.b,2)", "_____no_output_____" ] ], [ [ "### Image helpers", "_____no_output_____" ], [ "This is a quick way to generate, for instance, *train* and *valid* versions of a property. See `DataBunch` definition for an example of this.", "_____no_output_____" ] ], [ [ "#export\ndef make_cross_image(bw=True):\n \"Create a tensor containing a cross image, either `bw` (True) or color\"\n if bw:\n im = torch.zeros(5,5)\n im[2,:] = 1.\n im[:,2] = 1.\n else:\n im = torch.zeros(3,5,5)\n im[0,2,:] = 1.\n im[1,:,2] = 1.\n return im", "_____no_output_____" ], [ "plt.imshow(make_cross_image(), cmap=\"Greys\");", "_____no_output_____" ], [ "plt.imshow(make_cross_image(False).permute(1,2,0));", "_____no_output_____" ], [ "#export\ndef show_title(o, ax=None, ctx=None, label=None, **kwargs):\n \"Set title of `ax` to `o`, or print `o` if `ax` is `None`\"\n ax = ifnone(ax,ctx)\n if ax is None: print(o)\n elif hasattr(ax, 'set_title'): ax.set_title(o)\n elif isinstance(ax, pd.Series):\n while label in ax: label += '_'\n ax = ax.append(pd.Series({label: o}))\n return ax", "_____no_output_____" ], [ "test_stdout(lambda: show_title(\"title\"), \"title\")\n# ensure that col names are unique when showing to a pandas series\nassert show_title(\"title\", ctx=pd.Series(dict(a=1)), label='a').equals(pd.Series(dict(a=1,a_='title')))", "_____no_output_____" ], [ "#export\ndef show_image(im, ax=None, figsize=None, title=None, ctx=None, **kwargs):\n \"Show a PIL or PyTorch image on `ax`.\"\n ax = ifnone(ax,ctx)\n if ax is None: _,ax = plt.subplots(figsize=figsize)\n # Handle pytorch axis order\n if isinstance(im,Tensor):\n im = to_cpu(im)\n if im.shape[0]<5: im=im.permute(1,2,0)\n elif not isinstance(im,np.ndarray): im=array(im)\n # Handle 1-channel images\n if im.shape[-1]==1: im=im[...,0]\n ax.imshow(im, **kwargs)\n if title is not None: ax.set_title(title)\n ax.axis('off')\n return ax", "_____no_output_____" ] ], [ [ "`show_image` can show b&w images...", "_____no_output_____" ] ], [ [ "im = make_cross_image()\nax = show_image(im, cmap=\"Greys\", figsize=(2,2))", "_____no_output_____" ] ], [ [ "...and color images with standard `c*h*w` dim order...", "_____no_output_____" ] ], [ [ "im2 = make_cross_image(False)\nax = show_image(im2, figsize=(2,2))", "_____no_output_____" ] ], [ [ "...and color images with `h*w*c` dim order...", "_____no_output_____" ] ], [ [ "im3 = im2.permute(1,2,0)\nax = show_image(im3, figsize=(2,2))", "_____no_output_____" ], [ "ax = show_image(im, cmap=\"Greys\", figsize=(2,2))\nshow_title(\"Cross\", ax)", "_____no_output_____" ], [ "#export\ndef show_titled_image(o, **kwargs):\n \"Call `show_image` destructuring `o` to `(img,title)`\"\n show_image(o[0], title=str(o[1]), **kwargs)", "_____no_output_____" ], [ "#export\ndef show_image_batch(b, show=show_titled_image, items=9, cols=3, figsize=None, **kwargs):\n \"Display batch `b` in a grid of size `items` with `cols` width\"\n rows = (items+cols-1) // cols\n if figsize is None: figsize = (cols*3, rows*3)\n fig,axs = plt.subplots(rows, cols, figsize=figsize)\n for *o,ax in zip(*to_cpu(b), axs.flatten()): show(o, ax=ax, **kwargs)", "_____no_output_____" ], [ "show_image_batch(([im,im2,im3],['bw','chw','hwc']), items=3)", "_____no_output_____" ] ], [ [ "# Export -", "_____no_output_____" ] ], [ [ "#hide\nfrom local.notebook.export import notebook2script\nnotebook2script(all_fs=True)", "Converted 00_test.ipynb.\nConverted 01_core.ipynb.\nConverted 01a_dataloader.ipynb.\nConverted 01a_script.ipynb.\nConverted 02_transforms.ipynb.\nConverted 03_pipeline.ipynb.\nConverted 04_data_external.ipynb.\nConverted 05_data_core.ipynb.\nConverted 06_data_source.ipynb.\nConverted 07_vision_core.ipynb.\nConverted 08_pets_tutorial.ipynb.\nConverted 09_vision_augment.ipynb.\nConverted 11_layers.ipynb.\nConverted 12_optimizer.ipynb.\nConverted 13_learner.ipynb.\nConverted 14_callback_schedule.ipynb.\nConverted 15_callback_hook.ipynb.\nConverted 16_callback_progress.ipynb.\nConverted 17_callback_tracker.ipynb.\nConverted 18_callback_fp16.ipynb.\nConverted 19_callback_mixup.ipynb.\nConverted 20_metrics.ipynb.\nConverted 21_tutorial_imagenette.ipynb.\nConverted 30_text_core.ipynb.\nConverted 31_text_data.ipynb.\nConverted 32_text_models_awdlstm.ipynb.\nConverted 33_test_models_core.ipynb.\nConverted 34_callback_rnn.ipynb.\nConverted 35_tutorial_wikitext.ipynb.\nConverted 36_text_models_qrnn.ipynb.\nConverted 40_tabular_core.ipynb.\nConverted 41_tabular_model.ipynb.\nConverted 50_data_block.ipynb.\nConverted 60_vision_models_xresnet.ipynb.\nConverted 90_notebook_core.ipynb.\nConverted 91_notebook_export.ipynb.\nConverted 92_notebook_showdoc.ipynb.\nConverted 93_notebook_export2html.ipynb.\nConverted 94_index.ipynb.\nConverted 95_synth_learner.ipynb.\nConverted notebook2jekyll.ipynb.\n" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown", "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ], [ "markdown", "markdown" ], [ "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Choose a question to ask\nprint('How would you rate your day on a scale of 1 to 10?')", "How would you rate your day on a scale of 1 to 10?\n" ], [ "# Set a variable equal to input()\nday_rating = input()", "9\n" ], [ "# Select an appropriate output.\nprint('You feel like a ' + day_rating + ' today. Thanks for letting me know')", "You feel like a 9 today. Thanks for letting me know\n" ] ] ]

[ "code" ]

[ [ "code", "code", "code" ] ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ [ [ "import numpy as np\nimport scipy.optimize as so\n\n", "_____no_output_____" ], [ "# ref : https://matplotlib.org/stable/gallery/\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom matplotlib import cm\n\n", "_____no_output_____" ] ], [ [ "## 2차원 최적화<br>Two dimensional optimizations\n\n다음과 같은 비용 함수를 생각해 보자.<br>Let's think about a cost function as follows.\n\n$$\nC(x_0, x_1) = \\frac{x_0^2}{2^2} + \\frac{x_1^2}{1^2}\n$$\n\n파이썬으로는 다음과 같이 구현할 수 있을 것이다.<br>We may implement in python as follows.\n\n", "_____no_output_____" ] ], [ [ "def c(x:np.ndarray, a:float=2, b:float=1) -> float:\n x0 = x[0]\n x1 = x[1]\n \n return (x0 * x0) / (a * a) + (x1 * x1) / (b * b)\n\n", "_____no_output_____" ] ], [ [ "시각화 해 보자.<br>Let's visualize.\n\n", "_____no_output_____" ] ], [ [ "def plot_cost():\n # ref : https://matplotlib.org/stable/gallery/\n\n fig = plt.figure(figsize=(15, 6))\n ax1 = plt.subplot(1, 2, 1)\n ax2 = plt.subplot(1, 2, 2, projection=\"3d\")\n\n x = np.linspace(-4, 4)\n y = np.linspace(-2, 2)\n X, Y = np.meshgrid(x, y)\n\n Z = c((X, Y))\n\n cset = ax1.contour(X, Y, Z, cmap=cm.coolwarm)\n\n surf = ax2.plot_surface(X, Y, Z, antialiased=True, cmap=cm.viridis, alpha=0.5)\n fig.colorbar(surf)\n\n return ax1, ax2\n\n", "_____no_output_____" ], [ "plot_cost()\nplt.show()\n\n", "_____no_output_____" ] ], [ [ "중간 과정의 그래프를 그려 주는 비용 함수를 선언<br>Declare another cost function that will plot intermediate results\n\n", "_____no_output_____" ] ], [ [ "def get_cost_with_plot(a=2, b=1, b_triangle=True):\n\n x0_history = []\n x1_history = []\n c_history = []\n\n def cost_with_plot(x, a=a, b=b):\n '''\n 이런 함수를 클로져 라고 부름. 다른 함수의 내부 함수이면서 해당 함수의 반환값.\n This is a closuer; an internal function being a return value\n '''\n ax1, ax2 = plot_cost()\n\n result = c(x)\n\n x0_history.append(x[0])\n x1_history.append(x[1])\n c_history.append(result)\n\n ax1.plot(x0_history, x1_history, '.')\n ax2.plot(x0_history, x1_history, c_history, '.')\n\n if b_triangle and (3 <= len(x0_history)):\n ax1.plot(\n x0_history[-3:]+[x0_history[-3]],\n x1_history[-3:]+[x1_history[-3]],\n '-'\n )\n ax2.plot(\n x0_history[-3:]+[x0_history[-3]],\n x1_history[-3:]+[x1_history[-3]],\n c_history[-3:]+[c_history[-3]],\n '-'\n )\n\n plt.show()\n\n return result\n\n return cost_with_plot\n\n", "_____no_output_____" ], [ "cost_with_plot = get_cost_with_plot()\n\n", "_____no_output_____" ] ], [ [ "### Nelder-Mead 법\nref : [[0]](https://en.wikipedia.org/wiki/Nelder-Mead_method)<br>\nNelder-Mead 법은 비용함수의 독립변수가 $n$ 차원인 경우, $n+1$ 개의 점으로 이루어진 **simplex**를 이용한다.<br>\nIf the independend variables of the cost function is $n$-dimensional, the Nelder-Mead method uses a **simplex** of $n+1$ vertices.\n\n", "_____no_output_____" ] ], [ [ "fmin_result = so.fmin(cost_with_plot, [3.0, 1.0])\n\n", "_____no_output_____" ], [ "fmin_result\n\n", "_____no_output_____" ] ], [ [ "### Newton-CG 법\n비용함수를 각각 $x_0$, $x_1$에 대해 편미분 해 보자.<br>Let's get the partial derivatives of the cost function over $x_0$ and $x_1$.\n$$\nC(x_0, x_1) = \\frac{x_0^2}{2^2} + \\frac{x_1^2}{1^2} \\\\\n\\frac{\\partial C}{\\partial x_0} = 2 \\cdot \\frac{x_0}{2^2} \\\\\n\\frac{\\partial C}{\\partial x_1} = 2 \\cdot \\frac{x_1}{1^2}\n$$\n파이썬으로는 다음과 같이 구현할 수 있을 것이다.<br>One may implement in python as follows.\n\n", "_____no_output_____" ] ], [ [ "def jacobian(x, a=2, b=1):\n x0 = x[0]\n x1 = x[1]\n return (2 * x0 / (a*a), 2 * x1 / (b*b),)\n\n", "_____no_output_____" ] ], [ [ "최적화에도 기울기를 사용할 수 있다.<br>We can also use the slopes in the optimization.\n\n", "_____no_output_____" ] ], [ [ "cost_with_plot = get_cost_with_plot(b_triangle=False)\n\n", "_____no_output_____" ], [ "fmin_newton = so.minimize(cost_with_plot, [3.0, 1.0], jac=jacobian, method=\"newton-cg\")\n\n", "_____no_output_____" ], [ "fmin_newton\n\n", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# for use in tutorial and development; do not include this `sys.path` change in production:\nimport sys ; sys.path.insert(0, \"../\")", "_____no_output_____" ] ], [ [ "# Build a medium size KG from a CSV dataset", "_____no_output_____" ], [ "First let's initialize the KG object as we did previously:", "_____no_output_____" ] ], [ [ "import kglab\n\nnamespaces = {\n \"wtm\": \"http://purl.org/heals/food/\",\n \"ind\": \"http://purl.org/heals/ingredient/\",\n \"skos\": \"http://www.w3.org/2004/02/skos/core#\",\n }\n\nkg = kglab.KnowledgeGraph(\n name = \"A recipe KG example based on Food.com\",\n base_uri = \"https://www.food.com/recipe/\",\n namespaces = namespaces,\n )", "_____no_output_____" ] ], [ [ "Here's a way to describe the namespaces that are available to use:", "_____no_output_____" ] ], [ [ "kg.describe_ns()", "_____no_output_____" ] ], [ [ "Next, we'll define a dictionary that maps (somewhat magically) from strings (i.e., \"labels\") to ingredients defined in the <http://purl.org/heals/ingredient/> vocabulary:", "_____no_output_____" ] ], [ [ "common_ingredient = {\n \"water\": kg.get_ns(\"ind\").Water,\n \"salt\": kg.get_ns(\"ind\").Salt,\n \"pepper\": kg.get_ns(\"ind\").BlackPepper,\n \"black pepper\": kg.get_ns(\"ind\").BlackPepper,\n \"dried basil\": kg.get_ns(\"ind\").Basil,\n\n \"butter\": kg.get_ns(\"ind\").Butter,\n \"milk\": kg.get_ns(\"ind\").CowMilk,\n \"egg\": kg.get_ns(\"ind\").ChickenEgg,\n \"eggs\": kg.get_ns(\"ind\").ChickenEgg,\n \"bacon\": kg.get_ns(\"ind\").Bacon,\n\n \"sugar\": kg.get_ns(\"ind\").WhiteSugar,\n \"brown sugar\": kg.get_ns(\"ind\").BrownSugar,\n \"honey\": kg.get_ns(\"ind\").Honey,\n \"vanilla\": kg.get_ns(\"ind\").VanillaExtract,\n \"vanilla extract\": kg.get_ns(\"ind\").VanillaExtract,\n\n \"flour\": kg.get_ns(\"ind\").AllPurposeFlour,\n \"all-purpose flour\": kg.get_ns(\"ind\").AllPurposeFlour,\n \"whole wheat flour\": kg.get_ns(\"ind\").WholeWheatFlour,\n\n \"olive oil\": kg.get_ns(\"ind\").OliveOil,\n \"vinegar\": kg.get_ns(\"ind\").AppleCiderVinegar,\n\n \"garlic\": kg.get_ns(\"ind\").Garlic,\n \"garlic clove\": kg.get_ns(\"ind\").Garlic,\n \"garlic cloves\": kg.get_ns(\"ind\").Garlic,\n\n \"onion\": kg.get_ns(\"ind\").Onion,\n \"onions\": kg.get_ns(\"ind\").Onion,\n \"cabbage\": kg.get_ns(\"ind\").Cabbage,\n \"carrot\": kg.get_ns(\"ind\").Carrot,\n \"carrots\": kg.get_ns(\"ind\").Carrot,\n \"celery\": kg.get_ns(\"ind\").Celery,\n \"potato\": kg.get_ns(\"ind\").Potato,\n \"potatoes\": kg.get_ns(\"ind\").Potato,\n \"tomato\": kg.get_ns(\"ind\").Tomato,\n \"tomatoes\": kg.get_ns(\"ind\").Tomato,\n \n \"baking powder\": kg.get_ns(\"ind\").BakingPowder,\n \"baking soda\": kg.get_ns(\"ind\").BakingSoda,\n}", "_____no_output_____" ] ], [ [ "This is where use of NLP work to produce *annotations* begins to overlap with KG pratices.", "_____no_output_____" ], [ "Now let's load our dataset of recipes – the `dat/recipes.csv` file in CSV format – into a `pandas` dataframe:", "_____no_output_____" ] ], [ [ "import pandas as pd\n\ndf = pd.read_csv(\"../dat/recipes.csv\")\ndf.head()", "_____no_output_____" ] ], [ [ "Then iterate over the rows in the dataframe, representing a recipe in the KG for each row:", "_____no_output_____" ] ], [ [ "import rdflib\n\nfor index, row in df.iterrows():\n recipe_id = row[\"id\"]\n node = rdflib.URIRef(\"https://www.food.com/recipe/{}\".format(recipe_id))\n kg.add(node, kg.get_ns(\"rdf\").type, kg.get_ns(\"wtm\").Recipe)\n\n recipe_name = row[\"name\"]\n kg.add(node, kg.get_ns(\"skos\").definition, rdflib.Literal(recipe_name))\n \n cook_time = row[\"minutes\"]\n cook_time_literal = \"PT{}M\".format(int(cook_time))\n code_time_node = rdflib.Literal(cook_time_literal, datatype=kg.get_ns(\"xsd\").duration)\n kg.add(node, kg.get_ns(\"wtm\").hasCookTime, code_time_node)\n \n ind_list = eval(row[\"ingredients\"])\n\n for ind in ind_list:\n ingredient = ind.strip()\n ingredient_obj = common_ingredient[ingredient]\n kg.add(node, kg.get_ns(\"wtm\").hasIngredient, ingredient_obj)", "_____no_output_____" ] ], [ [ "Notice how the `xsd:duration` literal is now getting used to represent cooking times.\n\nWe've structured this example such that each of the recipes in the CSV file has a known representation for all of its ingredients.\nThere are nearly 250K recipes in the full dataset from <https://food.com/> so the `common_ingredient` dictionary would need to be extended quite a lot to handle all of those possible ingredients.", "_____no_output_____" ], [ "At this stage, our graph has grown by a couple orders of magnitude, so its visualization should be more interesting now.\nLet's take a look:", "_____no_output_____" ] ], [ [ "VIS_STYLE = {\n \"wtm\": {\n \"color\": \"orange\",\n \"size\": 20,\n },\n \"ind\":{\n \"color\": \"blue\",\n \"size\": 35,\n },\n}\n\nsubgraph = kglab.SubgraphTensor(kg)\npyvis_graph = subgraph.build_pyvis_graph(notebook=True, style=VIS_STYLE)\n\npyvis_graph.force_atlas_2based()\npyvis_graph.show(\"tmp.fig01.html\")", "_____no_output_____" ] ], [ [ "Given the defaults for this kind of visualization, there's likely a dense center mass of orange (recipes) at the center, with a close cluster of common ingredients (dark blue), surrounded by less common ingredients and cooking times (light blue).", "_____no_output_____" ], [ "## Performance analysis of serialization methods", "_____no_output_____" ], [ "Let's serialize this recipe KG constructed from the CSV dataset to a local TTL file, while measuring the time and disk space required:", "_____no_output_____" ] ], [ [ "import time\n\nwrite_times = []\n\nt0 = time.time()\nkg.save_rdf(\"tmp.ttl\")\nwrite_times.append(round((time.time() - t0) * 1000.0, 2))", "_____no_output_____" ] ], [ [ "Let's also serialize the KG into the other formats that we've been using, to compare relative sizes for a medium size KG:", "_____no_output_____" ] ], [ [ "t0 = time.time()\nkg.save_rdf(\"tmp.xml\", format=\"xml\")\nwrite_times.append(round((time.time() - t0) * 1000.0, 2))\n\nt0 = time.time()\nkg.save_jsonld(\"tmp.jsonld\")\nwrite_times.append(round((time.time() - t0) * 1000.0, 2))\n\nt0 = time.time()\nkg.save_parquet(\"tmp.parquet\")\nwrite_times.append(round((time.time() - t0) * 1000.0, 2))", "_____no_output_____" ], [ "import pandas as pd\nimport os\n\nfile_paths = [\"tmp.ttl\", \"tmp.xml\", \"tmp.jsonld\", \"tmp.parquet\"]\nfile_sizes = [os.path.getsize(file_path) for file_path in file_paths]\n\ndf = pd.DataFrame({\"file_path\": file_paths, \"file_size\": file_sizes, \"write_time\": write_times})\ndf[\"ms_per_byte\"] = df[\"write_time\"] / df[\"file_size\"]\ndf", "_____no_output_____" ] ], [ [ "Notice the relative sizes and times?\n[Parquet](https://parquet.apache.org/) provides for compression in a way that works well with RDF.\nThe same KG stored as a Parquet file is ~10% the size of the same KG stored as JSON-LD.\nAlso the XML version is quite large.\n\nLooking at the write times, Parquet is relatively fast (after its first invocation) and its reads are faster.\nThe eponymous Turtle format is human-readable although relatively slow.\nXML is fast to write, but much larger on disk and difficult to read.\nJSON-LD is interesting in that any JSON library can read and use these files, without needing semantic technologies, *per se*; however, it's also large on disk.", "_____no_output_____" ], [ "---\n\n## Exercises", "_____no_output_____" ], [ "**Exercise 1:**\n\nSelect another ingredient in the <http://purl.org/heals/ingredient/> vocabulary that is not in the `common_ingredient` dictionary, for which you can find at least one simple recipe within <https://food.com/> searches.\nThen add this recipe into the KG.", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown", "markdown" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "import pandas as pd\nimport numpy as np", "_____no_output_____" ], [ "#Scraping the Values from the Wikipedia change\nurl = 'https://en.wikipedia.org/wiki/List_of_postal_codes_of_Canada:_M'\ndfs = pd.read_html(url)\npc = dfs[0]", "_____no_output_____" ], [ "#Removing Not Assigned Boroughs\npost_codes = pc.loc[(pc.Borough != 'Not assigned')]\n\n#Updating Column Names\npost_codes.columns = ['PostalCode', 'Borough', 'Neighbourhood']\n\n#Defaulting Nos assigned Neighbourhood to Borough Values\npost_codes.Neighbourhood = np.where(post_codes.Neighbourhood == 'Not assigned', post_codes.Borough, post_codes.Neighbourhood)\n\n#Skipping the step to merger post code records, as this case is no longer present in the source data \npost_codes.shape", "_____no_output_____" ], [ "#Loading from local file, had issues with the Geocode API\nlonglat = pd.read_csv('./Geospatial_Coordinates.csv')\nlonglat.columns = ['PostalCode', 'Latitude', 'Logitude']", "_____no_output_____" ], [ "longlat.head", "_____no_output_____" ], [ "#Merging the post code and positional data\npost_code_long_lat = post_codes.merge(longlat, on='PostalCode', how='inner')\n\npost_code_long_lat.head", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "#!/usr/bin/env python3\nimport pandas as pd\nimport lz4.frame\nimport gzip\nimport io\nimport pyarrow.parquet as pq\nimport pyarrow as pa\nimport numpy as np\nfrom glob import glob\nfrom plumbum.cmd import rm\nfrom keras.layers.core import Dense, Activation, Dropout\nfrom keras.layers.recurrent import LSTM\nfrom keras.layers import TimeDistributed\nfrom keras.models import Sequential\nfrom keras import regularizers\nfrom sklearn.preprocessing import MinMaxScaler\nfrom sklearn.metrics import mean_squared_error\nimport matplotlib.pyplot as plt", "/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/matplotlib/__init__.py:962: UserWarning: Duplicate key in file \"/home/ubuntu/.config/matplotlib/matplotlibrc\", line #2\n (fname, cnt))\n/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/matplotlib/__init__.py:962: UserWarning: Duplicate key in file \"/home/ubuntu/.config/matplotlib/matplotlibrc\", line #3\n (fname, cnt))\n/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n from ._conv import register_converters as _register_converters\nUsing TensorFlow backend.\n" ], [ "def plotline(data):\n plt.figure()\n plt.plot(data)\n plt.legend()\n plt.show()\n\ndef event_count(time_series, data_name):\n time_series = time_series[['Fill Price (USD)']].values\n upevents = 0\n downevents = 0\n sameprice = 0\n prev_obv = time_series[0]\n for obv in time_series[1:]:\n if obv > prev_obv:\n upevents += 1\n elif obv < prev_obv:\n downevents += 1\n elif obv == prev_obv:\n sameprice += 1\n prev_obv = obv\n print('=== Event counts on %s ===' % data_name)\n print('upevents')\n print(upevents)\n print('downevents')\n print(downevents)\n print('sameprice')\n print(sameprice)\n print()\n\ndef mse(time_series, data_name):\n time_series = time_series[['Fill Price (USD)']].values\n total_squared_error = 0\n total_absolute_error = 0\n prev_obv = time_series[0]\n for obv in time_series[1:]:\n total_squared_error += (obv - prev_obv)**2\n total_absolute_error += abs(obv - prev_obv)\n prev_obv = obv\n num_predictions = len(time_series) - 1\n mean_squared_error = total_squared_error / num_predictions\n mean_absolute_error = total_absolute_error / num_predictions\n root_mean_squared_error = np.sqrt(mean_squared_error)\n print('=== baseline on %s ===' % data_name)\n print('total squared error')\n print(total_squared_error)\n print('total absolute error')\n print(total_absolute_error)\n print('mean squared error')\n print(mean_squared_error)\n print('mean absolute error')\n print(mean_absolute_error) \n print('root mean squared error')\n print(root_mean_squared_error) \n print()", "_____no_output_____" ], [ "def show_summary_statistics():\n #event_count(small_set, 'small')\n train_set = df.iloc[0:num_samples_training]\n dev_set = df.iloc[num_samples_training:num_samples_training+num_samples_dev]\n test_set = df.iloc[num_samples_training+num_samples_dev:]\n event_count(train_set, 'train')\n event_count(dev_set, 'dev')\n event_count(test_set, 'test')\n mse(train_set, 'train')\n mse(dev_set, 'dev')\n mse(test_set, 'test')\n#show_summary_statistics()", "_____no_output_____" ], [ "def preprocess(data):\n values = np.array(data)\n values = values.reshape(-1,1)\n values = values.astype('float32') \n return values", "_____no_output_____" ], [ "def plot_losses(model_history, title):\n plt.figure()\n plt.plot(model_history.history['loss'], label='Train')\n plt.plot(model_history.history['val_loss'], label='Dev')\n plt.xlabel('Epochs'); plt.ylabel('Loss (mse)')\n plt.title(title)\n plt.legend(); plt.show()", "_____no_output_____" ], [ "def inverse_transform_pricescaler(data, Y_prevrawprice, fitted_scaler):\n return fitted_scaler.inverse_transform(preprocess(data))\n\ndef inverse_transform_percentdiff(data, Y_prevrawprice, fitted_scaler=None):\n orig_prices = Y_prevrawprice\n change = orig_prices * data\n return orig_prices + change\n #return fitted_scaler.inverse_transform(preprocess(data))\n\n#print(Y_test_prevrawprice)\n#print(inverse_transform_percentdiff(Y_test, Y_test_prevrawprice))\n\ninverse_transform = inverse_transform_percentdiff", "_____no_output_____" ], [ "def plot_predictions(model, X_test, Y_test, Y_prevrawprice, title, inverse=False, scaler=None):\n y_hat = model.predict(X_test)\n\n if inverse:\n y_hat = inverse_transform(y_hat, Y_prevrawprice, scaler)\n Y_test = inverse_transform(Y_test, Y_prevrawprice, scaler)\n\n plt.plot(y_hat, label='Predicted')\n plt.plot(Y_test, label='True')\n plt.xlabel('Time'); \n\n if inverse:\n plt.ylabel('Price')\n else:\n plt.ylabel('RESCALED Price')\n\n plt.title(title)\n plt.legend(); plt.show()", "_____no_output_____" ], [ "def calculate_MSE_RMSE(model, scaler, X_test, Y_test, Y_prevrawprice, model_name):\n y_hat = model.predict(X_test)\n y_hat_inverse = inverse_transform(y_hat, Y_prevrawprice, scaler)\n Y_test_inverse = inverse_transform(Y_test, Y_prevrawprice, scaler)\n mse = mean_squared_error(Y_test_inverse, y_hat_inverse)\n rmse = np.sqrt(mean_squared_error(Y_test_inverse, y_hat_inverse))\n print('%s:' % model_name)\n print('Test MSE: %.3f' % mse)\n print('Test RMSE: %.3f' % rmse)\n print()", "_____no_output_____" ], [ "def train_evaluate(model, model_name, \n X_train, Y_train, Y_train_prevrawprice, X_dev, Y_dev, Y_dev_prevrawprice, X_test, Y_test, Y_test_prevrawprice,\n lag=10, batch_size=100, epochs=10, verbose=1):\n\n # Train model\n history = model.fit(X_train, Y_train, batch_size=batch_size, epochs=epochs,\n validation_split=0.05, verbose=verbose, shuffle=False)\n #train_evaluate_showresults(history, model, model_name, \n # X_train, Y_train, X_dev, Y_dev, X_test, Y_test,\n # lag, batch_size, epochs, verbose)\n return history", "_____no_output_____" ], [ "def train_evaluate_showresults(history, model, model_name, \n X_train, Y_train, Y_train_prevrawprice, X_dev, Y_dev, Y_dev_prevrawprice, X_test, Y_test, Y_test_prevrawprice,\n lag=10, batch_size=100, epochs=10, verbose=1):\n # Plot losses, predictions, and calculate MSE and RMSE\n plot_losses(history, 'Loss\\n(%s)' % model_name)\n plot_predictions(model, X_dev, Y_dev, Y_dev_prevrawprice, 'Test Predictions\\n(%s)' % model_name)\n plot_predictions(model, X_dev, Y_dev, Y_dev_prevrawprice, 'Test Predictions\\n(%s)' % model_name, inverse=True, scaler=price_scaler)\n calculate_MSE_RMSE(model, price_scaler, X_dev, Y_dev, Y_dev_prevrawprice, '%s' % model_name)", "_____no_output_____" ], [ "def evaluate_test(model, model_name, \n X_train, Y_train, Y_train_prevrawprice, X_dev, Y_dev, Y_dev_prevrawprice, X_test, Y_test, Y_test_prevrawprice,\n lag=10, batch_size=100, epochs=10, verbose=1):\n # Plot losses, predictions, and calculate MSE and RMSE\n #plot_losses(history, 'Loss\\n(%s)' % model_name)\n plot_predictions(model, X_test, Y_test, Y_test_prevrawprice, 'Test Predictions\\n(%s)' % model_name)\n plot_predictions(model, X_test, Y_test, Y_test_prevrawprice, 'Test Predictions\\n(%s)' % model_name, inverse=True, scaler=price_scaler)\n calculate_MSE_RMSE(model, price_scaler, X_test, Y_test, Y_test_prevrawprice, '%s' % model_name)", "_____no_output_____" ], [ "def initialize_model(X_train, loss, optimizer, num_LSTMs, num_units, dropout):\n \n LSTM_input_shape = [X_train.shape[1], X_train.shape[2]]\n print('input shape is')\n print(LSTM_input_shape)\n\n # DEFINE MODEL\n model = Sequential()\n\n if num_LSTMs == 2:\n model.add(LSTM(num_units[0], input_shape=LSTM_input_shape, return_sequences=True))\n model.add(Dropout(dropout))\n\n model.add(LSTM(num_units[1], return_sequences=True))\n \n if num_LSTMs == 3:\n model.add(LSTM(num_units[0], input_shape=LSTM_input_shape, return_sequences=True))\n model.add(Dropout(dropout))\n\n model.add(LSTM(num_units[1], return_sequences=True))\n model.add(Dropout(dropout))\n \n model.add(LSTM(num_units[2], return_sequences=True))\n\n model.add(TimeDistributed(Dense(1)))\n model.add(Activation('linear'))\n\n \n model.compile(loss=loss, optimizer=optimizer)\n \n return model", "_____no_output_____" ], [ "import os.path\n\ndef load_data():\n if not os.path.isfile('cboe/parquet_preprocessed_subset_only_BTCUSD_merged.parquet'):\n files = sorted(glob('cboe/parquet_preprocessed_BTCUSD_merged/*.parquet'))\n all_dataframes = []\n for file in files:\n print(file)\n df = pq.read_table(file).to_pandas()\n all_dataframes.append(df)\n result = pd.concat(all_dataframes)\n pq.write_table(pa.Table.from_pandas(result), 'cboe/parquet_preprocessed_subset_only_BTCUSD_merged.parquet', compression='snappy')\n df = pq.read_table('cboe/parquet_preprocessed_subset_only_BTCUSD_merged.parquet').to_pandas();\n print(df.dtypes)\n print(df.shape)\n return df", "_____no_output_____" ], [ "def split_X(df):\n n_all = df.shape[0]\n n_train = round(n_all * 0.9)\n n_dev = round(n_all * 0.05)\n n_test = round(n_all * 0.05)\n print('n_all: ', n_all)\n print('n_train:', n_train)\n print('n_dev: ', n_dev)\n print('n_test: ', n_test)\n\n X_train = df.iloc[:n_train, 1:16].values.astype('float32')\n X_dev = df.iloc[n_train:n_train+n_dev, 1:16].values.astype('float32')\n X_test = df.iloc[n_train+n_dev:, 1:16].values.astype('float32')\n print(X_train.shape)\n print(X_dev.shape)\n print(X_test.shape)\n\n return X_train, X_dev, X_test", "_____no_output_____" ], [ "def split_Y(df):\n n_all = df.shape[0]\n n_train = round(n_all * 0.9)\n n_dev = round(n_all * 0.05)\n n_test = round(n_all * 0.05)\n Y_train = df.iloc[:n_train, -1:].values.astype('float32')\n Y_dev = df.iloc[n_train:n_train+n_dev, -1:].values.astype('float32')\n Y_test = df.iloc[n_train+n_dev:, -1:].values.astype('float32')\n print(Y_train.shape)\n print(Y_dev.shape)\n print(Y_test.shape)\n \n return Y_train, Y_dev, Y_test", "_____no_output_____" ], [ "def df_to_parquet(df, outfile):\n pq.write_table(pa.Table.from_pandas(df), outfile, compression='snappy')", "_____no_output_____" ], [ "def evaluate_model(model, history, X_train, X_dev, X_test, Y_train, Y_dev, Y_test):\n train_loss = history.history['loss'][-1]\n dev_loss = history.history['val_loss'][-1]\n test_loss = model.evaluate(X_test, Y_test, verbose=0)\n \n y_hat_train = model.predict(X_train)\n y_hat_dev = model.predict(X_dev)\n y_hat_test = model.predict(X_test)\n \n train_prop_correct = np.sum(np.sign(y_hat_train) == np.sign(Y_train)) / (Y_train_final.shape[0] * Y_train_final.shape[1])\n dev_prop_correct = np.sum(np.sign(y_hat_dev) == np.sign(Y_dev)) / (Y_dev_final.shape[0] * Y_dev_final.shape[1])\n test_prop_correct = np.sum(np.sign(y_hat_test) == np.sign(Y_test)) / (Y_test_final.shape[0] * Y_test_final.shape[1])\n \n evaluation = [train_loss, dev_loss, test_loss, train_prop_correct, dev_prop_correct, test_prop_correct]\n return evaluation", "_____no_output_____" ], [ "def create_sequenced_data(data, window, step, y=True):\n sequenced = []\n for minute in range(0, len(data) - window, step):\n chunk = data[minute:minute+window]\n sequenced.append(chunk)\n sequenced = np.array(sequenced)\n return sequenced", "_____no_output_____" ], [ "batch_size = 8192 #16384 #32768 #4096\nepochs = 100\nverbose = 2\nloss = 'mean_squared_error'\noptimizer = 'adagrad' #'adam'\n#num_LSTM = 2\n#n_units = [256, 256]\nnum_LSTM = 3\nn_units = [256, 256, 256]\ndropout = 0.1\n\nmodel = initialize_model(X_train_final, loss, optimizer, num_LSTM, n_units, dropout)\n\nhistory = model.fit(X_train_final, Y_train_final, batch_size=batch_size, epochs=epochs,\n validation_data=(X_dev_final, Y_dev_final), verbose=verbose, shuffle=False) ", "input shape is\n[30, 15]\nTrain on 35264 samples, validate on 1958 samples\nEpoch 1/200\n - 4s - loss: 10.9643 - val_loss: 0.0129\nEpoch 2/200\n - 2s - loss: 0.0088 - val_loss: 0.0063\nEpoch 3/200\n - 2s - loss: 0.0072 - val_loss: 0.0055\nEpoch 4/200\n - 2s - loss: 0.0063 - val_loss: 0.0049\nEpoch 5/200\n - 2s - loss: 0.0056 - val_loss: 0.0044\nEpoch 6/200\n - 2s - loss: 0.0051 - val_loss: 0.0040\nEpoch 7/200\n - 2s - loss: 0.0046 - val_loss: 0.0036\nEpoch 8/200\n - 2s - loss: 0.0042 - val_loss: 0.0033\nEpoch 9/200\n - 2s - loss: 0.0039 - val_loss: 0.0031\nEpoch 10/200\n - 2s - loss: 0.0036 - val_loss: 0.0029\nEpoch 11/200\n - 2s - loss: 0.0034 - val_loss: 0.0027\nEpoch 12/200\n - 2s - loss: 0.0032 - val_loss: 0.0025\nEpoch 13/200\n - 2s - loss: 0.0030 - val_loss: 0.0023\nEpoch 14/200\n - 2s - loss: 0.0028 - val_loss: 0.0022\nEpoch 15/200\n - 2s - loss: 0.0026 - val_loss: 0.0020\nEpoch 16/200\n - 2s - loss: 0.0025 - val_loss: 0.0019\nEpoch 17/200\n - 2s - loss: 0.0024 - val_loss: 0.0018\nEpoch 18/200\n - 2s - loss: 0.0023 - val_loss: 0.0017\nEpoch 19/200\n - 2s - loss: 0.0021 - val_loss: 0.0016\nEpoch 20/200\n - 2s - loss: 0.0020 - val_loss: 0.0016\nEpoch 21/200\n - 2s - loss: 0.0020 - val_loss: 0.0015\nEpoch 22/200\n - 2s - loss: 0.0019 - val_loss: 0.0014\nEpoch 23/200\n - 2s - loss: 0.0018 - val_loss: 0.0013\nEpoch 24/200\n - 2s - loss: 0.0017 - val_loss: 0.0013\nEpoch 25/200\n - 2s - loss: 0.0017 - val_loss: 0.0012\nEpoch 26/200\n - 2s - loss: 0.0016 - val_loss: 0.0012\nEpoch 27/200\n - 2s - loss: 0.0015 - val_loss: 0.0011\nEpoch 28/200\n - 2s - loss: 0.0015 - val_loss: 0.0011\nEpoch 29/200\n - 2s - loss: 0.0014 - val_loss: 0.0010\nEpoch 30/200\n - 2s - loss: 0.0014 - val_loss: 9.9952e-04\nEpoch 31/200\n - 2s - loss: 0.0013 - val_loss: 9.6192e-04\nEpoch 32/200\n - 2s - loss: 0.0013 - val_loss: 9.2679e-04\nEpoch 33/200\n - 2s - loss: 0.0013 - val_loss: 8.9353e-04\nEpoch 34/200\n - 2s - loss: 0.0012 - val_loss: 8.6235e-04\nEpoch 35/200\n - 2s - loss: 0.0012 - val_loss: 8.3256e-04\nEpoch 36/200\n - 2s - loss: 0.0012 - val_loss: 8.0466e-04\nEpoch 37/200\n - 2s - loss: 0.0011 - val_loss: 7.7834e-04\nEpoch 38/200\n - 2s - loss: 0.0011 - val_loss: 7.5309e-04\nEpoch 39/200\n - 2s - loss: 0.0011 - val_loss: 7.2906e-04\nEpoch 40/200\n - 2s - loss: 0.0010 - val_loss: 7.0632e-04\nEpoch 41/200\n - 2s - loss: 0.0010 - val_loss: 6.8486e-04\nEpoch 42/200\n - 2s - loss: 9.8930e-04 - val_loss: 6.6416e-04\nEpoch 43/200\n - 2s - loss: 9.6677e-04 - val_loss: 6.4445e-04\nEpoch 44/200\n - 2s - loss: 9.4354e-04 - val_loss: 6.2587e-04\nEpoch 45/200\n - 2s - loss: 9.2251e-04 - val_loss: 6.0793e-04\nEpoch 46/200\n - 2s - loss: 9.0079e-04 - val_loss: 5.9102e-04\nEpoch 47/200\n - 2s - loss: 8.8291e-04 - val_loss: 5.7466e-04\nEpoch 48/200\n - 2s - loss: 8.6111e-04 - val_loss: 5.5911e-04\nEpoch 49/200\n - 2s - loss: 8.4414e-04 - val_loss: 5.4423e-04\nEpoch 50/200\n - 2s - loss: 8.2643e-04 - val_loss: 5.2992e-04\nEpoch 51/200\n - 2s - loss: 8.0776e-04 - val_loss: 5.1618e-04\nEpoch 52/200\n - 2s - loss: 7.9379e-04 - val_loss: 5.0307e-04\nEpoch 53/200\n - 2s - loss: 7.7774e-04 - val_loss: 4.9054e-04\nEpoch 54/200\n - 2s - loss: 7.6358e-04 - val_loss: 4.7851e-04\nEpoch 55/200\n - 2s - loss: 7.4859e-04 - val_loss: 4.6688e-04\nEpoch 56/200\n - 2s - loss: 7.3544e-04 - val_loss: 4.5585e-04\nEpoch 57/200\n - 2s - loss: 7.2261e-04 - val_loss: 4.4501e-04\nEpoch 58/200\n - 2s - loss: 7.1029e-04 - val_loss: 4.3474e-04\nEpoch 59/200\n - 2s - loss: 6.9662e-04 - val_loss: 4.2481e-04\nEpoch 60/200\n - 2s - loss: 6.8573e-04 - val_loss: 4.1528e-04\nEpoch 61/200\n - 2s - loss: 6.7265e-04 - val_loss: 4.0622e-04\nEpoch 62/200\n - 2s - loss: 6.6380e-04 - val_loss: 3.9728e-04\nEpoch 63/200\n - 2s - loss: 6.5129e-04 - val_loss: 3.8873e-04\nEpoch 64/200\n - 2s - loss: 6.4071e-04 - val_loss: 3.8057e-04\nEpoch 65/200\n - 2s - loss: 6.3138e-04 - val_loss: 3.7264e-04\nEpoch 66/200\n - 2s - loss: 6.2177e-04 - val_loss: 3.6503e-04\nEpoch 67/200\n - 2s - loss: 6.1285e-04 - val_loss: 3.5762e-04\nEpoch 68/200\n - 2s - loss: 6.0125e-04 - val_loss: 3.5065e-04\nEpoch 69/200\n - 2s - loss: 5.9412e-04 - val_loss: 3.4368e-04\nEpoch 70/200\n - 2s - loss: 5.8569e-04 - val_loss: 3.3686e-04\nEpoch 71/200\n - 2s - loss: 5.7761e-04 - val_loss: 3.3043e-04\nEpoch 72/200\n - 2s - loss: 5.6914e-04 - val_loss: 3.2425e-04\nEpoch 73/200\n - 2s - loss: 5.6240e-04 - val_loss: 3.1823e-04\nEpoch 74/200\n - 2s - loss: 5.5471e-04 - val_loss: 3.1247e-04\nEpoch 75/200\n - 2s - loss: 5.4737e-04 - val_loss: 3.0677e-04\nEpoch 76/200\n - 2s - loss: 5.3940e-04 - val_loss: 3.0133e-04\nEpoch 77/200\n - 2s - loss: 5.3261e-04 - val_loss: 2.9621e-04\nEpoch 78/200\n - 2s - loss: 5.2577e-04 - val_loss: 2.9096e-04\nEpoch 79/200\n - 2s - loss: 5.2029e-04 - val_loss: 2.8608e-04\nEpoch 80/200\n - 2s - loss: 5.1361e-04 - val_loss: 2.8129e-04\nEpoch 81/200\n - 2s - loss: 5.0846e-04 - val_loss: 2.7661e-04\nEpoch 82/200\n - 2s - loss: 5.0160e-04 - val_loss: 2.7211e-04\nEpoch 83/200\n - 2s - loss: 4.9636e-04 - val_loss: 2.6769e-04\nEpoch 84/200\n - 2s - loss: 4.9059e-04 - val_loss: 2.6358e-04\nEpoch 85/200\n - 2s - loss: 4.8425e-04 - val_loss: 2.5929e-04\nEpoch 86/200\n - 2s - loss: 4.8051e-04 - val_loss: 2.5532e-04\nEpoch 87/200\n - 2s - loss: 4.7417e-04 - val_loss: 2.5135e-04\nEpoch 88/200\n - 2s - loss: 4.6836e-04 - val_loss: 2.4772e-04\nEpoch 89/200\n - 2s - loss: 4.6455e-04 - val_loss: 2.4393e-04\nEpoch 90/200\n - 2s - loss: 4.5965e-04 - val_loss: 2.4044e-04\nEpoch 91/200\n - 2s - loss: 4.5454e-04 - val_loss: 2.3703e-04\nEpoch 92/200\n - 2s - loss: 4.4997e-04 - val_loss: 2.3355e-04\nEpoch 93/200\n - 2s - loss: 4.4598e-04 - val_loss: 2.3041e-04\nEpoch 94/200\n - 2s - loss: 4.4064e-04 - val_loss: 2.2722e-04\nEpoch 95/200\n - 2s - loss: 4.3740e-04 - val_loss: 2.2413e-04\nEpoch 96/200\n - 2s - loss: 4.3303e-04 - val_loss: 2.2119e-04\nEpoch 97/200\n - 2s - loss: 4.2972e-04 - val_loss: 2.1834e-04\nEpoch 98/200\n - 2s - loss: 4.2530e-04 - val_loss: 2.1537e-04\nEpoch 99/200\n - 2s - loss: 4.2100e-04 - val_loss: 2.1267e-04\nEpoch 100/200\n - 2s - loss: 4.1785e-04 - val_loss: 2.0980e-04\nEpoch 101/200\n - 2s - loss: 4.1316e-04 - val_loss: 2.0728e-04\nEpoch 102/200\n - 2s - loss: 4.0985e-04 - val_loss: 2.0470e-04\nEpoch 103/200\n - 2s - loss: 4.0717e-04 - val_loss: 2.0218e-04\nEpoch 104/200\n - 2s - loss: 4.0238e-04 - val_loss: 1.9977e-04\nEpoch 105/200\n - 2s - loss: 3.9979e-04 - val_loss: 1.9730e-04\nEpoch 106/200\n - 2s - loss: 3.9662e-04 - val_loss: 1.9500e-04\nEpoch 107/200\n - 2s - loss: 3.9347e-04 - val_loss: 1.9277e-04\nEpoch 108/200\n - 2s - loss: 3.9002e-04 - val_loss: 1.9063e-04\nEpoch 109/200\n - 2s - loss: 3.8662e-04 - val_loss: 1.8858e-04\nEpoch 110/200\n - 2s - loss: 3.8514e-04 - val_loss: 1.8631e-04\nEpoch 111/200\n - 2s - loss: 3.8223e-04 - val_loss: 1.8428e-04\nEpoch 112/200\n - 2s - loss: 3.7782e-04 - val_loss: 1.8223e-04\nEpoch 113/200\n - 2s - loss: 3.7592e-04 - val_loss: 1.8041e-04\nEpoch 114/200\n - 2s - loss: 3.7269e-04 - val_loss: 1.7853e-04\nEpoch 115/200\n - 2s - loss: 3.7074e-04 - val_loss: 1.7648e-04\nEpoch 116/200\n - 2s - loss: 3.6691e-04 - val_loss: 1.7489e-04\nEpoch 117/200\n - 2s - loss: 3.6295e-04 - val_loss: 1.7311e-04\nEpoch 118/200\n - 2s - loss: 3.6174e-04 - val_loss: 1.7127e-04\nEpoch 119/200\n - 2s - loss: 3.5955e-04 - val_loss: 1.6955e-04\nEpoch 120/200\n - 2s - loss: 3.5755e-04 - val_loss: 1.6803e-04\nEpoch 121/200\n - 2s - loss: 3.5408e-04 - val_loss: 1.6626e-04\nEpoch 122/200\n - 2s - loss: 3.5216e-04 - val_loss: 1.6458e-04\nEpoch 123/200\n - 2s - loss: 3.5050e-04 - val_loss: 1.6309e-04\nEpoch 124/200\n - 2s - loss: 3.4688e-04 - val_loss: 1.6165e-04\nEpoch 125/200\n - 2s - loss: 3.4492e-04 - val_loss: 1.6023e-04\nEpoch 126/200\n - 2s - loss: 3.4258e-04 - val_loss: 1.5873e-04\nEpoch 127/200\n - 2s - loss: 3.4069e-04 - val_loss: 1.5728e-04\nEpoch 128/200\n - 2s - loss: 3.3946e-04 - val_loss: 1.5587e-04\nEpoch 129/200\n - 2s - loss: 3.3669e-04 - val_loss: 1.5457e-04\nEpoch 130/200\n - 2s - loss: 3.3425e-04 - val_loss: 1.5326e-04\nEpoch 131/200\n - 2s - loss: 3.3309e-04 - val_loss: 1.5191e-04\nEpoch 132/200\n - 2s - loss: 3.3096e-04 - val_loss: 1.5083e-04\nEpoch 133/200\n - 2s - loss: 3.2909e-04 - val_loss: 1.4949e-04\nEpoch 134/200\n - 2s - loss: 3.2612e-04 - val_loss: 1.4816e-04\nEpoch 135/200\n - 2s - loss: 3.2492e-04 - val_loss: 1.4705e-04\nEpoch 136/200\n - 2s - loss: 3.2387e-04 - val_loss: 1.4586e-04\nEpoch 137/200\n - 2s - loss: 3.2065e-04 - val_loss: 1.4473e-04\nEpoch 138/200\n" ], [ "a = evaluate_model(model, history, X_train_final, X_dev_final, X_test_final, Y_train_final, Y_dev_final, Y_test_final)", "_____no_output_____" ], [ "# Concatenate dataframes\nfiles = sorted(glob('cboe/parquet_preprocessed_BTCUSD_merged/*.parquet'))[451:]\nall_dataframes = []\nfor file in files:\n df = pq.read_table(file).to_pandas()\n all_dataframes.append(df)\ndf = pd.concat(all_dataframes)\n\n#\nX_train, X_dev, X_test = split_X(df)\nY_train, Y_dev, Y_test = split_Y(df)\n\nwindow_size = 30\nstep = 30\n\nX_train = create_sequenced_data(X_train, window=window_size, step=step, y=False)\nX_dev = create_sequenced_data(X_dev, window=window_size, step=step, y=False)\nX_test = create_sequenced_data(X_test, window=window_size, step=step, y=False)\n\nY_train = create_sequenced_data(Y_train, window=window_size, step=step, y=True)\nY_dev = create_sequenced_data(Y_dev, window=window_size, step=step, y=True)\nY_test = create_sequenced_data(Y_test, window=window_size, step=step, y=True)\n\nprint('Train, dev, test shapes:')\nprint(X_train_final.shape)\nprint(X_dev_final.shape)\nprint(X_test_final.shape)\nprint(Y_train_final.shape)\nprint(Y_dev_final.shape)\nprint(Y_test_final.shape)", "n_all: 587753\nn_train: 528978\nn_dev: 29388\nn_test: 29388\n(528978, 15)\n(29388, 15)\n(29387, 15)\n(528978, 1)\n(29388, 1)\n(29387, 1)\nTrain, dev, test shapes:\n(17632, 30, 15)\n(979, 30, 15)\n(979, 30, 15)\n(17632, 30, 1)\n(979, 30, 1)\n(979, 30, 1)\n" ], [ "# Initialize output dataframe\noutfile = 'cboe/grid_search.parquet'\ncolumns = ['num_epochs', 'loss', 'optimizer', 'batch_size', 'num_LSTMs', 'num_units',\n 'train_loss', 'dev_loss', 'test_loss', 'train_prop_correct', 'dev_prop_correct', 'test_prop_correct']\ndf_output = pd.DataFrame(columns=columns)\npq.write_table(pa.Table.from_pandas(df_output), outfile, compression='snappy')", "_____no_output_____" ], [ "batch_size = 8192\nnum_epochs = 100\nverbose = 1\nloss = 'mean_squared_error'\noptimizers = ['adagrad', 'adam', 'rmsprop']\nnum_LSTMs = [2,3]\nnum_units_2 = [[128, 256], [256, 256]]\nnum_units_3 = [[128, 256, 256], [256, 256, 256], [256, 512, 512]]\ndropout = 0.1\n\ncount = 0\nfor optimizer in optimizers:\n for num_LSTM in num_LSTMs:\n if num_LSTM == 2:\n num_units = num_units_2\n elif num_LSTM == 3:\n num_units = num_units_3\n for n_units in num_units:\n # Load output dataframe\n df_output = pq.read_table(outfile).to_pandas()\n\n # Initialize model\n model = initialize_model(X_train, loss, optimizer, num_LSTM, n_units, dropout)\n\n # Train model\n if verbose:\n verbose=1\n print(count, '/', 15)\n else:\n verbose=0\n history = model.fit(X_train, Y_train, batch_size=batch_size, epochs=num_epochs,\n validation_data=(X_dev, Y_dev), verbose=0, shuffle=False) \n\n # Evaluate model\n evaluate = evaluate_model(model, history, X_train, X_dev, X_test, Y_train, Y_dev, Y_test)\n\n # Write to dataframe and save\n row = [num_epochs, loss, optimizer, batch_size, num_LSTM, str(n_units)]\n row.extend(evaluate)\n df_output.loc[len(df_output)] = row\n df_to_parquet(df_output, outfile)\n\n count += 1", "input shape is\n[30, 15]\n0 / 15\ninput shape is\n[30, 15]\n1 / 15\ninput shape is\n[30, 15]\n2 / 15\ninput shape is\n[30, 15]\n3 / 15\ninput shape is\n[30, 15]\n4 / 15\n" ], [ "y_hat_train = model.predict(X_train)\ny_hat_dev = model.predict(X_dev)\ny_hat_test = model.predict(X_test)\n\ntrain_prop_correct = np.sum(np.sign(y_hat_train) == np.sign(Y_train)) / (Y_train.shape[0] * Y_train.shape[1])\ndev_prop_correct = np.sum(np.sign(y_hat_dev) == np.sign(Y_dev)) / (Y_dev.shape[0] * Y_dev.shape[1])\ntest_prop_correct = np.sum(np.sign(y_hat_test) == np.sign(Y_test)) / (Y_test.shape[0] * Y_test.shape[1])", "_____no_output_____" ], [ "y_hat_test = model.predict(X_test)", "_____no_output_____" ], [ "a = np.sign(y_hat_test) == np.sign(Y_test)", "_____no_output_____" ], [ "np.sign(Y_test).shape", "_____no_output_____" ], [ "last = []\nfor i in range(len(a)):\n last.append(a[i][-1])", "_____no_output_____" ], [ "np.sum(last) / 979", "_____no_output_____" ], [ "np.sum(a) / (979*30)", "_____no_output_____" ], [ "np.sum(np.sign(Y_test)==1)", "_____no_output_____" ], [ "13615 / (979*30)", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "https://colab.research.google.com/drive/1OmAdxU_Lw7r-tMXiTOeSI7NWgB3AF9QF", "_____no_output_____" ], [ "# Issue with image translation", "_____no_output_____" ] ], [ [ "from keras.datasets import mnist\nimport numpy\nfrom keras.datasets import mnist\nfrom keras.models import Sequential\nfrom keras.layers import Dense\nfrom keras.layers import Dropout\nfrom keras.utils import np_utils", "Using TensorFlow backend.\n" ], [ "import matplotlib.pyplot as plt\n%matplotlib inline\n(X_train, y_train), (X_test, y_test) = mnist.load_data()", "Downloading data from https://s3.amazonaws.com/img-datasets/mnist.npz\n11493376/11490434 [==============================] - 1s 0us/step\n" ], [ "X_train1 = X_train[y_train==1]", "_____no_output_____" ], [ "num_pixels = X_train.shape[1] * X_train.shape[2]\nX_train = X_train.reshape(X_train.shape[0],num_pixels).astype('float32')\nX_test = X_test.reshape(X_test.shape[0],num_pixels).astype('float32')\nX_train = X_train / 255\nX_test = X_test / 255", "_____no_output_____" ], [ "y_train = np_utils.to_categorical(y_train)\ny_test = np_utils.to_categorical(y_test)\nnum_classes = y_train.shape[1]", "_____no_output_____" ], [ "model = Sequential()\nmodel.add(Dense(1000, input_dim=num_pixels, activation='relu'))\nmodel.add(Dense(num_classes, activation='softmax'))\nmodel.compile(loss='categorical_crossentropy', optimizer='adam',metrics=['accuracy'])\nhistory = model.fit(X_train, y_train, validation_data=(X_test, y_test),epochs=5, batch_size=1024, verbose=1)", "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:66: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:541: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:4432: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/optimizers.py:793: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:3576: The name tf.log is deprecated. Please use tf.math.log instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/math_grad.py:1250: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\nInstructions for updating:\nUse tf.where in 2.0, which has the same broadcast rule as np.where\nWARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:1033: The name tf.assign_add is deprecated. Please use tf.compat.v1.assign_add instead.\n\nTrain on 60000 samples, validate on 10000 samples\nEpoch 1/5\n60000/60000 [==============================] - 5s 78us/step - loss: 0.4730 - acc: 0.8733 - val_loss: 0.2302 - val_acc: 0.9334\nEpoch 2/5\n60000/60000 [==============================] - 1s 10us/step - loss: 0.1954 - acc: 0.9451 - val_loss: 0.1620 - val_acc: 0.9531\nEpoch 3/5\n60000/60000 [==============================] - 1s 10us/step - loss: 0.1387 - acc: 0.9614 - val_loss: 0.1261 - val_acc: 0.9635\nEpoch 4/5\n60000/60000 [==============================] - 1s 10us/step - loss: 0.1056 - acc: 0.9706 - val_loss: 0.1057 - val_acc: 0.9685\nEpoch 5/5\n60000/60000 [==============================] - 1s 10us/step - loss: 0.0838 - acc: 0.9770 - val_loss: 0.0971 - val_acc: 0.9711\n" ], [ "import numpy as np\npic=np.zeros((28,28))\npic2=np.copy(pic)\nfor i in range(X_train1.shape[0]):\n pic2=X_train1[i,:,:]\n pic=pic+pic2\npic=(pic/X_train1.shape[0])\nplt.imshow(pic)", "_____no_output_____" ], [ "for i in range(pic.shape[0]):\n if i<20:\n pic[:,i]=pic[:,i+1]\n plt.imshow(pic)", "_____no_output_____" ], [ "model.predict(pic.reshape(1,784)/255)", "_____no_output_____" ], [ "", "_____no_output_____" ] ] ]

[ "markdown", "code" ]

[ [ "markdown", "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "## Deep Learining project\n\n\n* Gianfranco Di Marco - 1962292\n* Giacomo Colizzi Coin - 1794538\n\n\n\\\n**- Trajectory Prediction -**\n\nIs the problem of predicting the short-term (1-3 seconds) and long-term (3-5 seconds) spatial coordinates of various road-agents such as cars, buses, pedestrians, rickshaws, and animals, etc. These road-agents have different dynamic behaviors that may correspond to aggressive or conservative driving styles.\n\n**- nuScenes Dataset -**\n\nAvailable at. https://www.nuscenes.org/nuscenes. The nuScenes\ndataset is a large-scale autonomous driving dataset. The dataset has 3D bounding boxes for 1000 scenes collected in Boston and Singapore. Each scene is 20 seconds long and annotated at 2Hz. This results in a total of 28130 samples for training, 6019 samples for validation and 6008 samples for testing. The dataset has the full autonomous vehicle data suite: 32-beam LiDAR, 6 cameras and radars with complete 360° coverage\n\n\n> Holger Caesar and Varun Bankiti and Alex H. Lang and Sourabh Vora and Venice Erin Liong and Qiang Xu and Anush Krishnan and Yu Pan and Giancarlo Baldan and Oscar Beijbom: \"*nuScenes: A multimodal dataset for autonomous driving*\", arXiv preprint arXiv:1903.11027, 2019.\n\nThe most important part of this dataset for our project is the Map Expansion Pack, which simplify the trajectory prediction problem", "_____no_output_____" ], [ "## Requirements", "_____no_output_____" ], [ "**Environment**", "_____no_output_____" ] ], [ [ "# Necessary since Google Colab supports only Python 3.7\n# -> some libraries can be different from local and Colab\ntry:\n import google.colab\n from google.colab import drive\n ENVIRONMENT = 'colab'\n %pip install tf-estimator-nightly==2.8.0.dev2021122109\n %pip install folium==0.2.1\nexcept:\n ENVIRONMENT = 'local'", "_____no_output_____" ] ], [ [ "**Libraries**", "_____no_output_____" ] ], [ [ "%pip install nuscenes-devkit\n%pip install pytorch-lightning", "_____no_output_____" ], [ "# Learning\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torchvision.models import resnet50\nfrom torchvision.transforms import Normalize\nfrom torchmetrics import functional\nimport pytorch_lightning as pl\nfrom pytorch_lightning.callbacks import ModelCheckpoint\n\n# Math\nimport numpy as np\n\n# Dataset\nfrom nuscenes.nuscenes import NuScenes\nfrom nuscenes.prediction import PredictHelper\nfrom nuscenes.prediction.input_representation.static_layers import StaticLayerRasterizer\nfrom nuscenes.prediction.input_representation.agents import AgentBoxesWithFadedHistory\nfrom nuscenes.prediction.input_representation.interface import InputRepresentation\nfrom nuscenes.prediction.input_representation.combinators import Rasterizer\nfrom nuscenes.eval.prediction.config import PredictionConfig, load_prediction_config\nfrom nuscenes.eval.prediction.splits import get_prediction_challenge_split\nfrom nuscenes.eval.prediction import metrics, data_classes\n\n# File system\nimport os\nimport shutil\nimport pickle\nimport zipfile\nimport tarfile\nimport urllib.request\n\n# Generic\nimport time\nfrom tqdm import tqdm\nfrom typing import List, Dict, Tuple, Any\nfrom collections import defaultdict\nfrom abc import abstractmethod\nimport multiprocessing as mp\nimport matplotlib.pyplot as plt", "_____no_output_____" ] ], [ [ "## Configuration", "_____no_output_____" ], [ "**Generic Parameters**", "_____no_output_____" ] ], [ [ "# Environment-dependent parameters\nif ENVIRONMENT == 'colab':\n ROOT = '/content/drive/MyDrive/DL/Trajectory-Prediction-PyTorch/'\n MAX_NUM_WORKERS = 0\n MAX_BATCH_SIZE = 8\n PROGRESS_BAR_REFRESH_RATE = 20\nelif ENVIRONMENT == 'local':\n ROOT = os.getcwd()\n # TODO: solve problem with VRAM with PL\n if os.name == 'nt':\n MAX_NUM_WORKERS = 0\n MAX_BATCH_SIZE = 16\n else:\n MAX_NUM_WORKERS = 4\n MAX_BATCH_SIZE = 8\n PROGRESS_BAR_REFRESH_RATE = 10\nelse:\n raise ValueError(\"Wrong 'environment' value\")\n\n# Train parameters\nBATCH_SIZE = MAX_BATCH_SIZE\nNUM_WORKERS = MAX_NUM_WORKERS\nLEARNING_RATE = 1e-4\nMOMENTUM = 0.9\nTRAIN_EPOCHES = 20 \nPLOT_PERIOD = 1 # 1 = plot at each epoch\nCHECKPOINT_DIR = os.path.join(ROOT, 'checkpoints')\nBEST_CHECKPOINT_DIR = os.path.join(CHECKPOINT_DIR, 'best')\nCHECKPOINT_MONITOR = \"val_loss\"\nTOP_K_SAVE = 10\n\n# Test parameters\nDEBUG_MODE = False\n\n# Hardcoded parameters\nHELPER_NEEDED = False", "_____no_output_____" ] ], [ [ "**Network Parameters**", "_____no_output_____" ] ], [ [ "# TODO: add other baselines\nPREDICTION_MODEL = 'CoverNet'\nif PREDICTION_MODEL == 'CoverNet':\n # - Architecture parameters\n BACKBONE_WEIGHTS = 'ImageNet'\n BACKBONE_MODEL = 'ResNet18'\n K_SIZE = 20000\n # - Trajectory parameters\n AGENT_HISTORY = 1\n SHORT_TERM_HORIZON = 3\n LONG_TERM_HORIZON = 6\n TRAJ_HORIZON = SHORT_TERM_HORIZON\n TRAJ_LINK = 'https://www.nuscenes.org/public/nuscenes-prediction-challenge-trajectory-sets.zip'\n TRAJ_DIR = os.path.join(ROOT, 'trajectory_sets')\n EPSILON = 2 ", "_____no_output_____" ] ], [ [ "**Dataset Parameters**", "_____no_output_____" ] ], [ [ "# Organization parameters\nPREPARE_DATASET = False\nPREPROCESSED = True\n\n# File system parameters\nPL_SEED = 42\nDATAROOT = os.path.join(ROOT, 'data', 'sets', 'nuscenes')\nPREPROCESSED_FOLDER = 'preprocessed'\nGT_SUFFIX = '-gt'\nFILENAME_EXT = '.pt'\nDATASET_VERSION = 'v1.0-trainval'\nAGGREGATORS = [{'name': \"RowMean\"}]\n\n# Other parameters\nMAX_PREDICTED_MODES = 25\nSAMPLES_PER_SECOND = 2\nNORMALIZATION = 'imagenet'", "_____no_output_____" ] ], [ [ "## Dataset", "_____no_output_____" ], [ "**Initialization**\n\nN.B: The download links in function *urllib.request.urlretrieve()* should be replaced periodically because it expires. Steps to download correctly are (on Firefox):\n\n\n1. Dowload Map Expansion pack (or Trainval metadata) from the website\n2. Stop the download\n3. Right-click on the file -> copy download link\n4. Paste the copied link into the first argument of the urlretrieve function. The second argument is the final name of the file", "_____no_output_____" ] ], [ [ "# Drive initialization\nif ENVIRONMENT == 'colab':\n drive.mount('/content/drive')", "_____no_output_____" ], [ "if PREPARE_DATASET:\n\n # Creating dataset dir\n os.makedirs(DATAROOT, exist_ok=True)\n os.chdir(DATAROOT)\n\n # Downloading Map Expansion Pack\n os.mkdir('maps')\n os.chdir('maps')\n print(\"Downloading and extracting Map Expansion pack ...\")\n urllib.request.urlretrieve('https://s3.amazonaws.com/data.nuscenes.org/public/v1.0/nuScenes-map-expansion-v1.3.zip?AWSAccessKeyId=AKIA6RIK4RRMFUKM7AM2&Signature=AvzxB6d7CxtpCUYIUChItvDSA3Q%3D&Expires=1651141974', 'nuScenes-map-expansion-v1.3.zip')\n with zipfile.ZipFile('nuScenes-map-expansion-v1.3.zip', 'r') as zip_ref:\n zip_ref.extractall(os.getcwd())\n os.remove('nuScenes-map-expansion-v1.3.zip')\n\n # Downloading Trainval Metadata\n os.chdir('..')\n print(\"Downloading and extracting TrainVal metadata ...\")\n urllib.request.urlretrieve('https://s3.amazonaws.com/data.nuscenes.org/public/v1.0/v1.0-trainval_meta.tgz?AWSAccessKeyId=AKIA6RIK4RRMFUKM7AM2&Signature=ZDr9UgOoV3UpYCI5RCY%2BNKiZVZ4%3D&Expires=1651142002', 'v1.0-trainval_meta.tgz')\n tar_ref = tarfile.open('v1.0-trainval_meta.tgz', 'r:gz')\n tar_ref.extractall(os.getcwd())\n tar_ref.close()\n os.remove('v1.0-trainval_meta.tgz')\n os.chdir(DATAROOT)", "_____no_output_____" ] ], [ [ "**Dataset definition**", "_____no_output_____" ] ], [ [ "class TrajPredDataset(torch.utils.data.Dataset):\n \"\"\" Trajectory Prediction Dataset\n\n Base Class for Trajectory Prediction Datasets\n \"\"\"\n def __init__(self, dataset, name, data_type, preprocessed, split,\n dataroot, preprocessed_folder, filename_ext,\n gt_suffix, traj_horizon, max_traj_horizon, num_workers):\n \"\"\" Dataset Initialization\n\n Parameters\n ----------\n dataset: the instantiated dataset\n name: name of the dataset\n data_type: data type of the dataset elements\n preprocessed: True if data has already been preprocessed\n split: the dataset split ('train', 'train_val', 'val')\n dataroot: the root directory of the dataset\n preprocessed_folder: the folder containing preprocessed data\n filename_ext: the extension of the generated filenames\n gt_suffix: the suffix added after each GT filename (before ext)\n traj_horizon: horizon (in seconds) for the future trajectory\n max_traj_horizon: maximum trajectory horizon possible (in seconds)\n num_workers: num of processes that collect data\n \"\"\"\n super(TrajPredDataset, self).__init__()\n self.dataset = dataset\n self.name = name\n self.data_type = data_type\n self.preprocessed = preprocessed\n self.split = split\n self.dataroot = dataroot\n self.preprocessed_folder = preprocessed_folder\n self.filename_ext = filename_ext\n self.gt_suffix = gt_suffix\n self.traj_horizon = traj_horizon\n self.max_traj_horizon = max_traj_horizon\n self.num_workers = num_workers\n self.helper = None\n self.tokens = None\n self.static_layer_rasterizer = None\n self.agent_rasterizer = None\n self.input_representation = None\n\n def __len__(self):\n \"\"\" Return the size of the dataset \"\"\"\n raise NotImplementedError\n\n def __getitem__(self, idx):\n \"\"\" Return an element of the dataset \"\"\"\n raise NotImplementedError\n\n @abstractmethod\n def generate_data(self):\n \"\"\" Data generation\n\n If self.preprocessed, directly collect data.\n Otherwise, generate data without preprocess it.\n \"\"\"\n raise NotImplementedError\n\n @abstractmethod\n def get_raster(self, token):\n \"\"\" Convert a token split into a raster\n\n Parameters\n ----------\n token: token containing instance token and sample token\n\n Return\n ------\n raster: the raster image\n \"\"\"\n raise NotImplementedError\n\n\nclass nuScenesDataset(TrajPredDataset):\n \"\"\" nuScenes Dataset for Trajectory Prediction challenge \"\"\"\n def __init__(self, helper, data_type='raster', preprocessed=False, split='train',\n dataroot=DATAROOT, preprocessed_folder=PREPROCESSED_FOLDER,\n filename_ext=FILENAME_EXT, gt_suffix=GT_SUFFIX,\n traj_horizon=TRAJ_HORIZON, max_traj_horizon=LONG_TERM_HORIZON,\n samples_per_second=SAMPLES_PER_SECOND,\n agent_history=AGENT_HISTORY, normalization=NORMALIZATION, \n num_workers=NUM_WORKERS):\n \"\"\" nuScenes Dataset Initialization\n\n Parameters\n ----------\n helper: the helper of the instantiated nuScenes dataset (None if not needed)\n data_type: data type of the dataset elements\n preprocessed: True if data has already been preprocessed\n split: the dataset split ('train', 'train_val', 'val')\n dataroot: the root directory of the dataset\n preprocessed_folder: the folder containing preprocessed data\n filename_ext: the extension of the generated filenames\n gt_suffix: the suffix added after each GT filename (before ext)\n traj_horizon: horizon (in seconds) for the future trajectory\n max_traj_horizon: maximum trajectory horizon possible (in seconds)\n samples_per_second: sampling frequency (in Hertz)\n agent_history: the seconds of considered agent history\n normalization: which kind of normalization to apply to input\n num_workers: num of processes that collect data\n \"\"\"\n # General initialization\n super(nuScenesDataset, self).__init__(\n None, 'nuScenes', data_type, preprocessed, split, dataroot, preprocessed_folder, \n filename_ext, gt_suffix, traj_horizon, max_traj_horizon, num_workers)\n self.helper = helper\n self.tokens = get_prediction_challenge_split(\n split, dataroot=dataroot)\n self.samples_per_second = samples_per_second\n if data_type == 'raster':\n if helper is not None:\n self.static_layer_rasterizer = StaticLayerRasterizer(self.helper)\n self.agent_rasterizer = AgentBoxesWithFadedHistory(\n self.helper, seconds_of_history=agent_history)\n self.input_representation = InputRepresentation(\n self.static_layer_rasterizer, self.agent_rasterizer, Rasterizer())\n else:\n self.static_layer_rasterizer = None\n self.agent_rasterizer = None\n self.input_representation = None\n else: # NOTE: possible also other type of input data\n pass\n if not self.preprocessed:\n print(\"Preprocessing data ...\")\n self.generate_data()\n\n # Normalization function\n if normalization == 'imagenet':\n self.normalization = Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n else:\n raise ValueError(\"Available only 'imagenet' normalization\")\n \n def __len__(self) -> int:\n \"\"\" Return the size of the dataset \"\"\"\n return len(self.tokens)\n\n def __getitem__(self, idx) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, int]:\n \"\"\" Return an element of the dataset \"\"\"\n # Select subfolder\n if idx < 0:\n idx = len(self) + idx\n subfolder = f'batch_{idx//128}'\n # Load files\n complete_tensor = torch.load(\n os.path.join(self.dataroot, self.preprocessed_folder, self.split,\n subfolder, self.tokens[idx] + self.filename_ext))\n gt_trajectory = torch.load(\n os.path.join(self.dataroot, self.preprocessed_folder, self.split, subfolder,\n self.tokens[idx] + self.gt_suffix + self.filename_ext))\n # Adjust tensors\n # NOTE: maybe it's better to handle this section in data generation \n while gt_trajectory.shape[0] < self.samples_per_second * self.max_traj_horizon:\n gt_trajectory = torch.concat((gt_trajectory, gt_trajectory[-1].unsqueeze(0)))\n gt_trajectory = gt_trajectory[:(self.samples_per_second * self.traj_horizon)]\n agent_state_vector, raster_img = self.tensor_io_conversion(\n \"read\", None, None, complete_tensor)\n raster_img = self.normalization(raster_img)\n nan_mask = agent_state_vector != agent_state_vector\n if nan_mask.any():\n agent_state_vector[nan_mask] = 0\n return agent_state_vector, raster_img, gt_trajectory, idx\n\n def generate_data(self):\n \"\"\" Data generation\n\n If self.preprocessed, directly collect data.\n Otherwise, generate data without preprocess it.\n \"\"\"\n # Generate directories if don't exist\n preprocessed_dir = os.path.join(self.dataroot, self.preprocessed_folder)\n split_dir = os.path.join(preprocessed_dir, self.split)\n if self.preprocessed_folder not in os.listdir(self.dataroot):\n os.mkdir(preprocessed_dir)\n if self.split not in os.listdir(preprocessed_dir):\n os.mkdir(split_dir)\n # Variable useful to restore interrupted preprocessing\n preprocessed_batches = os.listdir(split_dir)\n already_preproc = \\\n len([f for f in preprocessed_batches\n if os.path.isfile(os.path.join(split_dir, f))])\n\n # Create subfolders\n if len(preprocessed_batches) == 0:\n n_subfolders = len(self.tokens) // 128 + int(len(self.tokens) % 128 != 0)\n for i in range(n_subfolders):\n subfolder = 'batch_' + str(i)\n os.mkdir(os.path.join(split_dir, subfolder))\n\n # Generate data\n if self.data_type == 'raster':\n for i, t in enumerate(tqdm(self.tokens)):\n subfolder = f'batch_{i//128}'\n if i >= int(already_preproc/2):\n self.generate_raster_data(t, split_dir, subfolder)\n else:\n pass\n\n def generate_raster_data(self, token, batches_dir, subfolder):\n \"\"\" Generate a raster map and agent state vector from token split \n\n The generated input data consists in a tensor like this:\n [raster map | agent state vector]\n The generated ground truth data is the future agent trajectory tensor\n\n Parameters\n ----------\n token: token containing instance token and sample token\n batches_dir: the directory in which the batches will be generated\n subfolder: the data is divided into subfolders in order to avoid Drive timeouts;\n this parameter tells which is the actual subfolder towhere place data\n \"\"\"\n # Generate and concatenate input tensors\n instance_token, sample_token = token.split(\"_\")\n raster_img = self.input_representation.make_input_representation(\n instance_token, sample_token)\n raster_tensor = torch.Tensor(raster_img).permute(2, 0, 1) / 255.\n agent_state_vector = torch.Tensor(\n [[self.helper.get_velocity_for_agent(instance_token, sample_token),\n self.helper.get_acceleration_for_agent(instance_token, sample_token),\n self.helper.get_heading_change_rate_for_agent(instance_token, sample_token)]])\n raster_agent_tensor, _ = \\\n self.tensor_io_conversion('write', raster_tensor, agent_state_vector)\n\n # Generate ground truth\n gt_trajectory = torch.Tensor(\n self.helper.get_future_for_agent(instance_token, sample_token,\n seconds=self.max_traj_horizon, in_agent_frame=True))\n\n # Save to disk\n torch.save(raster_agent_tensor, os.path.join(\n batches_dir, subfolder, token + self.filename_ext))\n torch.save(gt_trajectory, os.path.join(\n batches_dir, subfolder, token + self.gt_suffix + self.filename_ext))\n \n @staticmethod\n def tensor_io_conversion(mode, big_t=None, small_t=None, complete_t=None) -> Tuple[torch.Tensor, torch.Tensor]:\n \"\"\" Utility IO function to concatenate tensors of different shape\n\n Normally used to concatenate (or separate) raster map and agent state vector in order to speed up IO\n\n Parameters\n ----------\n mode: 'write' (concatenate) or 'read' (separate)\n big_t: the bigger tensor (None if we are going to separate tensors)\n small_t: the smaller tensor (None if we are going to separate tensors)\n complete_t: the concatenated tensor (None if we are going to concatenate tensors)\n\n Return\n ------\n out1: big tensor (mode == 'read') or complete tensor (mode == 'write')\n out2: small tensor (mode == 'read') or empty tensor (mode == 'write') \n \"\"\"\n out1, out2 = None, None\n if mode == 'write': # concatenate\n if big_t is None or small_t is None:\n raise ValueError(\"Wrong argument: 'big_t' and 'small_t' cannot be None\")\n small_t = small_t.permute(1, 0).unsqueeze(2)\n small_t = small_t.expand(-1, -1, big_t.shape[-1])\n out1 = torch.cat((big_t, small_t), dim=1)\n out2 = torch.empty(small_t.shape)\n elif mode == 'read': # separate\n if complete_t is None:\n raise ValueError(\"Wrong argument: 'complete_t' cannot be None\")\n out1 = complete_t[..., -1, -1].unsqueeze(0)\n out2 = complete_t[..., :-1, :]\n else:\n raise ValueError(\n \"Wrong argument 'mode'; available 'read' or 'write'\")\n return out1, out2\n\nclass nuScenesDataModule(pl.LightningDataModule):\n \"\"\" PyTorch Lightning Data Module for the nuScenes dataset \"\"\"\n def __init__(self, nuscenes_train, nuscenes_val, batch_size=BATCH_SIZE, num_workers=NUM_WORKERS):\n \"\"\" Data Module initialization\n\n Parameters\n ----------\n nuscenes_train: instance of the nuScenesDataset class (split='train')\n nuscenes_val: instance of the nuScenesDataset class (split='val')\n batch_size: number of samples to extract from the dataset at each step\n num_workers: number of cores implied in data collection\n \"\"\"\n super(nuScenesDataModule, self).__init__()\n self.batch_size = batch_size\n self.num_workers = num_workers\n self.nuscenes_train = nuscenes_train\n self.nuscenes_val = nuscenes_val\n\n def setup(self, stage=None):\n \"\"\" Setup the data module \"\"\"\n if stage == \"fit\" or stage is None:\n self.nusc_train = self.nuscenes_train\n self.nusc_val = self.nuscenes_val\n\n if stage == \"test\" or stage is None:\n self.nusc_test = self.nuscenes_val\n\n def train_dataloader(self):\n \"\"\" Dataloader for the training part \"\"\"\n return torch.utils.data.DataLoader(self.nusc_train, self.batch_size, shuffle=True,\n num_workers=self.num_workers, drop_last=True)\n\n def val_dataloader(self):\n \"\"\" Dataloader for the validation part \"\"\"\n return torch.utils.data.DataLoader(self.nusc_val, self.batch_size, shuffle=False, \n num_workers=self.num_workers, drop_last=True)\n\n def test_dataloader(self):\n \"\"\" Dataloader for the testing part \"\"\"\n return torch.utils.data.DataLoader(self.nusc_test, self.batch_size, shuffle=False,\n num_workers=self.num_workers, drop_last=True)", "_____no_output_____" ] ], [ [ "## Models", "_____no_output_____" ], [ "**Covernet**", "_____no_output_____" ] ], [ [ "class CoverNet(pl.LightningModule):\n \"\"\" CoverNet model for Trajectory Prediction \"\"\"\n def __init__(self, K_size, epsilon, traj_link, traj_dir, device, \n lr=LEARNING_RATE, momentum=MOMENTUM,\n traj_samples=SAMPLES_PER_SECOND*TRAJ_HORIZON):\n \"\"\" CoverNet initialization\n\n Parameters\n ----------\n K_size: number of modes (trajectories) (needed ?)\n epsilon: value (in meters) relative to the space coverage\n traj_link: link from which to download the trajectories\n device: target device of the model (e.g. 'cuda:0')\n lr: learning rate of the optimizer\n momentum: momentum of the optimizer\n traj_samples: number of samples to consider in the trajectory\n \"\"\"\n super().__init__()\n self.K_size = K_size\n self.convModel = resnet50(pretrained=True)\n self.activation = {}\n def get_activation(name):\n def hook(model, input, output):\n self.activation[name] = output\n return hook\n self.convModel.layer4.register_forward_hook(get_activation('layer4'))\n self.trajectories = prepare_trajectories(epsilon, traj_link, traj_dir)\n self.fc1 = nn.Linear(2051, 4096)\n self.fc2 = nn.Linear(4096, self.trajectories.size()[0])\n self.traj_samples = traj_samples\n self.tgt_device = device\n self.momentum = momentum\n self.lr = lr\n\n def forward(self, x) -> torch.Tensor:\n \"\"\" Network inference \"\"\"\n img, state = x\n self.convModel(img)\n resnet_output = torch.flatten(self.convModel.avgpool(self.activation['layer4']),start_dim=1)\n x = torch.cat([resnet_output, state], 1)\n x = self.fc1(x)\n x = self.fc2(x)\n return x\n\n def training_step(self, batch, batch_idx):\n \"\"\" Training step of the model\n\n Parameters\n ----------\n batch: batch of data\n batch_idx: index of the actual batch (from 0 to len(dataset))\n \"\"\"\n # Collect data\n x_state, x_img, gt, _ = batch\n x_state = torch.flatten(x_state, 0, 1)\n reduced_traj = self.trajectories[:, :self.traj_samples]\n # Prepare positive samples\n with torch.no_grad():\n y = get_positives(reduced_traj, gt.to('cpu'))\n y = y.to(self.tgt_device)\n # Inference\n y_hat = self((x_img, x_state))\n loss = F.cross_entropy(y_hat, y)\n # Log\n self.log('train_loss', loss.item(), on_step=True)\n \n return loss\n\n def validation_step(self, batch, batch_idx):\n \"\"\" Validation step of the model\n\n Parameters\n ----------\n batch: batch of data\n batch_idx: index of the actual batch (from 0 to len(dataset))\n \"\"\"\n with torch.no_grad():\n # Collect data\n x_state, x_img, gt, _ = batch\n x_state = torch.flatten(x_state, 0, 1)\n reduced_traj = self.trajectories[:, :self.traj_samples]\n # Prepare positive samples\n y = get_positives(reduced_traj, gt.to('cpu'))\n y = y.to(self.tgt_device)\n # Inference\n y_hat = self((x_img, x_state))\n loss = F.cross_entropy(y_hat, y)\n # Log\n self.log('val_loss', loss.item(), on_epoch=True)\n \n return loss\n\n def configure_optimizers(self):\n \"\"\" Set the optimizer for the model \"\"\"\n # TODO: find best optimizer and parameters\n #return torch.optim.Adam(self.parameters(), lr=self.lr)\n return torch.optim.SGD(self.parameters(), lr=self.lr, momentum=self.momentum)\n\n# TODO: check if generated trajectory are expressed in the same frame of the agent\ndef get_positives(trajectories, ground_truth) -> torch.Tensor:\n \"\"\" Get positive samples wrt the actual GT\n\n Parameters\n ----------\n trajectories: the pre-generated set of trajectories\n ground_truth: the future trajectory for the agent\n\n Return\n ------\n positive_traj: as defined in the original CoverNet paper, \n 'positive samples determined by the element in the trajectory set\n closest to the actual ground truth in minimum average \n of point-wise Euclidean distances'\n \"\"\"\n euclidean_dist = torch.stack([torch.pow(torch.sub(trajectories, gt), 2) \n for gt in ground_truth]).sum(dim=3).sqrt() \n mean_euclidean_dist = euclidean_dist.mean(dim=2)\n positive_traj = mean_euclidean_dist.argmin(dim=1)\n return positive_traj\n\ndef prepare_trajectories(epsilon, download_link, directory) -> torch.Tensor:\n \"\"\" Function to download and extract trajectory sets for CoverNet \n\n Parameters\n ----------\n epsilon: value (in meters) relative to the space coverage\n download_link: link from which to download trajectory sets\n directory: directory where to download trajectory sets\n\n Return\n ------\n trajectories: tensor of the trajectory set for the specified epsilon\n \"\"\"\n # 1. Download and extract trajectories\n filename_zip = 'nuscenes-prediction-challenge-trajectory-sets.zip'\n filename = filename_zip[:-4]\n filename_dir = os.path.join(directory, filename)\n filename_zipdir = os.path.join(directory, filename_zip)\n if (not os.path.isdir(filename_dir) \n or any(e not in os.listdir(filename_dir)\n for e in ['epsilon_2.pkl', 'epsilon_4.pkl', 'epsilon_8.pkl'])):\n print(\"Downloading trajectories ...\")\n os.makedirs(directory, exist_ok=True)\n urllib.request.urlretrieve(download_link, filename_zipdir)\n with zipfile.ZipFile(filename_zipdir, 'r') as archive:\n archive.extractall(directory)\n os.remove(filename_zipdir)\n\n # 2. Generate trajectories\n traj_set_path = os.path.join(filename_dir, 'epsilon_' + str(epsilon) + '.pkl')\n trajectories = pickle.load(open(traj_set_path, 'rb'))\n return torch.Tensor(trajectories)", "_____no_output_____" ] ], [ [ "## Utilities", "_____no_output_____" ], [ "**Metrics**", "_____no_output_____" ] ], [ [ "def compute_metrics(predictions: List[data_classes.Prediction], ground_truths: List[np.ndarray], \n helper, aggregators=AGGREGATORS) -> Dict[str, Any]:#Dict[str, Dict[str, List[float]]]:\n \"\"\" Utility eval function to compute dataset metrics\n\n Parameters\n ----------\n predictions: list of predictions made by the model (in Prediction class format)\n ground_truths: the real trajectories of the agent (SHAPE -> [len(dataset), n_samples, state_dim])\n helper: nuScenes dataset helper\n aggregators: functions to aggregate metrics (e.g. mean)\n\n Return\n ------\n metric_output: dictionary of the computed metrics:\n - minADE_5: The average of pointwise L2 distances between the predicted trajectory \n and ground truth over the 5 most likely predictions.\n - minADE_10: The average of pointwise L2 distances between the predicted trajectory \n and ground truth over the 10 most likely predictions.\n - missRateTop_2_5: Proportion of misses relative to the 5 most likely trajectories\n over all agents\n - missRateTop_2_10: Proportion of misses relative to the 10 most likely trajectories\n over all agents\n - minFDE_1: The final displacement error (FDE) is the L2 distance \n between the final points of the prediction and ground truth, computed\n on the most likely trajectory\n - offRoadRate: the fraction of trajectories that are not entirely contained\n in the drivable area of the map.\n \"\"\"\n # 1. Define metrics\n print(\"\\t - Metrics definition ...\")\n aggregators = \\\n [metrics.deserialize_aggregator(agg) for agg in aggregators]\n min_ade = metrics.MinADEK([5, 10], aggregators)\n miss_rate = metrics.MissRateTopK([5, 10], aggregators)\n min_fde = metrics.MinFDEK([1], aggregators)\n if helper is not None:\n # FIXME: instantiating offRoadRate class makes RAM explode\n #offRoadRate = metrics.OffRoadRate(self.helper, self.aggregators)\n pass\n else:\n offRoadRate = None\n\n # 2. Compute metrics\n metric_list = []\n print(\"\\t - Effective metrics computation ...\")\n for p, pred in enumerate(tqdm(predictions)):\n # TODO: check for argument shapes\n minADE_5 = min_ade(ground_truths[p], pred)[0][0]\n minADE_10 = min_ade(ground_truths[p], pred)[0][1]\n missRateTop_2_5 = miss_rate(ground_truths[p], pred)[0][0]\n missRateTop_2_10 = miss_rate(ground_truths[p], pred)[0][1]\n minFDE_1 = min_fde(ground_truths[p], pred)\n #offRoadRate = offRoadRate(ground_truth[i], prediction)\n metric = {'minADE_5': minADE_5, 'missRateTop_2_5': missRateTop_2_5,\n 'minADE_10': minADE_10, 'missRateTop_2_10': missRateTop_2_10,\n 'minFDE_1': minFDE_1}#, 'offRoadRate': offRoadRate}\n metric_list.append(metric)\n\n # 3. Aggregate\n print(\"\\t - Metrics aggregation ...\")\n aggregations: Dict[str, Dict[str, List[float]]] = defaultdict(dict)\n metric_names = list(metric_list[0].keys())\n metrics_dict = {name: np.array([metric_list[i][name] for i in range(len(metric_list))]) \n for name in metric_names}\n for metric in metric_names:\n for agg in aggregators:\n aggregations[metric][agg.name] = agg(metrics_dict[metric])\n\n return aggregations ", "_____no_output_____" ] ], [ [ "**Plotting**", "_____no_output_____" ] ], [ [ "def plot_train_data(train_iterations, val_iterations, epoches, train_losses, val_losses):\n \"\"\" Plot a graph with the training trend\n\n Parameters\n ----------\n train_iterations: number of iterations for each epoch [train]\n val_iterations: number of iterations for each epoch [val]\n epoches: actual epoch number (starting from 1)\n train_losses: array of loss values [train]\n val_losses: array of loss values [val]\n \"\"\"\n # Data preparation\n train_iterations_list = list(range(epoches*(train_iterations)))\n val_iterations_list = list(range(epoches*(val_iterations)))\n epoches_list = list(range(epoches))\n\n # Adjust validation array dimension\n val_error = len(val_losses) - len(val_iterations_list)\n if val_error > 0:\n val_losses = val_losses[:-val_error]\n\n # Per-iteration plot\n fig = plt.figure()\n plt.title('Per-iteration Loss [train]')\n plt.xlabel('Iterations')\n plt.ylabel('Value')\n l1, = plt.plot(train_iterations_list, train_losses, c='blue')\n plt.legend(handles=[l1], labels=['Train loss'], loc='best')\n plt.show()\n fig = plt.figure()\n plt.title('Per-iteration Loss [val]')\n plt.xlabel('Iterations')\n plt.ylabel('Value')\n l2, = plt.plot(val_iterations_list, val_losses, c='red')\n plt.legend(handles=[l2], labels=['Validation loss'], loc='best')\n plt.show()\n\n # Per-epoch plot\n fig = plt.figure()\n plt.title('Per-epoch Loss')\n plt.xlabel('Epoches')\n plt.ylabel('Value')\n train_avg_losses = [np.array(train_losses[i:i+train_iterations]).mean() \n for i in range(0, len(train_losses), train_iterations)]\n val_avg_losses = [np.array(val_losses[i:i+val_iterations]).mean() \n for i in range(0, len(val_losses), val_iterations)]\n l1, = plt.plot(epoches_list, train_avg_losses, c='blue')\n l2, = plt.plot(epoches_list, val_avg_losses, c='red')\n plt.legend(handles=[l1, l2], labels=['Train loss', 'Validation loss'], loc='best')\n plt.show()\n\ndef plot_agent_future(raster, future, agent_pos=(0,0), reference_frame='local', color='green'):\n \"\"\" Plot agent's future trajectory\n\n Parameters\n ----------\n raster: raster map tensor (image)\n future: future trajectory of the agent (predicted or GT) [x,y]\n agent_pos: position of the agent (needed in case of local coords)\n reference_frame: frame to which future coordinates refer\n color: color of the plotted trajectory\n \"\"\"\n # Show raster map\n plt.imshow(raster.permute(1, 2, 0))\n\n # Show trajectory\n x, y = [], []\n for i in range(len(future)):\n point = (agent_pos[0], agent_pos[1]) if i == 0 else future[i].numpy()\n if reference_frame == 'local' and i > 0:\n point = (point[0] + agent_pos[0], -point[1] + agent_pos[1])\n x.append(point[0])\n y.append(point[1])\n \n plt.plot(x, y, color=color, markersize=10, linewidth=5)\n plt.show()", "_____no_output_____" ] ], [ [ "## Main", "_____no_output_____" ], [ "**Initialization**", "_____no_output_____" ] ], [ [ "# ---------- Dataset initialization ---------- #\n# Initialize nuScenes helper\nprint(\"nuScenes Helper initialization ...\")\nstart_time = time.time()\npl.seed_everything(PL_SEED)\nif ENVIRONMENT == 'local':\n if PREPARE_DATASET:\n nusc = NuScenes(version=DATASET_VERSION, dataroot=DATAROOT, verbose=True)\n with open(os.path.join(ROOT, 'nuscenes_checkpoint'+FILENAME_EXT), 'wb') as f:\n pickle.dump(nusc, f, protocol=pickle.HIGHEST_PROTOCOL)\n elif not 'nusc' in locals():\n if HELPER_NEEDED:\n with open(os.path.join(ROOT, 'nuscenes_checkpoint'+FILENAME_EXT), 'rb') as f:\n nusc = pickle.load(f)\nelif ENVIRONMENT == 'colab':\n if PREPARE_DATASET or HELPER_NEEDED:\n nusc = NuScenes(version=DATASET_VERSION, dataroot=DATAROOT, verbose=True)\nhelper = PredictHelper(nusc) if HELPER_NEEDED else None\nprint(\"nuScenes Helper initialization done in %f s\\n\" % (time.time() - start_time))\n\n# Initialize dataset and data module\nprint(\"\\nDataset and Data Module initialization ...\")\nstart_time = time.time()\ntrain_dataset = nuScenesDataset(helper, preprocessed=PREPROCESSED, split='train')\nval_dataset = nuScenesDataset(helper, preprocessed=PREPROCESSED, split='val')\ntrainval_dm = nuScenesDataModule(train_dataset, val_dataset, num_workers=NUM_WORKERS)\ntrainval_dm.setup(stage='fit')\nprint(\"Dataset and Data Module initialization done in %f s\\n\" % (time.time() - start_time))\n\n# ---------- Network initialization ---------- #\nprint(\"\\nCoverNet model initialization ...\")\nstart_time = time.time()\ndevice = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\nmodel = CoverNet(K_SIZE, EPSILON, TRAJ_LINK, TRAJ_DIR, device)\nprint(\"CoverNet model intialization done in %f s\\n\" % (time.time() - start_time))\n\n# ---------- Training initialization ---------- #\nprint(\"\\nTrainer initialization ...\")\nstart_time = time.time()\nGPUS = min(1, torch.cuda.device_count())\ncheckpoint_callback = ModelCheckpoint(dirpath=CHECKPOINT_DIR,\n save_top_k=TOP_K_SAVE,\n monitor=CHECKPOINT_MONITOR)\ntrainer = pl.Trainer(callbacks=[checkpoint_callback],\n progress_bar_refresh_rate=PROGRESS_BAR_REFRESH_RATE, \n gpus=GPUS, max_epochs=TRAIN_EPOCHES)\nprint(\"Trainer intialization done in %f s\\n\" % (time.time() - start_time))", "_____no_output_____" ] ], [ [ "**Training loop**", "_____no_output_____" ] ], [ [ "trainer.fit(model, trainval_dm)", "_____no_output_____" ] ], [ [ "**Testing**", "_____no_output_____" ] ], [ [ "# Dataloader initialization\nprint(\"Loading test dataloader ...\")\ntrainval_dm.setup(stage='test')\ntest_dataloader = trainval_dm.test_dataloader()\ntest_generator = iter(test_dataloader)\n\n# Trained model initialization\n# TODO: istantiate kwargs for network in a better way\nprint(\"\\nCoverNet trained model initialization ...\")\ncheckpoint_name = 'epoch=19-step=80460.ckpt'\nnet_args = {'K_size': K_SIZE, 'epsilon': EPSILON, 'traj_link': TRAJ_LINK, 'traj_dir': TRAJ_DIR, 'device': device}\nmodel = CoverNet.load_from_checkpoint(checkpoint_path=os.path.join(BEST_CHECKPOINT_DIR, checkpoint_name), \n map_location=None, hparams_file=None, strict=True, \n K_size=K_SIZE, epsilon=EPSILON, traj_link=TRAJ_LINK, traj_dir=TRAJ_DIR, device=device).to(device)\nmodel.eval()\n\n# ---------- CoverNet Metrics computation ---------- #\n# TODO: generalize metrics computation\npredictions = []\nground_truths = []\nstart = time.time()\nreduced_traj = model.trajectories[:, :model.traj_samples].numpy()\nprint(\"\\nCoverNet metrics computation ...\")\nprint(\"1 - Producing predictions ...\")\nfor i, token in enumerate(tqdm(val_dataset.tokens)):\n with torch.no_grad():\n x_state, x_img, gt, _ = val_dataset[i]\n x_state = x_state.to(device)\n x_img = x_img.to(device)\n x_state = torch.unsqueeze(torch.flatten(x_state, 0, 1), 0)\n x_img = torch.unsqueeze(x_img, 0)\n pred_logits = model((x_img, x_state))\n pred_probs = F.softmax(pred_logits, dim=1)[0]\n top_indices = pred_probs.argsort()[-MAX_PREDICTED_MODES:]\n cutted_probs = pred_probs[top_indices].cpu().numpy()\n cutted_traj = reduced_traj[top_indices.cpu()]\n i_t, s_t = token.split(\"_\")\n ground_truths.append(gt.numpy())\n predictions.append(data_classes.Prediction(i_t, s_t, cutted_traj, cutted_probs))\nprint(\"2 - Computing metrics ...\")\nconvernet_metrics = compute_metrics(predictions, ground_truths, helper)\nprint(\"Metric computation done in %f s\" % (time.time() - start))\n", "_____no_output_____" ], [ "convernet_metrics", "_____no_output_____" ] ], [ [ "## Code Debugging", "_____no_output_____" ], [ "**Training loop** (manual - debug only)", "_____no_output_____" ] ], [ [ "if DEBUG_MODE:\n\n # Dataset preparation\n train_dataloader = torch.utils.data.DataLoader(train_dataset, BATCH_SIZE, shuffle=True, num_workers=NUM_WORKERS, drop_last=True)\n val_dataloader = torch.utils.data.DataLoader(val_dataset, BATCH_SIZE, shuffle=False, num_workers=NUM_WORKERS, drop_last=True)\n\n # Training preparation\n optimizer = torch.optim.SGD(model.parameters(), lr=LEARNING_RATE, momentum=MOMENTUM)\n model = model.to(device)\n\n # Plotting preparation\n train_loss_arr = []\n val_loss_arr = []\n train_iterations = len(train_dataset) // BATCH_SIZE\n val_iterations = len(val_dataset) // BATCH_SIZE\n\n # Training loop\n for i in range(TRAIN_EPOCHES):\n print(\"-------- Epoch %d --------\" % i)\n model.train()\n\n # Training\n for j, data in enumerate(train_dataloader):\n \n # Data preparation\n x_state, x_img, gt, idx = data\n x_state = x_state.to(device)\n x_img = x_img.to(device)\n x_state = torch.flatten(x_state, 0, 1)\n with torch.no_grad():\n reduced_traj = model.trajectories[:, :SAMPLES_PER_SECOND*TRAJ_HORIZON]\n y = get_positives(reduced_traj, gt)\n\n # Inference\n optimizer.zero_grad()\n traj_logits = model((x_img, x_state))\n y = y.to(device)\n loss = F.cross_entropy(traj_logits, y)\n loss.backward()\n optimizer.step()\n\n # Logging\n loss_val = loss.item()\n train_loss_arr.append(loss_val)\n print(\"[%d] %d - train loss = %f\" % (i, j, loss_val))\n\n # Validation\n model.train(mode=False)\n for j, data in enumerate(val_dataloader):\n\n # Data preparation\n x_state, x_img, gt, idx = data\n x_state = x_state.to(device)\n x_img = x_img.to(device)\n x_state = torch.flatten(x_state, 0, 1)\n reduced_traj = model.trajectories[:, :SAMPLES_PER_SECOND*TRAJ_HORIZON]\n y = get_positives(reduced_traj, gt)\n\n # Inference\n traj_logits = model((x_img, x_state))\n y = y.to(device)\n loss = F.cross_entropy(traj_logits, y)\n\n # Logging\n loss_val = loss.item()\n val_loss_arr.append(loss_val)\n print(\"[%d] %d - val loss = %f\" % (i, j, loss_val))\n\n # Plotting\n if (i+1) % PLOT_PERIOD == 0:\n plot_train_data(train_iterations, val_iterations, i+1, train_loss_arr, val_loss_arr)\n a = input(\"Press Enter to continue...\")\n plt.close('all')\n ", "_____no_output_____" ] ], [ [ "**Dataset debugging**", "_____no_output_____" ] ], [ [ "# Initialize nuScenes\nHELPER_NEEDED = True\nif ENVIRONMENT == 'local':\n if PREPARE_DATASET:\n nusc = NuScenes(version=DATASET_VERSION, dataroot=DATAROOT, verbose=True)\n with open(os.path.join(ROOT, 'nuscenes_checkpoint'+FILENAME_EXT), 'wb') as f:\n pickle.dump(nusc, f, protocol=pickle.HIGHEST_PROTOCOL)\n elif not 'nusc' in locals():\n if HELPER_NEEDED:\n with open(os.path.join(ROOT, 'nuscenes_checkpoint'+FILENAME_EXT), 'rb') as f:\n nusc = pickle.load(f)\nelif ENVIRONMENT == 'colab':\n if PREPARE_DATASET or HELPER_NEEDED:\n nusc = NuScenes(version=DATASET_VERSION, dataroot=DATAROOT, verbose=True)", "_____no_output_____" ], [ "helper = PredictHelper(nusc)\ndataset = nuScenesDataset(helper, preprocessed=PREPROCESSED)\ntrain_dataloader = torch.utils.data.DataLoader(dataset, BATCH_SIZE, True, num_workers=NUM_WORKERS)\ntrain_generator = iter(train_dataloader)", "_____no_output_____" ], [ "# Useful to check ideal number of workers and batch size\nx = time.time()\ntry:\n state, img, gt, idxs = next(train_generator)\nexcept StopIteration:\n train_generator = iter(train_dataloader)\n state, img, gt, idxs = next(train_generator)\nprint(time.time() - x)", "_____no_output_____" ], [ "state, img, gt, idx = dataset[np.random.randint(len(dataset))]\nplt.imshow(img.permute(1, 2, 0))\nplt.show()\nprint(\"State input size:\", state.shape)\nprint(\"Ground truth size:\", gt.shape)", "_____no_output_____" ], [ "instance_token, sample_token = dataset.tokens[idx].split(\"_\")\nlong_gt = torch.Tensor(\n dataset.helper.get_future_for_agent(instance_token, sample_token,\n seconds=100, in_agent_frame=True))\n# TODO: check how to get agent position in the map \nplot_agent_future(img, long_gt, agent_pos=(250,400), reference_frame='local')", "_____no_output_____" ] ], [ [ "**Network debugging**", "_____no_output_____" ] ], [ [ "test_states, test_imgs, test_gts, _ = next(train_generator)\ntest_states = torch.flatten(test_states, 0, 1)\n\nprint(test_imgs.size())\nprint(test_states.size())", "_____no_output_____" ], [ "# Prediction\nmodel = CoverNet(K_SIZE, EPSILON, TRAJ_LINK, TRAJ_DIR, device='cuda:0')\ntraj_logits = model((test_imgs, test_states))\n\n# Output 5 and 10 most likely trajectories for this batch\ntop_5_trajectories = model.trajectories[traj_logits.argsort(descending=True)[:5]]\ntop_10_trajectories = model.trajectories[traj_logits.argsort(descending=True)[:10]]", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code" ] ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ [ [ "import os\nimport shutil", "_____no_output_____" ], [ "labels = os.listdir('../datasets/cifar10png/train/')", "_____no_output_____" ], [ "labels", "_____no_output_____" ], [ "labels.index('automobile')", "_____no_output_____" ], [ "partition = 'train'\ndataset = 'cifar10'\nDIR = os.path.join('../datasets/', dataset+'png', partition)\nOUT_DIR = os.path.join('../datasets/', dataset, partition+'A')\nfor folder in os.listdir(DIR):\n input_path = os.path.join(DIR, folder)\n for image in os.listdir(input_path):\n if image.endswith('.png'):\n img_path = os.path.join(input_path, image)\n filename, ext = image.split('.')\n out_path = os.path.join(OUT_DIR, filename+'_'+str(labels.index(folder))+'.'+ext)\n shutil.copy(img_path, out_path)", "_____no_output_____" ], [ "partition = 'test'\ndataset = 'cifar10'\nDIR = os.path.join('../datasets/', dataset+'png', partition)\nOUT_DIR = os.path.join('../datasets/', dataset, partition+'A')\nfor folder in os.listdir(DIR):\n input_path = os.path.join(DIR, folder)\n for image in os.listdir(input_path):\n if image.endswith('.png'):\n img_path = os.path.join(input_path, image)\n filename, ext = image.split('.')\n out_path = os.path.join(OUT_DIR, filename+'_'+str(labels.index(folder))+'.'+ext)\n shutil.copy(img_path, out_path)", "_____no_output_____" ], [ "partition = 'train'\ndataset = 'cifar100'\nDIR = os.path.join('../datasets/', dataset+'png', partition)\nOUT_DIR = os.path.join('../datasets/', dataset, partition+'A')\nlabels = os.listdir(DIR)\n\nfor folder in os.listdir(DIR):\n input_path = os.path.join(DIR, folder)\n for image in os.listdir(input_path):\n if image.endswith('.png'):\n img_path = os.path.join(input_path, image)\n filename, ext = image.split('.')\n out_path = os.path.join(OUT_DIR, filename+'_'+str(labels.index(folder))+'.'+ext)\n shutil.copy(img_path, out_path)", "_____no_output_____" ], [ "!ls ../datasets/cifar100png/train", "apple\t castle\t fox\t\tmushroom road\t tank\r\naquarium_fish caterpillar girl\toak_tree rocket\t telephone\r\nbaby\t cattle\t hamster\torange\t rose\t television\r\nbear\t chair\t house\torchid\t sea\t tiger\r\nbeaver\t chimpanzee kangaroo\totter\t seal\t tractor\r\nbed\t clock\t keyboard\tpalm_tree shark\t train\r\nbee\t cloud\t lamp\tpear\t shrew\t trout\r\nbeetle\t cockroach lawn_mower\tpickup_truck skunk\t tulip\r\nbicycle couch\t leopard\tpine_tree skyscraper turtle\r\nbottle\t crab\t lion\tplain\t snail\t wardrobe\r\nbowl\t crocodile lizard\tplate\t snake\t whale\r\nboy\t cup\t lobster\tpoppy\t spider\t willow_tree\r\nbridge\t dinosaur man\t\tporcupine squirrel\t wolf\r\nbus\t dolphin\t maple_tree\tpossum\t streetcar woman\r\nbutterfly elephant motorcycle\trabbit\t sunflower worm\r\ncamel\t flatfish mountain\traccoon sweet_pepper\r\ncan\t forest\t mouse\tray\t table\r\n" ], [ "partition = 'test'\ndataset = 'cifar100'\nDIR = os.path.join('../datasets/', dataset+'png', partition)\nOUT_DIR = os.path.join('../datasets/', dataset, partition+'A')\nfor folder in os.listdir(DIR):\n input_path = os.path.join(DIR, folder)\n for image in os.listdir(input_path):\n if image.endswith('.png'):\n img_path = os.path.join(input_path, image)\n filename, ext = image.split('.')\n out_path = os.path.join(OUT_DIR, filename+'_'+str(labels.index(folder))+'.'+ext)\n shutil.copy(img_path, out_path)", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "## OpenVisus Enabled Jupyter Notebook", "_____no_output_____" ], [ "### OpenViSUS: imports and utilities", "_____no_output_____" ] ], [ [ "%matplotlib notebook\n\nimport os,sys\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom ipywidgets import *\n\nimport OpenVisus as ov\n\n# Enable I/O component of OpenVisus\nov.DbModule.attach()", "Requirement already satisfied: OpenVisus in /Users/steve/opt/anaconda3/lib/python3.7/site-packages (1.3.70)\nRequirement already satisfied: numpy in /Users/steve/opt/anaconda3/lib/python3.7/site-packages (from OpenVisus) (1.17.2)\nPythonEngine is working fine\n" ], [ "# function to plot the image data with matplotlib\n# optional parameters: colormap, existing plot to reuse (for more interactivity)\ndef showData(data, cmap=None, plot=None):\n if len(data.shape)==3 and data.shape[0]==1: data=data[0,:,:]\n if len(data.shape)==3 and data.shape[1]==1: data=data[:,0,:] \n if len(data.shape)==3 and data.shape[2]==1: data=data[:,:,0]\n if(plot==None or cmap!=None):\n fig=plt.figure(figsize = (7,5))\n plot = plt.imshow(data, origin='lower', cmap=cmap)\n plt.show()\n return plot\n else:\n plot.set_data(data)\n plt.show()\n return plot\n ", "_____no_output_____" ] ] ]

[ "markdown", "code" ]

[ [ "markdown", "markdown" ], [ "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Computo concurrente\n\n## Multiprocessing", "_____no_output_____" ], [ "El modulo 'multiprocessing' de Python permite la manipulacion y sincronizacion de procesos, tambien ofrece concurrencia local como remota.\n\nEjemplo de motivacion...", "_____no_output_____" ] ], [ [ "import time\ndef calc_cuad(numeros):\n print('Calcula el cuadrado:')\n for n in numeros:\n time.sleep(0.2)\n print('cuadrado:', n*n)\ndef calc_cubo(numeros):\n print('Calcula el cubo:')\n for n in numeros:\n time.sleep(0.2)\n print('cubo:', n*n*n)\n \nnums = range(10)\n\nt = time.time()\ncalc_cuad(nums)\ncalc_cubo(nums)\n\nprint('Finaliza la ejecucion')\nprint('Tiempo de ejecucion', time.time()-t)", "Calcula el cuadrado:\ncuadrado: 0\ncuadrado: 1\ncuadrado: 4\ncuadrado: 9\ncuadrado: 16\ncuadrado: 25\ncuadrado: 36\ncuadrado: 49\ncuadrado: 64\ncuadrado: 81\nCalcula el cubo:\ncubo: 0\ncubo: 1\ncubo: 8\ncubo: 27\ncubo: 64\ncubo: 125\ncubo: 216\ncubo: 343\ncubo: 512\ncubo: 729\nFinaliza la ejecucion\nTiempo de ejecucion 4.024327278137207\n" ] ], [ [ "Una manera sencilla de generar procesos en Python es por medio de la creacion del objeto `Process` y llamarlo por medio del metodo `start()`.", "_____no_output_____" ] ], [ [ "import multiprocessing as mp\n\ndef tarea(nombre):\n print('Hola', nombre)\n for n in range(10000):\n n**(1/(n+1))\n \nif __name__ == '__main__': # Esta condicion se interpreta como una verificacion de si este proceso es el principal\n p = mp.Process(target=tarea, args=('Saul', )) ## Ejecuta la funcion tarea con el los argumentos de args\n p.start() ## Ejecuta p el objeto multiprocess \n p.join()", "Hola Saul\n" ], [ "import multiprocessing as mp\nimport time\n\n\ndef calc_cuad(numeros):\n print('Calcula el cuadrado:')\n for n in numeros:\n time.sleep(0.2)\n print('cuadrado:', n*n)\ndef calc_cubo(numeros):\n print('Calcula el cubo:')\n for n in numeros:\n time.sleep(0.2)\n print('cubo:', n*n*n)\n \nnums = range(10)\n\n\nt1 = time.time()\n\np1 = mp.Process(target=calc_cuad, args=(nums,))\np2 = mp.Process(target=calc_cubo, args=(nums,))\n\np1.start()\np2.start()\np1.join()\np2.join()\n\n\nprint('Tiempo de ejecucion', time.time()-t1)\nprint('Finaliza la ejecucion')", "Calcula el cuadrado:\nCalcula el cubo:\ncuadrado: cubo:0 \n0\ncuadrado: cubo:1 \n1\ncuadrado:cubo: 48\n\ncuadrado:cubo: 927\n\ncuadrado: cubo:16 \n64\ncuadrado: cubo:25\n 125\ncuadrado: 36\ncubo: 216\ncuadrado: 49\ncubo: 343\ncuadrado: 64\ncubo: 512\ncuadrado: 81\ncubo: 729\nTiempo de ejecucion 2.1406450271606445\nFinaliza la ejecucion\n" ] ], [ [ "## Tarea \n\nInvestiga en la documentacion del modulo `Multiprocessing` cual es su funcionamiento y todos los metodos o funciones que estan implementados en el.", "_____no_output_____" ], [ "## Identificadores PID, PPID", "_____no_output_____" ] ], [ [ "import multiprocessing as mp\nimport os\n\nprint('Nombre del proceso:', __name__)\nprint('Proceso padre:', os.getppid())\nprint('Proceso actual:', os.getpid())", "Nombre del proceso: __main__\nProceso padre: 7448\nProceso actual: 8016\n" ], [ "import multiprocessing as mp\nimport os\n\ndef info(titulo):\n print(titulo)\n print('Nombre del proceso:', __name__)\n print('Proceso padre:', os.getppid())\n print('Proceso actual:', os.getpid())\n\ndef f(nombre):\n info('Funcion f')\n print('Hola', nombre)\n print('------------')\n \ninfo('Inicio')\n\np = mp.Process(target = f, args=('Valeriano',))\np.start()\np.join()", "Inicio\nNombre del proceso: __main__\nProceso padre: 7448\nProceso actual: 8016\nFuncion f\nNombre del proceso: __main__\nProceso padre: 8016\nProceso actual: 9690\nHola Valeriano\n------------\n" ] ], [ [ "## Ejercicio\n\nCrea 3 procesos hijos, donde:\n- El primero multiplique 3 numeros (a,b,c)\n- El segundo sume (a,b,c)\n- El tercero haga (a+b)/c\n- Todos devolveran el valor calculado, el nombre de cada proceso hijo y el id del proceso padre.", "_____no_output_____" ] ], [ [ "import multiprocessing as mp\nimport os\n\ndef info(titulo):\n print(titulo)\n print('Nombre del proceso:', __name__)\n print('Proceso actual:', os.getpid())\n print('Proceso padre:', os.getppid())\n \n\ndef primero(a,b,c):\n info('a*b*c =')\n print(a*b*c)\n \ndef segundo(a,b,c):\n info('a+b+c =')\n print(a+b+c)\n \ndef tercero(a,b,c):\n info('(a+b)/c =')\n print((a+b)/c)\n \ninfo('Inicio')\n\n\na = 3\nb = 5\nc = 1\n\np1 = mp.Process(target = primero, args=(a,b,c))\np2 = mp.Process(target = segundo, args=(a,b,c))\np3 = mp.Process(target = tercero, args=(a,b,c))\n\np1.start()\np1.join()\np2.start()\np2.join()\np3.start()\np3.join()", "Inicio\nNombre del proceso: __main__\nProceso actual: 8016\nProceso padre: 7448\na*b*c =\nNombre del proceso: __main__\nProceso actual: 10829\nProceso padre: 8016\n15\na+b+c =\nNombre del proceso: __main__\nProceso actual: 10862\nProceso padre: 8016\n9\n(a+b)/c =\nNombre del proceso: __main__\nProceso actual: 10895\nProceso padre: 8016\n8.0\n" ], [ "import time\n\nnums_res = []\n\ndef calc_cuad(numeros):\n global nums_res\n for n in numeros:\n print('Cuadrado:', n*n)\n nums_res.append(n*n)\n \n \nnums = range(10)\nt = time.time()\np1 = mp.Process(target=calc_cuad, args = (nums,))\n\n\np1.start()\np1.join()\n\nprint('Tiempo de ejecucion: ', time.time()-t)\nprint('Resultado del proceso:', nums_res)\nprint('Finaliza ejecucion')", "Cuadrado: 0\nCuadrado: 1\nCuadrado: 4\nCuadrado: 9\nCuadrado: 16\nCuadrado: 25\nCuadrado: 36\nCuadrado: 49\nCuadrado: 64\nCuadrado: 81\nTiempo de ejecucion: 0.04141974449157715\nResultado del proceso: []\nFinaliza ejecucion\n" ] ], [ [ "# 2020-10-27\n\n## Nombres y terminación de procesos", "_____no_output_____" ] ], [ [ "import multiprocessing\nmultiprocessing.cpu_count()", "_____no_output_____" ] ], [ [ "Con el método `cpu_count()", "_____no_output_____" ] ], [ [ "import time\ndef TareaHijo():\n print(\"Proceso HIJO con PID: {}\".format(multiprocessing.current_process().pid))\n time.sleep(3)\n print(\"Fin del proceso hijo\")\ndef main():\n print(\"Proceso Padre PID: {}\".format(multiprocessing.current_process().pid))\n myProcess = multiprocessing.Process(target=TareaHijo) # Define el objeto myProcess como el objeto que llam[a al proceso]\n myProcess.start()\n myProcess.join()\n# Se acostumbra usar la variable __name__\n# para hacer la ejecución desde el progragrama\n# principal, puede omitirse en los notebooks \nif __name__ == '__main__':\n main()", "Proceso Padre PID: 6703\nProceso HIJO con PID: 7714\nFin del proceso hijo\n" ] ], [ [ "Es posible asignar un nombre a un proceso hijo que ha sido creado, por medio del medio del argumento `name` se asigna el nombre del proceso hijo.", "_____no_output_____" ] ], [ [ "def myProcess():\n print(\"Proceso con nombre: {}\".format(multiprocessing.current_process().name)) ## Metodo current process para obtener el nombre del proceso\n \ndef main():\n childProcess = multiprocessing.Process(target=myProcess, name='Proceso-LCD-cc')\n childProcess.start()\n childProcess.join()\n \nmain()", "Proceso con nombre: Proceso-LCD-cc\n" ], [ "from multiprocessing import Process, current_process\nimport time\n\n\ndef f1():\n pname = current_process().name\n print('Starting process %s...' % pname)\n time.sleep(2)\n print('Exiting process %s...' % pname)\n \n \n\ndef f2():\n pname = current_process().name\n print('Starting process %s...' % pname)\n time.sleep(4)\n print('Exiting process %s...' % pname)\n \n \nif __name__ == '__main__':\n p1 = Process(name='Worker 1', target=f1)\n p2 = Process(name='Worker 2', target=f2)\n p3 = Process(target=f1)\n p1.start()\n p2.start()\n p3.start()\n \n p1.join()\n p2.join()\n p3.join()", "Starting process Worker 1...\nStarting process Worker 2...\nStarting process Process-23...\nExiting process Worker 1...\nExiting process Process-23...\nExiting process Worker 2...\n" ], [ "def TareaProceso():\n proceso_actual = multiprocessing.current_process()\n print(\"Procesos Hijo PID: {}\".format(proceso_actual.pid))\n time.sleep(20)\n proceso_actual = multiprocessing.current_process()\n print(\"Procesos Padre PID: {}\".format(proceso_actual.pid))\n \nmiProceso = multiprocessing.Process(target=TareaProceso)\nmiProceso.start()\n\n\n\nprint(\"Proceso Padre ha terminado, termina el proceso main\")\nprint(\"Terminando el proceso Hijo...\")\ntime.sleep(1)\nmiProceso.terminate()\n#miProceso.join()\nprint(\"Proceso Hijo ha terminado exitosamente\")\n", "Procesos Hijo PID: 8953\nProceso Padre ha terminado, termina el proceso main\nTerminando el proceso Hijo...\nProceso Hijo ha terminado exitosamente\n" ], [ "multiprocessing.cpu_count()", "_____no_output_____" ] ], [ [ "### Ejercicio:\n\n1. Vamos a crear 3 procesos los cuales tendrán nombre y código definido como funP1, funP2, funP3. Cada hijo escribirá su nombre, su PID y el PID del padre, además de hacer un cálculo sobre tres valores a, b y c.\n2. El proceso 1 calcula a*b + c, el proceso 2 calcula a*b*c y el proceso 3 calcula (a*b)/c\n3. Crea un mecanismo para terminar alguno de los procesos de manera aleatoria.", "_____no_output_____" ] ], [ [ "import multiprocessing as mp\nimport os\nimport random\n\ndef info(titulo):\n pname = current_process().name\n print('Nombre del proceso: %s...' % pname)\n print(titulo)\n print('Proceso actual:', os.getpid())\n print('Proceso padre:', os.getppid())\n \n\ndef funP1(a,b,c):\n info('a*b + c =')\n print(a*b + c)\n \ndef funP2(a,b,c):\n info('a*b*c =')\n print(a*b*c)\n \ndef funP3(a,b,c):\n info('(a+b)/c =')\n print((a+b)/c)\n\n\na = 3\nb = 5\nc = 1\n\np1 = mp.Process(name = 'funP1',target = funP1, args=(a,b,c))\np2 = mp.Process(name = 'funP2',target = funP2, args=(a,b,c))\np3 = mp.Process(name = 'funP3',target = funP3, args=(a,b,c))\n\n\np1.start()\np2.start()\np3.start()\n\ni = random.randint(1,3)\n\nif i==1:\n p1.terminate()\nelif i == 2:\n p2.terminate()\nelif i == 3:\n p3.terminate()\n\n\np1.join()\np2.join()\np3.join()", "Nombre del proceso: funP2...\na*b*c =\nProceso actual: 15004\nProceso padre: 6703\n15\nNombre del proceso: funP1...\na*b + c =\nProceso actual: 15003\nProceso padre: 6703\n16\n" ] ], [ [ "No obstante , a veces se requiere crear procesos que corran en silencio (*background*) y no bloquear el proceso principal al finalizarlos. Esta especificación es comunmente utilizada cuando el proceso principal no tiene la certeza de interrumpir un proceso después de esperar cierto tiempo o finalizar sin que haya terminado el proceso hijo sin afectaciones al resultado final\n\nEstos procesos se llaman **Procesos demonio** (*daemon processes*). Por medio del atributo `daemon` del método `Process` se crea un proceso de este tipo.\n\nEl valor por defecto del atributo `daemon` es False, por tanto se establece a `True`para crear el proceso demonio.", "_____no_output_____" ] ], [ [ "from multiprocessing import Process, current_process\nimport time\n\ndef f1():\n p = current_process()\n print('Starting process %s, ID %s....' %(p.name, p.pid))\n time.sleep(8)\n print('Starting process %s, ID, %s....' %(p.name, p.pid))\n \ndef f2():\n p = current_process()\n print('Starting process %s, ID %s....' %(p.name, p.pid))\n time.sleep(2)\n print('Starting process %s, ID %s....' %(p.name, p.pid))\n \n \nif __name__ == '__main__':\n p1 = Process(name='Worker 1', target=f1)\n p1.daemon = True\n p2 = Process(name='Worker 2', target=f2)\n \n p1.start()\n time.sleep(1)\n p2.start()\n \n # p1.join()\n # p2.join()\n # p3.join()", "Starting process Worker 1, ID 15700....\nStarting process Worker 2, ID 15705....\nStarting process Worker 2, ID 15705....\nStarting process Worker 1, ID, 15700....\n" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Sentiment Classification & How To \"Frame Problems\" for a Neural Network\n\nby Andrew Trask\n\n- **Twitter**: @iamtrask\n- **Blog**: http://iamtrask.github.io", "_____no_output_____" ], [ "### What You Should Already Know\n\n- neural networks, forward and back-propagation\n- stochastic gradient descent\n- mean squared error\n- and train/test splits\n\n### Where to Get Help if You Need it\n- Re-watch previous Udacity Lectures\n- Leverage the recommended Course Reading Material - [Grokking Deep Learning](https://www.manning.com/books/grokking-deep-learning) (Check inside your classroom for a discount code)\n- Shoot me a tweet @iamtrask\n\n\n### Tutorial Outline:\n\n- Intro: The Importance of \"Framing a Problem\" (this lesson)\n\n- [Curate a Dataset](#lesson_1)\n- [Developing a \"Predictive Theory\"](#lesson_2)\n- [**PROJECT 1**: Quick Theory Validation](#project_1)\n\n\n- [Transforming Text to Numbers](#lesson_3)\n- [**PROJECT 2**: Creating the Input/Output Data](#project_2)\n\n\n- Putting it all together in a Neural Network (video only - nothing in notebook)\n- [**PROJECT 3**: Building our Neural Network](#project_3)\n\n\n- [Understanding Neural Noise](#lesson_4)\n- [**PROJECT 4**: Making Learning Faster by Reducing Noise](#project_4)\n\n\n- [Analyzing Inefficiencies in our Network](#lesson_5)\n- [**PROJECT 5**: Making our Network Train and Run Faster](#project_5)\n\n\n- [Further Noise Reduction](#lesson_6)\n- [**PROJECT 6**: Reducing Noise by Strategically Reducing the Vocabulary](#project_6)\n\n\n- [Analysis: What's going on in the weights?](#lesson_7)", "_____no_output_____" ], [ "# Lesson: Curate a Dataset<a id='lesson_1'></a>\nThe cells from here until Project 1 include code Andrew shows in the videos leading up to mini project 1. We've included them so you can run the code along with the videos without having to type in everything.", "_____no_output_____" ] ], [ [ "def pretty_print_review_and_label(i):\n print(labels[i] + \"\\t:\\t\" + reviews[i][:80] + \"...\")\n\ng = open('reviews.txt','r') # What we know!\nreviews = list(map(lambda x:x[:-1],g.readlines()))\ng.close()\n\ng = open('labels.txt','r') # What we WANT to know!\nlabels = list(map(lambda x:x[:-1].upper(),g.readlines()))\ng.close()", "_____no_output_____" ] ], [ [ "**Note:** The data in `reviews.txt` we're using has already been preprocessed a bit and contains only lower case characters. If we were working from raw data, where we didn't know it was all lower case, we would want to add a step here to convert it. That's so we treat different variations of the same word, like `The`, `the`, and `THE`, all the same way.", "_____no_output_____" ] ], [ [ "len(reviews)", "_____no_output_____" ], [ "reviews[0]", "_____no_output_____" ], [ "labels[0]", "_____no_output_____" ] ], [ [ "# Lesson: Develop a Predictive Theory<a id='lesson_2'></a>", "_____no_output_____" ] ], [ [ "print(\"labels.txt \\t : \\t reviews.txt\\n\")\npretty_print_review_and_label(2137)\npretty_print_review_and_label(12816)\npretty_print_review_and_label(6267)\npretty_print_review_and_label(21934)\npretty_print_review_and_label(5297)\npretty_print_review_and_label(4998)", "labels.txt \t : \t reviews.txt\n\nNEGATIVE\t:\tthis movie is terrible but it has some good effects . ...\nPOSITIVE\t:\tadrian pasdar is excellent is this film . he makes a fascinating woman . ...\nNEGATIVE\t:\tcomment this movie is impossible . is terrible very improbable bad interpretat...\nPOSITIVE\t:\texcellent episode movie ala pulp fiction . days suicides . it doesnt get more...\nNEGATIVE\t:\tif you haven t seen this it s terrible . it is pure trash . i saw this about ...\nPOSITIVE\t:\tthis schiffer guy is a real genius the movie is of excellent quality and both e...\n" ] ], [ [ "# Project 1: Quick Theory Validation<a id='project_1'></a>\n\nThere are multiple ways to implement these projects, but in order to get your code closer to what Andrew shows in his solutions, we've provided some hints and starter code throughout this notebook.\n\nYou'll find the [Counter](https://docs.python.org/2/library/collections.html#collections.Counter) class to be useful in this exercise, as well as the [numpy](https://docs.scipy.org/doc/numpy/reference/) library.", "_____no_output_____" ] ], [ [ "from collections import Counter\nimport numpy as np", "_____no_output_____" ] ], [ [ "We'll create three `Counter` objects, one for words from postive reviews, one for words from negative reviews, and one for all the words.", "_____no_output_____" ] ], [ [ "# Create three Counter objects to store positive, negative and total counts\npositive_counts = Counter()\nnegative_counts = Counter()\ntotal_counts = Counter()", "_____no_output_____" ] ], [ [ "**TODO:** Examine all the reviews. For each word in a positive review, increase the count for that word in both your positive counter and the total words counter; likewise, for each word in a negative review, increase the count for that word in both your negative counter and the total words counter.\n\n**Note:** Throughout these projects, you should use `split(' ')` to divide a piece of text (such as a review) into individual words. If you use `split()` instead, you'll get slightly different results than what the videos and solutions show.", "_____no_output_____" ] ], [ [ "for i in range(len(reviews)):\n if(labels[i] == 'POSITIVE'):\n for word in reviews[i].split(\" \"):\n positive_counts[word] += 1\n total_counts[word] += 1\n else:\n for word in reviews[i].split(\" \"):\n negative_counts[word] += 1\n total_counts[word] += 1", "_____no_output_____" ] ], [ [ "Run the following two cells to list the words used in positive reviews and negative reviews, respectively, ordered from most to least commonly used. ", "_____no_output_____" ] ], [ [ "# Examine the counts of the most common words in positive reviews\npositive_counts.most_common()", "_____no_output_____" ], [ "# Examine the counts of the most common words in negative reviews\nnegative_counts.most_common()", "_____no_output_____" ] ], [ [ "As you can see, common words like \"the\" appear very often in both positive and negative reviews. Instead of finding the most common words in positive or negative reviews, what you really want are the words found in positive reviews more often than in negative reviews, and vice versa. To accomplish this, you'll need to calculate the **ratios** of word usage between positive and negative reviews.\n\n**TODO:** Check all the words you've seen and calculate the ratio of postive to negative uses and store that ratio in `pos_neg_ratios`. \n>Hint: the positive-to-negative ratio for a given word can be calculated with `positive_counts[word] / float(negative_counts[word]+1)`. Notice the `+1` in the denominator – that ensures we don't divide by zero for words that are only seen in positive reviews.", "_____no_output_____" ] ], [ [ "# Create Counter object to store positive/negative ratios\npos_neg_ratios = Counter()\n\n# TODO: Calculate the ratios of positive and negative uses of the most common words\n# Consider words to be \"common\" if they've been used at least 100 times\n# for word, count in total_counts.most_common():\n# if count > 100:\n# neg_ratio = positive_counts[word] / float(negative_counts[word] + 1)\n# pos_neg_ratios[word] = neg_ratio\n \nfor term,count in total_counts.most_common():\n if(count > 100):\n pos_neg_ratio = positive_counts[term] / float(negative_counts[term]+1)\n pos_neg_ratios[term] = pos_neg_ratio", "_____no_output_____" ] ], [ [ "Examine the ratios you've calculated for a few words:", "_____no_output_____" ] ], [ [ "print(\"Pos-to-neg ratio for 'the' = {}\".format(pos_neg_ratios[\"the\"]))\nprint(\"Pos-to-neg ratio for 'amazing' = {}\".format(pos_neg_ratios[\"amazing\"]))\nprint(\"Pos-to-neg ratio for 'terrible' = {}\".format(pos_neg_ratios[\"terrible\"]))", "Pos-to-neg ratio for 'the' = 1.0607993145235326\nPos-to-neg ratio for 'amazing' = 4.022813688212928\nPos-to-neg ratio for 'terrible' = 0.17744252873563218\n" ] ], [ [ "Looking closely at the values you just calculated, we see the following:\n\n* Words that you would expect to see more often in positive reviews – like \"amazing\" – have a ratio greater than 1. The more skewed a word is toward postive, the farther from 1 its positive-to-negative ratio will be.\n* Words that you would expect to see more often in negative reviews – like \"terrible\" – have positive values that are less than 1. The more skewed a word is toward negative, the closer to zero its positive-to-negative ratio will be.\n* Neutral words, which don't really convey any sentiment because you would expect to see them in all sorts of reviews – like \"the\" – have values very close to 1. A perfectly neutral word – one that was used in exactly the same number of positive reviews as negative reviews – would be almost exactly 1. The `+1` we suggested you add to the denominator slightly biases words toward negative, but it won't matter because it will be a tiny bias and later we'll be ignoring words that are too close to neutral anyway.\n\nOk, the ratios tell us which words are used more often in postive or negative reviews, but the specific values we've calculated are a bit difficult to work with. A very positive word like \"amazing\" has a value above 4, whereas a very negative word like \"terrible\" has a value around 0.18. Those values aren't easy to compare for a couple of reasons:\n\n* Right now, 1 is considered neutral, but the absolute value of the postive-to-negative rations of very postive words is larger than the absolute value of the ratios for the very negative words. So there is no way to directly compare two numbers and see if one word conveys the same magnitude of positive sentiment as another word conveys negative sentiment. So we should center all the values around netural so the absolute value from neutral of the postive-to-negative ratio for a word would indicate how much sentiment (positive or negative) that word conveys.\n* When comparing absolute values it's easier to do that around zero than one. \n\nTo fix these issues, we'll convert all of our ratios to new values using logarithms.\n\n**TODO:** Go through all the ratios you calculated and convert them to logarithms. (i.e. use `np.log(ratio)`)\n\nIn the end, extremely positive and extremely negative words will have positive-to-negative ratios with similar magnitudes but opposite signs.", "_____no_output_____" ] ], [ [ "# TODO: Convert ratios to logs\nfor word, ratio in pos_neg_ratios.most_common():\n pos_neg_ratios[word] = np.log(ratio)", "_____no_output_____" ] ], [ [ "Examine the new ratios you've calculated for the same words from before:", "_____no_output_____" ] ], [ [ "print(\"Pos-to-neg ratio for 'the' = {}\".format(pos_neg_ratios[\"the\"]))\nprint(\"Pos-to-neg ratio for 'amazing' = {}\".format(pos_neg_ratios[\"amazing\"]))\nprint(\"Pos-to-neg ratio for 'terrible' = {}\".format(pos_neg_ratios[\"terrible\"]))", "Pos-to-neg ratio for 'the' = 0.05902269426102881\nPos-to-neg ratio for 'amazing' = 1.3919815802404802\nPos-to-neg ratio for 'terrible' = -1.7291085042663878\n" ] ], [ [ "If everything worked, now you should see neutral words with values close to zero. In this case, \"the\" is near zero but slightly positive, so it was probably used in more positive reviews than negative reviews. But look at \"amazing\"'s ratio - it's above `1`, showing it is clearly a word with positive sentiment. And \"terrible\" has a similar score, but in the opposite direction, so it's below `-1`. It's now clear that both of these words are associated with specific, opposing sentiments.\n\nNow run the following cells to see more ratios. \n\nThe first cell displays all the words, ordered by how associated they are with postive reviews. (Your notebook will most likely truncate the output so you won't actually see *all* the words in the list.)\n\nThe second cell displays the 30 words most associated with negative reviews by reversing the order of the first list and then looking at the first 30 words. (If you want the second cell to display all the words, ordered by how associated they are with negative reviews, you could just write `reversed(pos_neg_ratios.most_common())`.)\n\nYou should continue to see values similar to the earlier ones we checked – neutral words will be close to `0`, words will get more positive as their ratios approach and go above `1`, and words will get more negative as their ratios approach and go below `-1`. That's why we decided to use the logs instead of the raw ratios.", "_____no_output_____" ] ], [ [ "# words most frequently seen in a review with a \"POSITIVE\" label\npos_neg_ratios.most_common()", "_____no_output_____" ], [ "# words most frequently seen in a review with a \"NEGATIVE\" label\nlist(reversed(pos_neg_ratios.most_common()))[0:30]\n\n# Note: Above is the code Andrew uses in his solution video, \n# so we've included it here to avoid confusion.\n# If you explore the documentation for the Counter class, \n# you will see you could also find the 30 least common\n# words like this: pos_neg_ratios.most_common()[:-31:-1]", "_____no_output_____" ] ], [ [ "# End of Project 1. \n## Watch the next video to see Andrew's solution, then continue on to the next lesson.\n\n# Transforming Text into Numbers<a id='lesson_3'></a>\nThe cells here include code Andrew shows in the next video. We've included it so you can run the code along with the video without having to type in everything.", "_____no_output_____" ] ], [ [ "from IPython.display import Image\n\nreview = \"This was a horrible, terrible movie.\"\n\nImage(filename='sentiment_network.png')", "_____no_output_____" ], [ "review = \"The movie was excellent\"\n\nImage(filename='sentiment_network_pos.png')", "_____no_output_____" ] ], [ [ "# Project 2: Creating the Input/Output Data<a id='project_2'></a>\n\n**TODO:** Create a [set](https://docs.python.org/3/tutorial/datastructures.html#sets) named `vocab` that contains every word in the vocabulary.", "_____no_output_____" ] ], [ [ "# TODO: Create set named \"vocab\" containing all of the words from all of the reviews\nvocab = list(total_counts)", "_____no_output_____" ] ], [ [ "Run the following cell to check your vocabulary size. If everything worked correctly, it should print **74074**", "_____no_output_____" ] ], [ [ "vocab_size = len(vocab)\nprint(vocab_size)", "74074\n" ] ], [ [ "Take a look at the following image. It represents the layers of the neural network you'll be building throughout this notebook. `layer_0` is the input layer, `layer_1` is a hidden layer, and `layer_2` is the output layer.", "_____no_output_____" ] ], [ [ "from IPython.display import Image\nImage(filename='sentiment_network_2.png')", "_____no_output_____" ] ], [ [ "**TODO:** Create a numpy array called `layer_0` and initialize it to all zeros. You will find the [zeros](https://docs.scipy.org/doc/numpy/reference/generated/numpy.zeros.html) function particularly helpful here. Be sure you create `layer_0` as a 2-dimensional matrix with 1 row and `vocab_size` columns. ", "_____no_output_____" ] ], [ [ "# TODO: Create layer_0 matrix with dimensions 1 by vocab_size, initially filled with zeros\nlayer_0 = np.zeros((1, vocab_size))", "_____no_output_____" ] ], [ [ "Run the following cell. It should display `(1, 74074)`", "_____no_output_____" ] ], [ [ "layer_0.shape", "_____no_output_____" ], [ "from IPython.display import Image\nImage(filename='sentiment_network.png')", "_____no_output_____" ] ], [ [ "`layer_0` contains one entry for every word in the vocabulary, as shown in the above image. We need to make sure we know the index of each word, so run the following cell to create a lookup table that stores the index of every word.", "_____no_output_____" ] ], [ [ "# Create a dictionary of words in the vocabulary mapped to index positions\n# (to be used in layer_0)\nword2index = {}\nfor i, word in enumerate(vocab):\n word2index[word] = i\n \n# display the map of words to indices\nword2index", "_____no_output_____" ] ], [ [ "**TODO:** Complete the implementation of `update_input_layer`. It should count \n how many times each word is used in the given review, and then store\n those counts at the appropriate indices inside `layer_0`.", "_____no_output_____" ] ], [ [ "def update_input_layer(review):\n \"\"\" Modify the global layer_0 to represent the vector form of review.\n The element at a given index of layer_0 should represent\n how many times the given word occurs in the review.\n Args:\n review(string) - the string of the review\n Returns:\n None\n \"\"\"\n global layer_0\n # clear out previous state by resetting the layer to be all 0s\n layer_0 *= 0\n \n # TODO: count how many times each word is used in the given review and store the results in layer_0 \n# print(total_counts.most_common())\n for word in review.split(\" \"):\n layer_0[0][word2index[word]] += 1", "_____no_output_____" ] ], [ [ "Run the following cell to test updating the input layer with the first review. The indices assigned may not be the same as in the solution, but hopefully you'll see some non-zero values in `layer_0`. ", "_____no_output_____" ] ], [ [ "update_input_layer(reviews[0])\nlayer_0", "_____no_output_____" ] ], [ [ "**TODO:** Complete the implementation of `get_target_for_labels`. It should return `0` or `1`, \n depending on whether the given label is `NEGATIVE` or `POSITIVE`, respectively.", "_____no_output_____" ] ], [ [ "def get_target_for_label(label):\n \"\"\"Convert a label to `0` or `1`.\n Args:\n label(string) - Either \"POSITIVE\" or \"NEGATIVE\".\n Returns:\n `0` or `1`.\n \"\"\"\n if label == 'POSITIVE':\n return 1\n \n return 0\n # TODO: Your code here", "_____no_output_____" ] ], [ [ "Run the following two cells. They should print out`'POSITIVE'` and `1`, respectively.", "_____no_output_____" ] ], [ [ "labels[0]", "_____no_output_____" ], [ "get_target_for_label(labels[0])", "_____no_output_____" ] ], [ [ "Run the following two cells. They should print out `'NEGATIVE'` and `0`, respectively.", "_____no_output_____" ] ], [ [ "labels[1]", "_____no_output_____" ], [ "get_target_for_label(labels[1])", "_____no_output_____" ] ], [ [ "# End of Project 2. \n## Watch the next video to see Andrew's solution, then continue on to the next lesson.", "_____no_output_____" ], [ "# Project 3: Building a Neural Network<a id='project_3'></a>", "_____no_output_____" ], [ "**TODO:** We've included the framework of a class called `SentimentNetork`. Implement all of the items marked `TODO` in the code. These include doing the following:\n- Create a basic neural network much like the networks you've seen in earlier lessons and in Project 1, with an input layer, a hidden layer, and an output layer. \n- Do **not** add a non-linearity in the hidden layer. That is, do not use an activation function when calculating the hidden layer outputs.\n- Re-use the code from earlier in this notebook to create the training data (see `TODO`s in the code)\n- Implement the `pre_process_data` function to create the vocabulary for our training data generating functions\n- Ensure `train` trains over the entire corpus", "_____no_output_____" ], [ "### Where to Get Help if You Need it\n- Re-watch earlier Udacity lectures\n- Chapters 3-5 - [Grokking Deep Learning](https://www.manning.com/books/grokking-deep-learning) - (Check inside your classroom for a discount code)", "_____no_output_____" ] ], [ [ "import time\nimport sys\nimport numpy as np\n\n# Encapsulate our neural network in a class\nclass SentimentNetwork:\n def __init__(self, reviews, labels, hidden_nodes = 10, learning_rate = 0.001):\n \"\"\"Create a SentimenNetwork with the given settings\n Args:\n reviews(list) - List of reviews used for training\n labels(list) - List of POSITIVE/NEGATIVE labels associated with the given reviews\n hidden_nodes(int) - Number of nodes to create in the hidden layer\n learning_rate(float) - Learning rate to use while training\n \n \"\"\"\n # Assign a seed to our random number generator to ensure we get\n # reproducable results during development \n np.random.seed(1)\n\n # process the reviews and their associated labels so that everything\n # is ready for training\n self.pre_process_data(reviews, labels)\n \n # Build the network to have the number of hidden nodes and the learning rate that\n # were passed into this initializer. Make the same number of input nodes as\n # there are vocabulary words and create a single output node.\n self.init_network(len(self.review_vocab), hidden_nodes, 1, learning_rate)\n\n def pre_process_data(self, reviews, labels):\n # populate review_vocab with all of the words in the given reviews\n review_vocab = set()\n for review in reviews:\n for word in review.split(\" \"):\n review_vocab.add(word)\n\n # Convert the vocabulary set to a list so we can access words via indices\n self.review_vocab = list(review_vocab)\n \n # populate label_vocab with all of the words in the given labels.\n label_vocab = set()\n for label in labels:\n label_vocab.add(label)\n \n # Convert the label vocabulary set to a list so we can access labels via indices\n self.label_vocab = list(label_vocab)\n \n # Store the sizes of the review and label vocabularies.\n self.review_vocab_size = len(self.review_vocab)\n self.label_vocab_size = len(self.label_vocab)\n \n # Create a dictionary of words in the vocabulary mapped to index positions\n self.word2index = {}\n for i, word in enumerate(self.review_vocab):\n self.word2index[word] = i\n \n # Create a dictionary of labels mapped to index positions\n self.label2index = {}\n for i, label in enumerate(self.label_vocab):\n self.label2index[label] = i\n \n def init_network(self, input_nodes, hidden_nodes, output_nodes, learning_rate):\n # Store the number of nodes in input, hidden, and output layers.\n self.input_nodes = input_nodes\n self.hidden_nodes = hidden_nodes\n self.output_nodes = output_nodes\n\n # Store the learning rate\n self.learning_rate = learning_rate\n\n # Initialize weights\n \n self.weights_0_1 = np.zeros((self.input_nodes,self.hidden_nodes))\n \n # These are the weights between the hidden layer and the output layer.\n self.weights_1_2 = np.random.normal(0.0, self.output_nodes**-0.5, \n (self.hidden_nodes, self.output_nodes))\n \n # The input layer, a two-dimensional matrix with shape 1 x input_nodes\n self.layer_0 = np.zeros((1,input_nodes))\n \n \n def update_input_layer(self,review):\n\n # clear out previous state, reset the layer to be all 0s\n self.layer_0 *= 0\n \n for word in review.split(\" \"):\n # NOTE: This if-check was not in the version of this method created in Project 2,\n # and it appears in Andrew's Project 3 solution without explanation. \n # It simply ensures the word is actually a key in word2index before\n # accessing it, which is important because accessing an invalid key\n # with raise an exception in Python. This allows us to ignore unknown\n # words encountered in new reviews.\n if(word in self.word2index.keys()):\n self.layer_0[0][self.word2index[word]] += 1\n \n def get_target_for_label(self,label):\n if(label == 'POSITIVE'):\n return 1\n else:\n return 0\n \n def sigmoid(self,x):\n return 1 / (1 + np.exp(-x))\n \n def sigmoid_output_2_derivative(self,output):\n return output * (1 - output)\n\n def train(self, training_reviews, training_labels):\n \n # make sure out we have a matching number of reviews and labels\n assert(len(training_reviews) == len(training_labels))\n \n # Keep track of correct predictions to display accuracy during training \n correct_so_far = 0\n \n # Remember when we started for printing time statistics\n start = time.time()\n\n # loop through all the given reviews and run a forward and backward pass,\n # updating weights for every item\n for i in range(len(training_reviews)):\n review = training_reviews[i]\n label = training_labels[i]\n \n #### Implement the forward pass here ####\n ### Forward pass ###\n\n # Input Layer\n self.update_input_layer(review)\n\n # Hidden layer\n layer_1 = self.layer_0.dot(self.weights_0_1)\n\n # Output layer\n layer_2 = self.sigmoid(layer_1.dot(self.weights_1_2))\n \n layer_2_error = layer_2 - self.get_target_for_label(label) # Output layer error is the difference between desired target and actual output.\n layer_2_delta = layer_2_error * self.sigmoid_output_2_derivative(layer_2)\n\n # Backpropagated error\n layer_1_error = layer_2_delta.dot(self.weights_1_2.T) # errors propagated to the hidden layer\n layer_1_delta = layer_1_error # hidden layer gradients - no nonlinearity so it's the same as the error\n\n # Update the weights\n self.weights_1_2 -= layer_1.T.dot(layer_2_delta) * self.learning_rate # update hidden-to-output weights with gradient descent step\n self.weights_0_1 -= self.layer_0.T.dot(layer_1_delta) * self.learning_rate \n # TODO: Implement the back propagation pass here. \n # That means calculate the error for the forward pass's prediction\n # and update the weights in the network according to their\n # contributions toward the error, as calculated via the\n # gradient descent and back propagation algorithms you \n # learned in class.\n \n # TODO: Keep track of correct predictions. To determine if the prediction was\n # correct, check that the absolute value of the output error \n # is less than 0.5. If so, add one to the correct_so_far count.\n if(layer_2 >= 0.5 and label == 'POSITIVE'):\n correct_so_far += 1\n elif(layer_2 < 0.5 and label == 'NEGATIVE'):\n correct_so_far += 1\n \n # For debug purposes, print out our prediction accuracy and speed \n # throughout the training process. \n\n elapsed_time = float(time.time() - start)\n reviews_per_second = i / elapsed_time if elapsed_time > 0 else 0\n \n sys.stdout.write(\"\\rProgress:\" + str(100 * i/float(len(training_reviews)))[:4] \\\n + \"% Speed(reviews/sec):\" + str(reviews_per_second)[0:5] \\\n + \" #Correct:\" + str(correct_so_far) + \" #Trained:\" + str(i+1) \\\n + \" Training Accuracy:\" + str(correct_so_far * 100 / float(i+1))[:4] + \"%\")\n if(i % 2500 == 0):\n print(\"\")\n \n def test(self, testing_reviews, testing_labels):\n \"\"\"\n Attempts to predict the labels for the given testing_reviews,\n and uses the test_labels to calculate the accuracy of those predictions.\n \"\"\"\n \n # keep track of how many correct predictions we make\n correct = 0\n\n # we'll time how many predictions per second we make\n start = time.time()\n\n # Loop through each of the given reviews and call run to predict\n # its label. \n for i in range(len(testing_reviews)):\n pred = self.run(testing_reviews[i])\n# print(layer_2.shape)\n if(pred == testing_labels[i]):\n correct += 1\n \n # For debug purposes, print out our prediction accuracy and speed \n # throughout the prediction process. \n\n elapsed_time = float(time.time() - start)\n reviews_per_second = i / elapsed_time if elapsed_time > 0 else 0\n \n sys.stdout.write(\"\\rProgress:\" + str(100 * i/float(len(testing_reviews)))[:4] \\\n + \"% Speed(reviews/sec):\" + str(reviews_per_second)[0:5] \\\n + \" #Correct:\" + str(correct) + \" #Tested:\" + str(i+1) \\\n + \" Testing Accuracy:\" + str(correct * 100 / float(i+1))[:4] + \"%\")\n \n def run(self, review):\n \"\"\"\n Returns a POSITIVE or NEGATIVE prediction for the given review.\n \"\"\"\n # Run a forward pass through the network, like in the \"train\" function.\n \n # Input Layer\n self.update_input_layer(review.lower())\n\n # Hidden layer\n layer_1 = self.layer_0.dot(self.weights_0_1)\n\n # Output layer\n layer_2 = self.sigmoid(layer_1.dot(self.weights_1_2))\n \n # Return POSITIVE for values above greater-than-or-equal-to 0.5 in the output layer;\n # return NEGATIVE for other values\n if(layer_2 >= 0.5):\n return \"POSITIVE\"\n else:\n return \"NEGATIVE\"", "_____no_output_____" ] ], [ [ "Run the following cell to create a `SentimentNetwork` that will train on all but the last 1000 reviews (we're saving those for testing). Here we use a learning rate of `0.1`.", "_____no_output_____" ] ], [ [ "mlp = SentimentNetwork(reviews[:-1000],labels[:-1000], learning_rate=0.1)", "_____no_output_____" ] ], [ [ "Run the following cell to test the network's performance against the last 1000 reviews (the ones we held out from our training set). \n\n**We have not trained the model yet, so the results should be about 50% as it will just be guessing and there are only two possible values to choose from.**", "_____no_output_____" ] ], [ [ "mlp.test(reviews[-1000:],labels[-1000:])", "Progress:48.8% Speed(reviews/sec):800.1 #Correct:245 #Tested:489 Testing Accuracy:50.1%Progress:99.9% Speed(reviews/sec):777.5 #Correct:500 #Tested:1000 Testing Accuracy:50.0%" ] ], [ [ "Run the following cell to actually train the network. During training, it will display the model's accuracy repeatedly as it trains so you can see how well it's doing.", "_____no_output_____" ] ], [ [ "mlp.train(reviews[:-1000],labels[:-1000])", "Progress:0.0% Speed(reviews/sec):0.0 #Correct:1 #Trained:1 Training Accuracy:100.%\nProgress:10.4% Speed(reviews/sec):246.6 #Correct:1251 #Trained:2501 Training Accuracy:50.0%\nProgress:11.4% Speed(reviews/sec):247.1 #Correct:1369 #Trained:2737 Training Accuracy:50.0%" ] ], [ [ "That most likely didn't train very well. Part of the reason may be because the learning rate is too high. Run the following cell to recreate the network with a smaller learning rate, `0.01`, and then train the new network.", "_____no_output_____" ] ], [ [ "mlp = SentimentNetwork(reviews[:-1000],labels[:-1000], learning_rate=0.01)\nmlp.train(reviews[:-1000],labels[:-1000])", "Progress:0.0% Speed(reviews/sec):0.0 #Correct:1 #Trained:1 Training Accuracy:100.%\nProgress:9.72% Speed(reviews/sec):239.4 #Correct:1165 #Trained:2334 Training Accuracy:49.9%" ] ], [ [ "That probably wasn't much different. Run the following cell to recreate the network one more time with an even smaller learning rate, `0.001`, and then train the new network.", "_____no_output_____" ] ], [ [ "mlp = SentimentNetwork(reviews[:-1000],labels[:-1000], learning_rate=0.001)\nmlp.train(reviews[:-1000],labels[:-1000])", "Progress:0.0% Speed(reviews/sec):0.0 #Correct:1 #Trained:1 Training Accuracy:100.%\nProgress:10.4% Speed(reviews/sec):249.0 #Correct:1267 #Trained:2501 Training Accuracy:50.6%\nProgress:20.8% Speed(reviews/sec):248.8 #Correct:2655 #Trained:5001 Training Accuracy:53.0%\nProgress:31.2% Speed(reviews/sec):249.5 #Correct:4087 #Trained:7501 Training Accuracy:54.4%\nProgress:41.6% Speed(reviews/sec):250.9 #Correct:5535 #Trained:10001 Training Accuracy:55.3%\nProgress:49.3% Speed(reviews/sec):248.1 #Correct:6674 #Trained:11835 Training Accuracy:56.3%" ] ], [ [ "With a learning rate of `0.001`, the network should finall have started to improve during training. It's still not very good, but it shows that this solution has potential. We will improve it in the next lesson.", "_____no_output_____" ], [ "# End of Project 3. \n## Watch the next video to see Andrew's solution, then continue on to the next lesson.", "_____no_output_____" ], [ "# Understanding Neural Noise<a id='lesson_4'></a>\n\nThe following cells include includes the code Andrew shows in the next video. We've included it here so you can run the cells along with the video without having to type in everything.", "_____no_output_____" ] ], [ [ "from IPython.display import Image\nImage(filename='sentiment_network.png')", "_____no_output_____" ], [ "def update_input_layer(review):\n \n global layer_0\n \n # clear out previous state, reset the layer to be all 0s\n layer_0 *= 0\n for word in review.split(\" \"):\n layer_0[0][word2index[word]] += 1\n\nupdate_input_layer(reviews[0])", "_____no_output_____" ], [ "layer_0", "_____no_output_____" ], [ "review_counter = Counter()", "_____no_output_____" ], [ "for word in reviews[0].split(\" \"):\n review_counter[word] += 1", "_____no_output_____" ], [ "review_counter.most_common()", "_____no_output_____" ] ], [ [ "# Project 4: Reducing Noise in Our Input Data<a id='project_4'></a>\n\n**TODO:** Attempt to reduce the noise in the input data like Andrew did in the previous video. Specifically, do the following:\n* Copy the `SentimentNetwork` class you created earlier into the following cell.\n* Modify `update_input_layer` so it does not count how many times each word is used, but rather just stores whether or not a word was used. ", "_____no_output_____" ] ], [ [ "# TODO: -Copy the SentimentNetwork class from Projet 3 lesson\n# -Modify it to reduce noise, like in the video \nimport time\nimport sys\nimport numpy as np\n\n# Encapsulate our neural network in a class\nclass SentimentNetwork:\n def __init__(self, reviews, labels, hidden_nodes = 10, learning_rate = 0.001):\n \"\"\"Create a SentimenNetwork with the given settings\n Args:\n reviews(list) - List of reviews used for training\n labels(list) - List of POSITIVE/NEGATIVE labels associated with the given reviews\n hidden_nodes(int) - Number of nodes to create in the hidden layer\n learning_rate(float) - Learning rate to use while training\n \n \"\"\"\n # Assign a seed to our random number generator to ensure we get\n # reproducable results during development \n np.random.seed(1)\n\n # process the reviews and their associated labels so that everything\n # is ready for training\n self.pre_process_data(reviews, labels)\n \n # Build the network to have the number of hidden nodes and the learning rate that\n # were passed into this initializer. Make the same number of input nodes as\n # there are vocabulary words and create a single output node.\n self.init_network(len(self.review_vocab), hidden_nodes, 1, learning_rate)\n\n def pre_process_data(self, reviews, labels):\n # populate review_vocab with all of the words in the given reviews\n review_vocab = set()\n for review in reviews:\n for word in review.split(\" \"):\n review_vocab.add(word)\n\n # Convert the vocabulary set to a list so we can access words via indices\n self.review_vocab = list(review_vocab)\n \n # populate label_vocab with all of the words in the given labels.\n label_vocab = set()\n for label in labels:\n label_vocab.add(label)\n \n # Convert the label vocabulary set to a list so we can access labels via indices\n self.label_vocab = list(label_vocab)\n \n # Store the sizes of the review and label vocabularies.\n self.review_vocab_size = len(self.review_vocab)\n self.label_vocab_size = len(self.label_vocab)\n \n # Create a dictionary of words in the vocabulary mapped to index positions\n self.word2index = {}\n for i, word in enumerate(self.review_vocab):\n self.word2index[word] = i\n \n # Create a dictionary of labels mapped to index positions\n self.label2index = {}\n for i, label in enumerate(self.label_vocab):\n self.label2index[label] = i\n \n def init_network(self, input_nodes, hidden_nodes, output_nodes, learning_rate):\n # Store the number of nodes in input, hidden, and output layers.\n self.input_nodes = input_nodes\n self.hidden_nodes = hidden_nodes\n self.output_nodes = output_nodes\n\n # Store the learning rate\n self.learning_rate = learning_rate\n\n # Initialize weights\n \n self.weights_0_1 = np.zeros((self.input_nodes,self.hidden_nodes))\n \n # These are the weights between the hidden layer and the output layer.\n self.weights_1_2 = np.random.normal(0.0, self.output_nodes**-0.5, \n (self.hidden_nodes, self.output_nodes))\n \n # The input layer, a two-dimensional matrix with shape 1 x input_nodes\n self.layer_0 = np.zeros((1,input_nodes))\n \n \n def update_input_layer(self,review):\n\n # clear out previous state, reset the layer to be all 0s\n self.layer_0 *= 0\n \n for word in review.split(\" \"):\n # NOTE: This if-check was not in the version of this method created in Project 2,\n # and it appears in Andrew's Project 3 solution without explanation. \n # It simply ensures the word is actually a key in word2index before\n # accessing it, which is important because accessing an invalid key\n # with raise an exception in Python. This allows us to ignore unknown\n # words encountered in new reviews.\n if(word in self.word2index.keys()):\n self.layer_0[0][self.word2index[word]] = 1\n \n def get_target_for_label(self,label):\n if(label == 'POSITIVE'):\n return 1\n else:\n return 0\n \n def sigmoid(self,x):\n return 1 / (1 + np.exp(-x))\n \n def sigmoid_output_2_derivative(self,output):\n return output * (1 - output)\n\n def train(self, training_reviews, training_labels):\n \n # make sure out we have a matching number of reviews and labels\n assert(len(training_reviews) == len(training_labels))\n \n # Keep track of correct predictions to display accuracy during training \n correct_so_far = 0\n \n # Remember when we started for printing time statistics\n start = time.time()\n\n # loop through all the given reviews and run a forward and backward pass,\n # updating weights for every item\n for i in range(len(training_reviews)):\n review = training_reviews[i]\n label = training_labels[i]\n \n #### Implement the forward pass here ####\n ### Forward pass ###\n\n # Input Layer\n self.update_input_layer(review)\n\n # Hidden layer\n layer_1 = self.layer_0.dot(self.weights_0_1)\n\n # Output layer\n layer_2 = self.sigmoid(layer_1.dot(self.weights_1_2))\n \n layer_2_error = layer_2 - self.get_target_for_label(label) # Output layer error is the difference between desired target and actual output.\n layer_2_delta = layer_2_error * self.sigmoid_output_2_derivative(layer_2)\n\n # Backpropagated error\n layer_1_error = layer_2_delta.dot(self.weights_1_2.T) # errors propagated to the hidden layer\n layer_1_delta = layer_1_error # hidden layer gradients - no nonlinearity so it's the same as the error\n\n # Update the weights\n self.weights_1_2 -= layer_1.T.dot(layer_2_delta) * self.learning_rate # update hidden-to-output weights with gradient descent step\n self.weights_0_1 -= self.layer_0.T.dot(layer_1_delta) * self.learning_rate \n # TODO: Implement the back propagation pass here. \n # That means calculate the error for the forward pass's prediction\n # and update the weights in the network according to their\n # contributions toward the error, as calculated via the\n # gradient descent and back propagation algorithms you \n # learned in class.\n \n # TODO: Keep track of correct predictions. To determine if the prediction was\n # correct, check that the absolute value of the output error \n # is less than 0.5. If so, add one to the correct_so_far count.\n if(layer_2 >= 0.5 and label == 'POSITIVE'):\n correct_so_far += 1\n elif(layer_2 < 0.5 and label == 'NEGATIVE'):\n correct_so_far += 1\n \n # For debug purposes, print out our prediction accuracy and speed \n # throughout the training process. \n\n elapsed_time = float(time.time() - start)\n reviews_per_second = i / elapsed_time if elapsed_time > 0 else 0\n \n sys.stdout.write(\"\\rProgress:\" + str(100 * i/float(len(training_reviews)))[:4] \\\n + \"% Speed(reviews/sec):\" + str(reviews_per_second)[0:5] \\\n + \" #Correct:\" + str(correct_so_far) + \" #Trained:\" + str(i+1) \\\n + \" Training Accuracy:\" + str(correct_so_far * 100 / float(i+1))[:4] + \"%\")\n if(i % 2500 == 0):\n print(\"\")\n \n def test(self, testing_reviews, testing_labels):\n \"\"\"\n Attempts to predict the labels for the given testing_reviews,\n and uses the test_labels to calculate the accuracy of those predictions.\n \"\"\"\n \n # keep track of how many correct predictions we make\n correct = 0\n\n # we'll time how many predictions per second we make\n start = time.time()\n\n # Loop through each of the given reviews and call run to predict\n # its label. \n for i in range(len(testing_reviews)):\n pred = self.run(testing_reviews[i])\n# print(layer_2.shape)\n if(pred == testing_labels[i]):\n correct += 1\n \n # For debug purposes, print out our prediction accuracy and speed \n # throughout the prediction process. \n\n elapsed_time = float(time.time() - start)\n reviews_per_second = i / elapsed_time if elapsed_time > 0 else 0\n \n sys.stdout.write(\"\\rProgress:\" + str(100 * i/float(len(testing_reviews)))[:4] \\\n + \"% Speed(reviews/sec):\" + str(reviews_per_second)[0:5] \\\n + \" #Correct:\" + str(correct) + \" #Tested:\" + str(i+1) \\\n + \" Testing Accuracy:\" + str(correct * 100 / float(i+1))[:4] + \"%\")\n \n def run(self, review):\n \"\"\"\n Returns a POSITIVE or NEGATIVE prediction for the given review.\n \"\"\"\n # Run a forward pass through the network, like in the \"train\" function.\n \n # Input Layer\n self.update_input_layer(review.lower())\n\n # Hidden layer\n layer_1 = self.layer_0.dot(self.weights_0_1)\n\n # Output layer\n layer_2 = self.sigmoid(layer_1.dot(self.weights_1_2))\n \n # Return POSITIVE for values above greater-than-or-equal-to 0.5 in the output layer;\n # return NEGATIVE for other values\n if(layer_2 >= 0.5):\n return \"POSITIVE\"\n else:\n return \"NEGATIVE\"", "_____no_output_____" ] ], [ [ "Run the following cell to recreate the network and train it. Notice we've gone back to the higher learning rate of `0.1`.", "_____no_output_____" ] ], [ [ "mlp = SentimentNetwork(reviews[:-1000],labels[:-1000], learning_rate=0.1)\nmlp.train(reviews[:-1000],labels[:-1000])", "Progress:0.0% Speed(reviews/sec):0.0 #Correct:1 #Trained:1 Training Accuracy:100.%\nProgress:10.4% Speed(reviews/sec):83.64 #Correct:1838 #Trained:2501 Training Accuracy:73.4%\nProgress:20.8% Speed(reviews/sec):83.27 #Correct:3820 #Trained:5001 Training Accuracy:76.3%\nProgress:31.2% Speed(reviews/sec):83.09 #Correct:5911 #Trained:7501 Training Accuracy:78.8%\nProgress:41.6% Speed(reviews/sec):82.75 #Correct:8044 #Trained:10001 Training Accuracy:80.4%\nProgress:52.0% Speed(reviews/sec):82.98 #Correct:10188 #Trained:12501 Training Accuracy:81.4%\nProgress:62.5% Speed(reviews/sec):83.07 #Correct:12317 #Trained:15001 Training Accuracy:82.1%\nProgress:72.9% Speed(reviews/sec):83.04 #Correct:14438 #Trained:17501 Training Accuracy:82.4%\nProgress:83.3% Speed(reviews/sec):83.06 #Correct:16609 #Trained:20001 Training Accuracy:83.0%\nProgress:93.7% Speed(reviews/sec):82.96 #Correct:18788 #Trained:22501 Training Accuracy:83.4%\nProgress:99.9% Speed(reviews/sec):82.92 #Correct:20105 #Trained:24000 Training Accuracy:83.7%" ] ], [ [ "That should have trained much better than the earlier attempts. It's still not wonderful, but it should have improved dramatically. Run the following cell to test your model with 1000 predictions.", "_____no_output_____" ] ], [ [ "mlp.test(reviews[-1000:],labels[-1000:])", "Progress:99.9% Speed(reviews/sec):942.5 #Correct:849 #Tested:1000 Testing Accuracy:84.9%" ] ], [ [ "# End of Project 4. \n## Andrew's solution was actually in the previous video, so rewatch that video if you had any problems with that project. Then continue on to the next lesson.\n# Analyzing Inefficiencies in our Network<a id='lesson_5'></a>\nThe following cells include the code Andrew shows in the next video. We've included it here so you can run the cells along with the video without having to type in everything.", "_____no_output_____" ] ], [ [ "Image(filename='sentiment_network_sparse.png')", "_____no_output_____" ], [ "layer_0 = np.zeros(10)", "_____no_output_____" ], [ "layer_0", "_____no_output_____" ], [ "layer_0[4] = 1\nlayer_0[9] = 1", "_____no_output_____" ], [ "layer_0", "_____no_output_____" ], [ "weights_0_1 = np.random.randn(10,5)", "_____no_output_____" ], [ "layer_0.dot(weights_0_1)", "_____no_output_____" ], [ "indices = [4,9]", "_____no_output_____" ], [ "layer_1 = np.zeros(5)", "_____no_output_____" ], [ "for index in indices:\n layer_1 += (1 * weights_0_1[index])", "_____no_output_____" ], [ "layer_1", "_____no_output_____" ], [ "Image(filename='sentiment_network_sparse_2.png')", "_____no_output_____" ], [ "layer_1 = np.zeros(5)", "_____no_output_____" ], [ "for index in indices:\n layer_1 += (weights_0_1[index])", "_____no_output_____" ], [ "layer_1", "_____no_output_____" ] ], [ [ "# Project 5: Making our Network More Efficient<a id='project_5'></a>\n**TODO:** Make the `SentimentNetwork` class more efficient by eliminating unnecessary multiplications and additions that occur during forward and backward propagation. To do that, you can do the following:\n* Copy the `SentimentNetwork` class from the previous project into the following cell.\n* Remove the `update_input_layer` function - you will not need it in this version.\n* Modify `init_network`:\n>* You no longer need a separate input layer, so remove any mention of `self.layer_0`\n>* You will be dealing with the old hidden layer more directly, so create `self.layer_1`, a two-dimensional matrix with shape 1 x hidden_nodes, with all values initialized to zero\n* Modify `train`:\n>* Change the name of the input parameter `training_reviews` to `training_reviews_raw`. This will help with the next step.\n>* At the beginning of the function, you'll want to preprocess your reviews to convert them to a list of indices (from `word2index`) that are actually used in the review. This is equivalent to what you saw in the video when Andrew set specific indices to 1. Your code should create a local `list` variable named `training_reviews` that should contain a `list` for each review in `training_reviews_raw`. Those lists should contain the indices for words found in the review.\n>* Remove call to `update_input_layer`\n>* Use `self`'s `layer_1` instead of a local `layer_1` object.\n>* In the forward pass, replace the code that updates `layer_1` with new logic that only adds the weights for the indices used in the review.\n>* When updating `weights_0_1`, only update the individual weights that were used in the forward pass.\n* Modify `run`:\n>* Remove call to `update_input_layer` \n>* Use `self`'s `layer_1` instead of a local `layer_1` object.\n>* Much like you did in `train`, you will need to pre-process the `review` so you can work with word indices, then update `layer_1` by adding weights for the indices used in the review.", "_____no_output_____" ] ], [ [ "import time\nimport sys\nimport numpy as np\n\n# Encapsulate our neural network in a class\nclass SentimentNetwork:\n def __init__(self, reviews,labels,hidden_nodes = 10, learning_rate = 0.1):\n \"\"\"Create a SentimenNetwork with the given settings\n Args:\n reviews(list) - List of reviews used for training\n labels(list) - List of POSITIVE/NEGATIVE labels associated with the given reviews\n hidden_nodes(int) - Number of nodes to create in the hidden layer\n learning_rate(float) - Learning rate to use while training\n \n \"\"\"\n # Assign a seed to our random number generator to ensure we get\n # reproducable results during development \n np.random.seed(1)\n\n # process the reviews and their associated labels so that everything\n # is ready for training\n self.pre_process_data(reviews, labels)\n \n # Build the network to have the number of hidden nodes and the learning rate that\n # were passed into this initializer. Make the same number of input nodes as\n # there are vocabulary words and create a single output node.\n self.init_network(len(self.review_vocab),hidden_nodes, 1, learning_rate)\n\n def pre_process_data(self, reviews, labels):\n \n # populate review_vocab with all of the words in the given reviews\n review_vocab = set()\n for review in reviews:\n for word in review.split(\" \"):\n review_vocab.add(word)\n\n # Convert the vocabulary set to a list so we can access words via indices\n self.review_vocab = list(review_vocab)\n \n # populate label_vocab with all of the words in the given labels.\n label_vocab = set()\n for label in labels:\n label_vocab.add(label)\n \n # Convert the label vocabulary set to a list so we can access labels via indices\n self.label_vocab = list(label_vocab)\n \n # Store the sizes of the review and label vocabularies.\n self.review_vocab_size = len(self.review_vocab)\n self.label_vocab_size = len(self.label_vocab)\n \n # Create a dictionary of words in the vocabulary mapped to index positions\n self.word2index = {}\n for i, word in enumerate(self.review_vocab):\n self.word2index[word] = i\n \n # Create a dictionary of labels mapped to index positions\n self.label2index = {}\n for i, label in enumerate(self.label_vocab):\n self.label2index[label] = i\n\n def init_network(self, input_nodes, hidden_nodes, output_nodes, learning_rate):\n # Set number of nodes in input, hidden and output layers.\n self.input_nodes = input_nodes\n self.hidden_nodes = hidden_nodes\n self.output_nodes = output_nodes\n\n # Store the learning rate\n self.learning_rate = learning_rate\n\n # Initialize weights\n\n # These are the weights between the input layer and the hidden layer.\n self.weights_0_1 = np.zeros((self.input_nodes,self.hidden_nodes))\n\n # These are the weights between the hidden layer and the output layer.\n self.weights_1_2 = np.random.normal(0.0, self.output_nodes**-0.5, \n (self.hidden_nodes, self.output_nodes))\n \n ## New for Project 5: Removed self.layer_0; added self.layer_1\n # The input layer, a two-dimensional matrix with shape 1 x hidden_nodes\n self.layer_1 = np.zeros((1,hidden_nodes))\n \n ## New for Project 5: Removed update_input_layer function\n \n def get_target_for_label(self,label):\n if(label == 'POSITIVE'):\n return 1\n else:\n return 0\n \n def sigmoid(self,x):\n return 1 / (1 + np.exp(-x))\n \n def sigmoid_output_2_derivative(self,output):\n return output * (1 - output)\n\n def train(self, training_reviews_raw, training_labels):\n\n ## New for Project 5: pre-process training reviews so we can deal \n # directly with the indices of non-zero inputs\n training_reviews = list()\n for review in training_reviews_raw:\n indices = set()\n for word in review.split(\" \"):\n if(word in self.word2index.keys()):\n indices.add(self.word2index[word])\n training_reviews.append(list(indices))\n\n # make sure out we have a matching number of reviews and labels\n assert(len(training_reviews) == len(training_labels))\n \n # Keep track of correct predictions to display accuracy during training \n correct_so_far = 0\n\n # Remember when we started for printing time statistics\n start = time.time()\n \n # loop through all the given reviews and run a forward and backward pass,\n # updating weights for every item\n for i in range(len(training_reviews)):\n \n # Get the next review and its correct label\n review = training_reviews[i]\n label = training_labels[i]\n \n #### Implement the forward pass here ####\n ### Forward pass ###\n\n ## New for Project 5: Removed call to 'update_input_layer' function\n # because 'layer_0' is no longer used\n\n # Hidden layer\n ## New for Project 5: Add in only the weights for non-zero items\n self.layer_1 *= 0\n for index in review:\n self.layer_1 += self.weights_0_1[index]\n\n # Output layer\n ## New for Project 5: changed to use 'self.layer_1' instead of 'local layer_1'\n layer_2 = self.sigmoid(self.layer_1.dot(self.weights_1_2)) \n \n #### Implement the backward pass here ####\n ### Backward pass ###\n\n # Output error\n layer_2_error = layer_2 - self.get_target_for_label(label) # Output layer error is the difference between desired target and actual output.\n layer_2_delta = layer_2_error * self.sigmoid_output_2_derivative(layer_2)\n\n # Backpropagated error\n layer_1_error = layer_2_delta.dot(self.weights_1_2.T) # errors propagated to the hidden layer\n layer_1_delta = layer_1_error # hidden layer gradients - no nonlinearity so it's the same as the error\n\n # Update the weights\n ## New for Project 5: changed to use 'self.layer_1' instead of local 'layer_1'\n self.weights_1_2 -= self.layer_1.T.dot(layer_2_delta) * self.learning_rate # update hidden-to-output weights with gradient descent step\n \n ## New for Project 5: Only update the weights that were used in the forward pass\n for index in review:\n self.weights_0_1[index] -= layer_1_delta[0] * self.learning_rate # update input-to-hidden weights with gradient descent step\n\n # Keep track of correct predictions.\n if(layer_2 >= 0.5 and label == 'POSITIVE'):\n correct_so_far += 1\n elif(layer_2 < 0.5 and label == 'NEGATIVE'):\n correct_so_far += 1\n \n # For debug purposes, print out our prediction accuracy and speed \n # throughout the training process. \n elapsed_time = float(time.time() - start)\n reviews_per_second = i / elapsed_time if elapsed_time > 0 else 0\n \n sys.stdout.write(\"\\rProgress:\" + str(100 * i/float(len(training_reviews)))[:4] \\\n + \"% Speed(reviews/sec):\" + str(reviews_per_second)[0:5] \\\n + \" #Correct:\" + str(correct_so_far) + \" #Trained:\" + str(i+1) \\\n + \" Training Accuracy:\" + str(correct_so_far * 100 / float(i+1))[:4] + \"%\")\n if(i % 2500 == 0):\n print(\"\")\n \n def test(self, testing_reviews, testing_labels):\n correct = 0\n\n start = time.time()\n for i in range(len(testing_reviews)):\n pred = self.run(testing_reviews[i])\n if(pred == testing_labels[i]):\n correct += 1\n\n elapsed_time = float(time.time() - start)\n reviews_per_second = i / elapsed_time if elapsed_time > 0 else 0\n \n sys.stdout.write(\"\\rProgress:\" + str(100 * i/float(len(testing_reviews)))[:4] \\\n + \"% Speed(reviews/sec):\" + str(reviews_per_second)[0:5] \\\n + \" #Correct:\" + str(correct) + \" #Tested:\" + str(i+1) \\\n + \" Testing Accuracy:\" + str(correct * 100 / float(i+1))[:4] + \"%\")\n \n def run(self, review):\n \"\"\"\n Returns a POSITIVE or NEGATIVE prediction for the given review.\n \"\"\"\n # Run a forward pass through the network, like in the \"train\" function.\n \n ## New for Project 5: Removed call to update_input_layer function\n # because layer_0 is no longer used\n\n # Hidden layer\n ## New for Project 5: Identify the indices used in the review and then add\n # just those weights to layer_1 \n self.layer_1 *= 0\n unique_indices = set()\n for word in review.lower().split(\" \"):\n if word in self.word2index.keys():\n unique_indices.add(self.word2index[word])\n for index in unique_indices:\n self.layer_1 += self.weights_0_1[index]\n \n # Output layer\n ## New for Project 5: changed to use self.layer_1 instead of local layer_1\n layer_2 = self.sigmoid(self.layer_1.dot(self.weights_1_2))\n \n # Return POSITIVE for values above greater-than-or-equal-to 0.5 in the output layer;\n # return NEGATIVE for other values\n if(layer_2[0] >= 0.5):\n return \"POSITIVE\"\n else:\n return \"NEGATIVE\"", "_____no_output_____" ] ], [ [ "Run the following cell to recreate the network and train it once again.", "_____no_output_____" ] ], [ [ "mlp = SentimentNetwork(reviews[:-1000],labels[:-1000], learning_rate=0.1)\nmlp.train(reviews[:-1000],labels[:-1000])", "Progress:0.0% Speed(reviews/sec):0.0 #Correct:1 #Trained:1 Training Accuracy:100.%\nProgress:10.4% Speed(reviews/sec):1756. #Correct:1823 #Trained:2501 Training Accuracy:72.8%\nProgress:20.8% Speed(reviews/sec):1710. #Correct:3810 #Trained:5001 Training Accuracy:76.1%\nProgress:31.2% Speed(reviews/sec):1707. #Correct:5884 #Trained:7501 Training Accuracy:78.4%\nProgress:41.6% Speed(reviews/sec):1720. #Correct:8023 #Trained:10001 Training Accuracy:80.2%\nProgress:52.0% Speed(reviews/sec):1715. #Correct:10147 #Trained:12501 Training Accuracy:81.1%\nProgress:62.5% Speed(reviews/sec):1716. #Correct:12277 #Trained:15001 Training Accuracy:81.8%\nProgress:72.9% Speed(reviews/sec):1712. #Correct:14388 #Trained:17501 Training Accuracy:82.2%\nProgress:83.3% Speed(reviews/sec):1709. #Correct:16559 #Trained:20001 Training Accuracy:82.7%\nProgress:93.7% Speed(reviews/sec):1707. #Correct:18745 #Trained:22501 Training Accuracy:83.3%\nProgress:99.9% Speed(reviews/sec):1707. #Correct:20078 #Trained:24000 Training Accuracy:83.6%" ] ], [ [ "That should have trained much better than the earlier attempts. Run the following cell to test your model with 1000 predictions.", "_____no_output_____" ] ], [ [ "mlp.test(reviews[-1000:],labels[-1000:])", "Progress:99.9% Speed(reviews/sec):1970. #Correct:853 #Tested:1000 Testing Accuracy:85.3%" ] ], [ [ "# End of Project 5. \n## Watch the next video to see Andrew's solution, then continue on to the next lesson.\n# Further Noise Reduction<a id='lesson_6'></a>", "_____no_output_____" ] ], [ [ "Image(filename='sentiment_network_sparse_2.png')", "_____no_output_____" ], [ "# words most frequently seen in a review with a \"POSITIVE\" label\npos_neg_ratios.most_common()", "_____no_output_____" ], [ "# words most frequently seen in a review with a \"NEGATIVE\" label\nlist(reversed(pos_neg_ratios.most_common()))[0:30]", "_____no_output_____" ], [ "from bokeh.models import ColumnDataSource, LabelSet\nfrom bokeh.plotting import figure, show, output_file\nfrom bokeh.io import output_notebook\noutput_notebook()", "_____no_output_____" ], [ "hist, edges = np.histogram(list(map(lambda x:x[1],pos_neg_ratios.most_common())), density=True, bins=100, normed=True)\n\np = figure(tools=\"pan,wheel_zoom,reset,save\",\n toolbar_location=\"above\",\n title=\"Word Positive/Negative Affinity Distribution\")\np.quad(top=hist, bottom=0, left=edges[:-1], right=edges[1:], line_color=\"#555555\")\nshow(p)", "_____no_output_____" ], [ "frequency_frequency = Counter()\n\nfor word, cnt in total_counts.most_common():\n frequency_frequency[cnt] += 1", "_____no_output_____" ], [ "hist, edges = np.histogram(list(map(lambda x:x[1],frequency_frequency.most_common())), density=True, bins=100, normed=True)\n\np = figure(tools=\"pan,wheel_zoom,reset,save\",\n toolbar_location=\"above\",\n title=\"The frequency distribution of the words in our corpus\")\np.quad(top=hist, bottom=0, left=edges[:-1], right=edges[1:], line_color=\"#555555\")\nshow(p)", "_____no_output_____" ] ], [ [ "# Project 6: Reducing Noise by Strategically Reducing the Vocabulary<a id='project_6'></a>\n\n**TODO:** Improve `SentimentNetwork`'s performance by reducing more noise in the vocabulary. Specifically, do the following:\n* Copy the `SentimentNetwork` class from the previous project into the following cell.\n* Modify `pre_process_data`:\n>* Add two additional parameters: `min_count` and `polarity_cutoff`\n>* Calculate the positive-to-negative ratios of words used in the reviews. (You can use code you've written elsewhere in the notebook, but we are moving it into the class like we did with other helper code earlier.)\n>* Andrew's solution only calculates a postive-to-negative ratio for words that occur at least 50 times. This keeps the network from attributing too much sentiment to rarer words. You can choose to add this to your solution if you would like. \n>* Change so words are only added to the vocabulary if they occur in the vocabulary more than `min_count` times.\n>* Change so words are only added to the vocabulary if the absolute value of their postive-to-negative ratio is at least `polarity_cutoff`\n* Modify `__init__`:\n>* Add the same two parameters (`min_count` and `polarity_cutoff`) and use them when you call `pre_process_data`", "_____no_output_____" ] ], [ [ "import time\nimport sys\nimport numpy as np\nfrom collections import Counter\n\n# Encapsulate our neural network in a class\nclass SentimentNetwork:\n def __init__(self, reviews,labels,hidden_nodes = 10, learning_rate = 0.1, min_count = 10, polarity_cutoff = 0.1):\n \"\"\"Create a SentimenNetwork with the given settings\n Args:\n reviews(list) - List of reviews used for training\n labels(list) - List of POSITIVE/NEGATIVE labels associated with the given reviews\n hidden_nodes(int) - Number of nodes to create in the hidden layer\n learning_rate(float) - Learning rate to use while training\n \n \"\"\"\n # Assign a seed to our random number generator to ensure we get\n # reproducable results during development \n np.random.seed(1)\n\n # process the reviews and their associated labels so that everything\n # is ready for training\n self.pre_process_data(reviews, labels, min_count, polarity_cutoff)\n \n # Build the network to have the number of hidden nodes and the learning rate that\n # were passed into this initializer. Make the same number of input nodes as\n # there are vocabulary words and create a single output node.\n self.init_network(len(self.review_vocab),hidden_nodes, 1, learning_rate)\n\n def pre_process_data(self, reviews, labels, min_count, polarity_cutoff):\n positive_counts = Counter()\n negative_counts = Counter()\n total_counts = Counter()\n\n for i in range(len(reviews)):\n if(labels[i] == 'POSITIVE'):\n for word in reviews[i].split(\" \"):\n positive_counts[word] += 1\n total_counts[word] += 1\n else:\n for word in reviews[i].split(\" \"):\n negative_counts[word] += 1\n total_counts[word] += 1\n \n pos_neg_ratios = Counter()\n \n for term,count in total_counts.most_common():\n if(count > 50):\n pos_neg_ratio = positive_counts[term] / float(negative_counts[term]+1)\n try:\n pos_neg_ratios[term] = np.log(pos_neg_ratio)\n except:\n pass\n \n review_vocab = set()\n for review in reviews:\n for word in review.split(\" \"):\n ## New for Project 6: only add words that occur at least min_count times\n # and for words with pos/neg ratios, only add words\n # that meet the polarity_cutoff\n if(total_counts[word] > min_count):\n if(word in pos_neg_ratios.keys() and np.abs([pos_neg_ratios[word]]) >= polarity_cutoff):\n# if((pos_neg_ratios[word] >= polarity_cutoff) or (pos_neg_ratios[word] <= -polarity_cutoff)):\n review_vocab.add(word)\n else:\n review_vocab.add(word)\n\n # Convert the vocabulary set to a list so we can access words via indices\n self.review_vocab = list(review_vocab)\n \n # populate label_vocab with all of the words in the given labels.\n label_vocab = set()\n for label in labels:\n label_vocab.add(label)\n \n # Convert the label vocabulary set to a list so we can access labels via indices\n self.label_vocab = list(label_vocab)\n \n # Store the sizes of the review and label vocabularies.\n self.review_vocab_size = len(self.review_vocab)\n self.label_vocab_size = len(self.label_vocab)\n \n # Create a dictionary of words in the vocabulary mapped to index positions\n self.word2index = {}\n for i, word in enumerate(self.review_vocab):\n self.word2index[word] = i\n \n # Create a dictionary of labels mapped to index positions\n self.label2index = {}\n for i, label in enumerate(self.label_vocab):\n self.label2index[label] = i\n\n def init_network(self, input_nodes, hidden_nodes, output_nodes, learning_rate):\n # Set number of nodes in input, hidden and output layers.\n self.input_nodes = input_nodes\n self.hidden_nodes = hidden_nodes\n self.output_nodes = output_nodes\n\n # Store the learning rate\n self.learning_rate = learning_rate\n\n # Initialize weights\n\n # These are the weights between the input layer and the hidden layer.\n self.weights_0_1 = np.zeros((self.input_nodes,self.hidden_nodes))\n\n # These are the weights between the hidden layer and the output layer.\n self.weights_1_2 = np.random.normal(0.0, self.output_nodes**-0.5, \n (self.hidden_nodes, self.output_nodes))\n \n ## New for Project 5: Removed self.layer_0; added self.layer_1\n # The input layer, a two-dimensional matrix with shape 1 x hidden_nodes\n self.layer_1 = np.zeros((1,hidden_nodes))\n \n ## New for Project 5: Removed update_input_layer function\n \n def get_target_for_label(self,label):\n if(label == 'POSITIVE'):\n return 1\n else:\n return 0\n \n def sigmoid(self,x):\n return 1 / (1 + np.exp(-x))\n \n def sigmoid_output_2_derivative(self,output):\n return output * (1 - output)\n\n def train(self, training_reviews_raw, training_labels):\n\n ## New for Project 5: pre-process training reviews so we can deal \n # directly with the indices of non-zero inputs\n training_reviews = list()\n for review in training_reviews_raw:\n indices = set()\n for word in review.split(\" \"):\n if(word in self.word2index.keys()):\n indices.add(self.word2index[word])\n training_reviews.append(list(indices))\n\n # make sure out we have a matching number of reviews and labels\n assert(len(training_reviews) == len(training_labels))\n \n # Keep track of correct predictions to display accuracy during training \n correct_so_far = 0\n\n # Remember when we started for printing time statistics\n start = time.time()\n \n # loop through all the given reviews and run a forward and backward pass,\n # updating weights for every item\n for i in range(len(training_reviews)):\n \n # Get the next review and its correct label\n review = training_reviews[i]\n label = training_labels[i]\n \n #### Implement the forward pass here ####\n ### Forward pass ###\n\n ## New for Project 5: Removed call to 'update_input_layer' function\n # because 'layer_0' is no longer used\n\n # Hidden layer\n ## New for Project 5: Add in only the weights for non-zero items\n self.layer_1 *= 0\n for index in review:\n self.layer_1 += self.weights_0_1[index]\n\n # Output layer\n ## New for Project 5: changed to use 'self.layer_1' instead of 'local layer_1'\n layer_2 = self.sigmoid(self.layer_1.dot(self.weights_1_2)) \n \n #### Implement the backward pass here ####\n ### Backward pass ###\n\n # Output error\n layer_2_error = layer_2 - self.get_target_for_label(label) # Output layer error is the difference between desired target and actual output.\n layer_2_delta = layer_2_error * self.sigmoid_output_2_derivative(layer_2)\n\n # Backpropagated error\n layer_1_error = layer_2_delta.dot(self.weights_1_2.T) # errors propagated to the hidden layer\n layer_1_delta = layer_1_error # hidden layer gradients - no nonlinearity so it's the same as the error\n\n # Update the weights\n ## New for Project 5: changed to use 'self.layer_1' instead of local 'layer_1'\n self.weights_1_2 -= self.layer_1.T.dot(layer_2_delta) * self.learning_rate # update hidden-to-output weights with gradient descent step\n \n ## New for Project 5: Only update the weights that were used in the forward pass\n for index in review:\n self.weights_0_1[index] -= layer_1_delta[0] * self.learning_rate # update input-to-hidden weights with gradient descent step\n\n # Keep track of correct predictions.\n if(layer_2 >= 0.5 and label == 'POSITIVE'):\n correct_so_far += 1\n elif(layer_2 < 0.5 and label == 'NEGATIVE'):\n correct_so_far += 1\n \n # For debug purposes, print out our prediction accuracy and speed \n # throughout the training process. \n elapsed_time = float(time.time() - start)\n reviews_per_second = i / elapsed_time if elapsed_time > 0 else 0\n \n sys.stdout.write(\"\\rProgress:\" + str(100 * i/float(len(training_reviews)))[:4] \\\n + \"% Speed(reviews/sec):\" + str(reviews_per_second)[0:5] \\\n + \" #Correct:\" + str(correct_so_far) + \" #Trained:\" + str(i+1) \\\n + \" Training Accuracy:\" + str(correct_so_far * 100 / float(i+1))[:4] + \"%\")\n if(i % 2500 == 0):\n print(\"\")\n \n def test(self, testing_reviews, testing_labels):\n correct = 0\n\n start = time.time()\n for i in range(len(testing_reviews)):\n pred = self.run(testing_reviews[i])\n if(pred == testing_labels[i]):\n correct += 1\n\n elapsed_time = float(time.time() - start)\n reviews_per_second = i / elapsed_time if elapsed_time > 0 else 0\n \n sys.stdout.write(\"\\rProgress:\" + str(100 * i/float(len(testing_reviews)))[:4] \\\n + \"% Speed(reviews/sec):\" + str(reviews_per_second)[0:5] \\\n + \" #Correct:\" + str(correct) + \" #Tested:\" + str(i+1) \\\n + \" Testing Accuracy:\" + str(correct * 100 / float(i+1))[:4] + \"%\")\n \n def run(self, review):\n self.layer_1 *= 0\n unique_indices = set()\n for word in review.lower().split(\" \"):\n if word in self.word2index.keys():\n unique_indices.add(self.word2index[word])\n for index in unique_indices:\n self.layer_1 += self.weights_0_1[index]\n \n # Output layer\n ## New for Project 5: changed to use self.layer_1 instead of local layer_1\n layer_2 = self.sigmoid(self.layer_1.dot(self.weights_1_2))\n \n # Return POSITIVE for values above greater-than-or-equal-to 0.5 in the output layer;\n # return NEGATIVE for other values\n if(layer_2[0] >= 0.5):\n return \"POSITIVE\"\n else:\n return \"NEGATIVE\"", "_____no_output_____" ] ], [ [ "Run the following cell to train your network with a small polarity cutoff.", "_____no_output_____" ] ], [ [ "mlp = SentimentNetwork(reviews[:-1000],labels[:-1000],min_count=20,polarity_cutoff=0.05,learning_rate=0.01)\nmlp.train(reviews[:-1000],labels[:-1000])", "/opt/conda/lib/python3.6/site-packages/ipykernel_launcher.py:51: RuntimeWarning: divide by zero encountered in log\n" ] ], [ [ "And run the following cell to test it's performance. It should be ", "_____no_output_____" ] ], [ [ "mlp.test(reviews[-1000:],labels[-1000:])", "_____no_output_____" ] ], [ [ "Run the following cell to train your network with a much larger polarity cutoff.", "_____no_output_____" ] ], [ [ "mlp = SentimentNetwork(reviews[:-1000],labels[:-1000],min_count=20,polarity_cutoff=0.8,learning_rate=0.01)\nmlp.train(reviews[:-1000],labels[:-1000])", "_____no_output_____" ] ], [ [ "And run the following cell to test it's performance.", "_____no_output_____" ] ], [ [ "mlp.test(reviews[-1000:],labels[-1000:])", "_____no_output_____" ] ], [ [ "# End of Project 6. \n## Watch the next video to see Andrew's solution, then continue on to the next lesson.", "_____no_output_____" ], [ "# Analysis: What's Going on in the Weights?<a id='lesson_7'></a>", "_____no_output_____" ] ], [ [ "mlp_full = SentimentNetwork(reviews[:-1000],labels[:-1000],min_count=0,polarity_cutoff=0,learning_rate=0.01)", "_____no_output_____" ], [ "mlp_full.train(reviews[:-1000],labels[:-1000])", "_____no_output_____" ], [ "Image(filename='sentiment_network_sparse.png')", "_____no_output_____" ], [ "def get_most_similar_words(focus = \"horrible\"):\n most_similar = Counter()\n\n for word in mlp_full.word2index.keys():\n most_similar[word] = np.dot(mlp_full.weights_0_1[mlp_full.word2index[word]],mlp_full.weights_0_1[mlp_full.word2index[focus]])\n \n return most_similar.most_common()", "_____no_output_____" ], [ "get_most_similar_words(\"excellent\")", "_____no_output_____" ], [ "get_most_similar_words(\"terrible\")", "_____no_output_____" ], [ "import matplotlib.colors as colors\n\nwords_to_visualize = list()\nfor word, ratio in pos_neg_ratios.most_common(500):\n if(word in mlp_full.word2index.keys()):\n words_to_visualize.append(word)\n \nfor word, ratio in list(reversed(pos_neg_ratios.most_common()))[0:500]:\n if(word in mlp_full.word2index.keys()):\n words_to_visualize.append(word)", "_____no_output_____" ], [ "pos = 0\nneg = 0\n\ncolors_list = list()\nvectors_list = list()\nfor word in words_to_visualize:\n if word in pos_neg_ratios.keys():\n vectors_list.append(mlp_full.weights_0_1[mlp_full.word2index[word]])\n if(pos_neg_ratios[word] > 0):\n pos+=1\n colors_list.append(\"#00ff00\")\n else:\n neg+=1\n colors_list.append(\"#000000\")", "_____no_output_____" ], [ "from sklearn.manifold import TSNE\ntsne = TSNE(n_components=2, random_state=0)\nwords_top_ted_tsne = tsne.fit_transform(vectors_list)", "_____no_output_____" ], [ "p = figure(tools=\"pan,wheel_zoom,reset,save\",\n toolbar_location=\"above\",\n title=\"vector T-SNE for most polarized words\")\n\nsource = ColumnDataSource(data=dict(x1=words_top_ted_tsne[:,0],\n x2=words_top_ted_tsne[:,1],\n names=words_to_visualize,\n color=colors_list))\n\np.scatter(x=\"x1\", y=\"x2\", size=8, source=source, fill_color=\"color\")\n\nword_labels = LabelSet(x=\"x1\", y=\"x2\", text=\"names\", y_offset=6,\n text_font_size=\"8pt\", text_color=\"#555555\",\n source=source, text_align='center')\np.add_layout(word_labels)\n\nshow(p)\n\n# green indicates positive words, black indicates negative words", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ [ [ "# Advanced usage\n\nThis notebook replicates what was done in the *simple_usage* notebooks, but this time with the advanced API. The advanced API is required if we want to use non-standard affinity methods that better preserve global structure.\n\nIf you are comfortable with the advanced API, please refer to the *preserving_global_structure* notebook for a guide how obtain better embeddings and preserve more global structure.", "_____no_output_____" ] ], [ [ "from openTSNE import TSNEEmbedding\nfrom openTSNE import affinity\nfrom openTSNE import initialization\n\nfrom examples import utils\n\nimport numpy as np\nfrom sklearn.model_selection import train_test_split\n\nimport matplotlib.pyplot as plt", "_____no_output_____" ] ], [ [ "## Load data", "_____no_output_____" ] ], [ [ "import gzip\nimport pickle\n\nwith gzip.open(\"data/macosko_2015.pkl.gz\", \"rb\") as f:\n data = pickle.load(f)\n\nx = data[\"pca_50\"]\ny = data[\"CellType1\"].astype(str)", "_____no_output_____" ], [ "print(\"Data set contains %d samples with %d features\" % x.shape)", "Data set contains 44808 samples with 50 features\n" ] ], [ [ "## Create train/test split", "_____no_output_____" ] ], [ [ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=.33, random_state=42)", "_____no_output_____" ], [ "print(\"%d training samples\" % x_train.shape[0])\nprint(\"%d test samples\" % x_test.shape[0])", "30021 training samples\n14787 test samples\n" ] ], [ [ "## Create a t-SNE embedding\n\nLike in the *simple_usage* notebook, we will run the standard t-SNE optimization.\n\nThis example shows the standard t-SNE optimization. Much can be done in order to better preserve global structure and improve embedding quality. Please refer to the *preserving_global_structure* notebook for some examples.", "_____no_output_____" ], [ "**1. Compute the affinities between data points**", "_____no_output_____" ] ], [ [ "%%time\naffinities_train = affinity.PerplexityBasedNN(\n x_train,\n perplexity=30,\n metric=\"euclidean\",\n n_jobs=8,\n random_state=42,\n verbose=True,\n)", "===> Finding 90 nearest neighbors using Annoy approximate search using euclidean distance...\n --> Time elapsed: 3.78 seconds\n===> Calculating affinity matrix...\n --> Time elapsed: 0.43 seconds\nCPU times: user 19.3 s, sys: 794 ms, total: 20.1 s\nWall time: 4.22 s\n" ] ], [ [ "**2. Generate initial coordinates for our embedding**", "_____no_output_____" ] ], [ [ "%time init_train = initialization.pca(x_train, random_state=42)", "CPU times: user 448 ms, sys: 88.3 ms, total: 536 ms\nWall time: 86.9 ms\n" ] ], [ [ "**3. Construct the `TSNEEmbedding` object**", "_____no_output_____" ] ], [ [ "embedding_train = TSNEEmbedding(\n init_train,\n affinities_train,\n negative_gradient_method=\"fft\",\n n_jobs=8,\n verbose=True,\n)", "_____no_output_____" ] ], [ [ "**4. Optimize embedding**", "_____no_output_____" ], [ "1. Early exaggeration phase", "_____no_output_____" ] ], [ [ "%time embedding_train_1 = embedding_train.optimize(n_iter=250, exaggeration=12, momentum=0.5)", "===> Running optimization with exaggeration=12.00, lr=2501.75 for 250 iterations...\nIteration 50, KL divergence 5.8046, 50 iterations in 1.8747 sec\nIteration 100, KL divergence 5.2268, 50 iterations in 2.0279 sec\nIteration 150, KL divergence 5.1357, 50 iterations in 1.9912 sec\nIteration 200, KL divergence 5.0977, 50 iterations in 1.9626 sec\nIteration 250, KL divergence 5.0772, 50 iterations in 1.9759 sec\n --> Time elapsed: 9.83 seconds\nCPU times: user 1min 11s, sys: 2.04 s, total: 1min 13s\nWall time: 9.89 s\n" ], [ "utils.plot(embedding_train_1, y_train, colors=utils.MACOSKO_COLORS)", "_____no_output_____" ] ], [ [ "2. Regular optimization", "_____no_output_____" ] ], [ [ "%time embedding_train_2 = embedding_train_1.optimize(n_iter=500, momentum=0.8)", "===> Running optimization with exaggeration=1.00, lr=2501.75 for 500 iterations...\nIteration 50, KL divergence 3.5741, 50 iterations in 1.9240 sec\nIteration 100, KL divergence 3.1653, 50 iterations in 1.9942 sec\nIteration 150, KL divergence 2.9612, 50 iterations in 2.3730 sec\nIteration 200, KL divergence 2.8342, 50 iterations in 3.4895 sec\nIteration 250, KL divergence 2.7496, 50 iterations in 4.7873 sec\nIteration 300, KL divergence 2.6901, 50 iterations in 5.2739 sec\nIteration 350, KL divergence 2.6471, 50 iterations in 6.9968 sec\nIteration 400, KL divergence 2.6138, 50 iterations in 7.8137 sec\nIteration 450, KL divergence 2.5893, 50 iterations in 9.5210 sec\nIteration 500, KL divergence 2.5699, 50 iterations in 10.6958 sec\n --> Time elapsed: 54.87 seconds\nCPU times: user 6min 2s, sys: 20.3 s, total: 6min 23s\nWall time: 55.1 s\n" ], [ "utils.plot(embedding_train_2, y_train, colors=utils.MACOSKO_COLORS)", "_____no_output_____" ] ], [ [ "## Transform", "_____no_output_____" ] ], [ [ "%%time\nembedding_test = embedding_train_2.prepare_partial(\n x_test,\n initialization=\"median\",\n k=25,\n perplexity=5,\n)", "===> Finding 15 nearest neighbors in existing embedding using Annoy approximate search...\n --> Time elapsed: 1.11 seconds\n===> Calculating affinity matrix...\n --> Time elapsed: 0.03 seconds\nCPU times: user 3 s, sys: 192 ms, total: 3.19 s\nWall time: 1.15 s\n" ], [ "utils.plot(embedding_test, y_test, colors=utils.MACOSKO_COLORS)", "_____no_output_____" ], [ "%time embedding_test_1 = embedding_test.optimize(n_iter=250, learning_rate=0.1, momentum=0.8)", "===> Running optimization with exaggeration=1.00, lr=0.10 for 250 iterations...\nIteration 50, KL divergence 226760.6820, 50 iterations in 0.3498 sec\nIteration 100, KL divergence 221529.7066, 50 iterations in 0.4099 sec\nIteration 150, KL divergence 215464.6854, 50 iterations in 0.4285 sec\nIteration 200, KL divergence 211201.7247, 50 iterations in 0.4060 sec\nIteration 250, KL divergence 209022.1241, 50 iterations in 0.4211 sec\n --> Time elapsed: 2.02 seconds\nCPU times: user 10.7 s, sys: 889 ms, total: 11.6 s\nWall time: 2.74 s\n" ], [ "utils.plot(embedding_test_1, y_test, colors=utils.MACOSKO_COLORS)", "_____no_output_____" ] ], [ [ "## Together\n\nWe superimpose the transformed points onto the original embedding with larger opacity.", "_____no_output_____" ] ], [ [ "fig, ax = plt.subplots(figsize=(8, 8))\nutils.plot(embedding_train_2, y_train, colors=utils.MACOSKO_COLORS, alpha=0.25, ax=ax)\nutils.plot(embedding_test_1, y_test, colors=utils.MACOSKO_COLORS, alpha=0.75, ax=ax)", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "## Practice: BiLSTM for PoS Tagging\n*This notebook is based on [open-source implementation](https://github.com/bentrevett/pytorch-pos-tagging) of PoS Tagging in PyTorch.*\n\n### Introduction\n\nIn this series we'll be building a machine learning model that produces an output for every element in an input sequence, using PyTorch and TorchText. Specifically, we will be inputting a sequence of text and the model will output a part-of-speech (PoS) tag for each token in the input text. This can also be used for named entity recognition (NER), where the output for each token will be what type of entity, if any, the token is.\n\nIn this notebook, we'll be implementing a multi-layer bi-directional LSTM (BiLSTM) to predict PoS tags using the Universal Dependencies English Web Treebank (UDPOS) dataset.\n\n### Preparing Data\n\nFirst, let's import the necessary Python modules.", "_____no_output_____" ] ], [ [ "import torch\nimport torch.nn as nn\nimport torch.optim as optim\n\nfrom torchtext.legacy import data\nfrom torchtext.legacy import datasets\n\nimport spacy\nimport numpy as np\n\nimport time\nimport random", "_____no_output_____" ] ], [ [ "Next, we'll set the random seeds for reproducability.", "_____no_output_____" ] ], [ [ "SEED = 1234\n\nrandom.seed(SEED)\nnp.random.seed(SEED)\ntorch.manual_seed(SEED)\ntorch.backends.cudnn.deterministic = True", "_____no_output_____" ] ], [ [ "One of the key parts of TorchText is the `Field`. The `Field` handles how your dataset is processed.\n\nOur `TEXT` field handles how the text that we need to tag is dealt with. All we do here is set `lower = True` which lowercases all of the text.\n\nNext we'll define the `Fields` for the tags. This dataset actually has two different sets of tags, [universal dependency (UD) tags](https://universaldependencies.org/u/pos/) and [Penn Treebank (PTB) tags](https://www.sketchengine.eu/penn-treebank-tagset/). We'll only train our model on the UD tags, but will load the PTB tags to show how they could be used instead.\n\n`UD_TAGS` handles how the UD tags should be handled. Our `TEXT` vocabulary - which we'll build later - will have *unknown* tokens in it, i.e. tokens that are not within our vocabulary. However, we won't have unknown tags as we are dealing with a finite set of possible tags. TorchText `Fields` initialize a default unknown token, `<unk>`, which we remove by setting `unk_token = None`.\n\n`PTB_TAGS` does the same as `UD_TAGS`, but handles the PTB tags instead.", "_____no_output_____" ] ], [ [ "TEXT = data.Field(lower = True)\nUD_TAGS = data.Field(unk_token = None)\nPTB_TAGS = data.Field(unk_token = None)", "_____no_output_____" ] ], [ [ "We then define `fields`, which handles passing our fields to the dataset.\n\nNote that order matters, if you only wanted to load the PTB tags your field would be:\n\n```\nfields = ((\"text\", TEXT), (None, None), (\"ptbtags\", PTB_TAGS))\n```\n\nWhere `None` tells TorchText to not load those tags.", "_____no_output_____" ] ], [ [ "fields = ((\"text\", TEXT), (\"udtags\", UD_TAGS), (\"ptbtags\", PTB_TAGS))", "_____no_output_____" ] ], [ [ "Next, we load the UDPOS dataset using our defined fields.", "_____no_output_____" ] ], [ [ "train_data, valid_data, test_data = datasets.UDPOS.splits(fields)", "_____no_output_____" ] ], [ [ "We can check how many examples are in each section of the dataset by checking their length.", "_____no_output_____" ] ], [ [ "print(f\"Number of training examples: {len(train_data)}\")\nprint(f\"Number of validation examples: {len(valid_data)}\")\nprint(f\"Number of testing examples: {len(test_data)}\")", "_____no_output_____" ] ], [ [ "Let's print out an example:", "_____no_output_____" ] ], [ [ "print(vars(train_data.examples[0]))", "_____no_output_____" ] ], [ [ "We can also view the text and tags separately:", "_____no_output_____" ] ], [ [ "print(vars(train_data.examples[0])['text'])", "_____no_output_____" ], [ "print(vars(train_data.examples[0])['udtags'])", "_____no_output_____" ], [ "print(vars(train_data.examples[0])['ptbtags'])", "_____no_output_____" ] ], [ [ "Next, we'll build the vocabulary - a mapping of tokens to integers. \n\nWe want some unknown tokens within our dataset in order to replicate how this model would be used in real life, so we set the `min_freq` to 2 which means only tokens that appear twice in the training set will be added to the vocabulary and the rest will be replaced by `<unk>` tokens.\n\nWe also load the [GloVe](https://nlp.stanford.edu/projects/glove/) pre-trained token embeddings. Specifically, the 100-dimensional embeddings that have been trained on 6 billion tokens. Using pre-trained embeddings usually leads to improved performance - although admittedly the dataset used in this tutorial is too small to take advantage of the pre-trained embeddings. \n\n`unk_init` is used to initialize the token embeddings which are not in the pre-trained embedding vocabulary. By default this sets those embeddings to zeros, however it is better to not have them all initialized to the same value, so we initialize them from a Normal/Gaussian distribution.\n\nThese pre-trained vectors are now loaded into our vocabulary and we will initialize our model with these values later.", "_____no_output_____" ] ], [ [ "MIN_FREQ = 2\n\nTEXT.build_vocab(train_data, \n min_freq = MIN_FREQ,\n vectors = \"glove.6B.100d\",\n unk_init = torch.Tensor.normal_)\n\n\nUD_TAGS.build_vocab(train_data)\nPTB_TAGS.build_vocab(train_data)", "_____no_output_____" ] ], [ [ "We can check how many tokens and tags are in our vocabulary by getting their length:", "_____no_output_____" ] ], [ [ "print(f\"Unique tokens in TEXT vocabulary: {len(TEXT.vocab)}\")\nprint(f\"Unique tokens in UD_TAG vocabulary: {len(UD_TAGS.vocab)}\")\nprint(f\"Unique tokens in PTB_TAG vocabulary: {len(PTB_TAGS.vocab)}\")", "_____no_output_____" ] ], [ [ "Exploring the vocabulary, we can check the most common tokens within our texts:", "_____no_output_____" ] ], [ [ "print(TEXT.vocab.freqs.most_common(20))", "_____no_output_____" ] ], [ [ "We can see the vocabularies for both of our tags:", "_____no_output_____" ] ], [ [ "print(UD_TAGS.vocab.itos)", "_____no_output_____" ], [ "print(PTB_TAGS.vocab.itos)", "_____no_output_____" ] ], [ [ "We can also see how many of each tag are in our vocabulary:", "_____no_output_____" ] ], [ [ "print(UD_TAGS.vocab.freqs.most_common())", "_____no_output_____" ], [ "print(PTB_TAGS.vocab.freqs.most_common())", "_____no_output_____" ] ], [ [ "We can also view how common each of the tags are within the training set:", "_____no_output_____" ] ], [ [ "def tag_percentage(tag_counts):\n \n total_count = sum([count for tag, count in tag_counts])\n \n tag_counts_percentages = [(tag, count, count/total_count) for tag, count in tag_counts]\n \n return tag_counts_percentages", "_____no_output_____" ], [ "print(\"Tag\\t\\tCount\\t\\tPercentage\\n\")\n\nfor tag, count, percent in tag_percentage(UD_TAGS.vocab.freqs.most_common()):\n print(f\"{tag}\\t\\t{count}\\t\\t{percent*100:4.1f}%\")", "_____no_output_____" ], [ "print(\"Tag\\t\\tCount\\t\\tPercentage\\n\")\n\nfor tag, count, percent in tag_percentage(PTB_TAGS.vocab.freqs.most_common()):\n print(f\"{tag}\\t\\t{count}\\t\\t{percent*100:4.1f}%\")", "_____no_output_____" ] ], [ [ "The final part of data preparation is handling the iterator. \n\nThis will be iterated over to return batches of data to process. Here, we set the batch size and the `device` - which is used to place the batches of tensors on our GPU, if we have one. ", "_____no_output_____" ] ], [ [ "BATCH_SIZE = 128\n\ndevice = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n\ntrain_iterator, valid_iterator, test_iterator = data.BucketIterator.splits(\n (train_data, valid_data, test_data), \n batch_size = BATCH_SIZE,\n device = device)", "_____no_output_____" ] ], [ [ "## Building the Model\n\nNext up, we define our model - a multi-layer bi-directional LSTM. The image below shows a simplified version of the model with only one LSTM layer and omitting the LSTM's cell state for clarity.\n\n\n\nThe model takes in a sequence of tokens, $X = \\{x_1, x_2,...,x_T\\}$, passes them through an embedding layer, $e$, to get the token embeddings, $e(X) = \\{e(x_1), e(x_2), ..., e(x_T)\\}$.\n\nThese embeddings are processed - one per time-step - by the forward and backward LSTMs. The forward LSTM processes the sequence from left-to-right, whilst the backward LSTM processes the sequence right-to-left, i.e. the first input to the forward LSTM is $x_1$ and the first input to the backward LSTM is $x_T$. \n\nThe LSTMs also take in the the hidden, $h$, and cell, $c$, states from the previous time-step\n\n$$h^{\\rightarrow}_t = \\text{LSTM}^{\\rightarrow}(e(x^{\\rightarrow}_t), h^{\\rightarrow}_{t-1}, c^{\\rightarrow}_{t-1})$$\n$$h^{\\leftarrow}_t=\\text{LSTM}^{\\leftarrow}(e(x^{\\leftarrow}_t), h^{\\leftarrow}_{t-1}, c^{\\leftarrow}_{t-1})$$\n\nAfter the whole sequence has been processed, the hidden and cell states are then passed to the next layer of the LSTM.\n\nThe initial hidden and cell states, $h_0$ and $c_0$, for each direction and layer are initialized to a tensor full of zeros.\n\nWe then concatenate both the forward and backward hidden states from the final layer of the LSTM, $H = \\{h_1, h_2, ... h_T\\}$, where $h_1 = [h^{\\rightarrow}_1;h^{\\leftarrow}_T]$, $h_2 = [h^{\\rightarrow}_2;h^{\\leftarrow}_{T-1}]$, etc. and pass them through a linear layer, $f$, which is used to make the prediction of which tag applies to this token, $\\hat{y}_t = f(h_t)$.\n\nWhen training the model, we will compare our predicted tags, $\\hat{Y}$ against the actual tags, $Y$, to calculate a loss, the gradients w.r.t. that loss, and then update our parameters.\n\nWe implement the model detailed above in the `BiLSTMPOSTagger` class.\n\n`nn.Embedding` is an embedding layer and the input dimension should be the size of the input (text) vocabulary. We tell it what the index of the padding token is so it does not update the padding token's embedding entry.\n\n`nn.LSTM` is the LSTM. We apply dropout as regularization between the layers, if we are using more than one.\n\n`nn.Linear` defines the linear layer to make predictions using the LSTM outputs. We double the size of the input if we are using a bi-directional LSTM. The output dimensions should be the size of the tag vocabulary.\n\nWe also define a dropout layer with `nn.Dropout`, which we use in the `forward` method to apply dropout to the embeddings and the outputs of the final layer of the LSTM.", "_____no_output_____" ] ], [ [ "class BiLSTMPOSTagger(nn.Module):\n def __init__(self, \n input_dim, \n embedding_dim, \n hidden_dim, \n output_dim, \n n_layers, \n bidirectional, \n dropout, \n pad_idx):\n \n super().__init__()\n \n self.embedding = nn.Embedding(input_dim, embedding_dim, padding_idx = pad_idx)\n \n self.lstm = nn.LSTM(embedding_dim, \n hidden_dim, \n num_layers = n_layers, \n bidirectional = bidirectional,\n dropout = dropout if n_layers > 1 else 0)\n \n self.fc = nn.Linear(hidden_dim * 2 if bidirectional else hidden_dim, output_dim)\n \n self.dropout = nn.Dropout(dropout)\n \n def forward(self, text):\n\n #text = [sent len, batch size]\n \n #pass text through embedding layer\n embedded = self.dropout(self.embedding(text))\n \n #embedded = [sent len, batch size, emb dim]\n \n #pass embeddings into LSTM\n outputs, (hidden, cell) = self.lstm(embedded)\n \n #outputs holds the backward and forward hidden states in the final layer\n #hidden and cell are the backward and forward hidden and cell states at the final time-step\n \n #output = [sent len, batch size, hid dim * n directions]\n #hidden/cell = [n layers * n directions, batch size, hid dim]\n \n #we use our outputs to make a prediction of what the tag should be\n predictions = self.fc(self.dropout(outputs))\n \n #predictions = [sent len, batch size, output dim]\n \n return predictions", "_____no_output_____" ] ], [ [ "## Training the Model\n\nNext, we instantiate the model. We need to ensure the embedding dimensions matches that of the GloVe embeddings we loaded earlier.\n\nThe rest of the hyperparmeters have been chosen as sensible defaults, though there may be a combination that performs better on this model and dataset.\n\nThe input and output dimensions are taken directly from the lengths of the respective vocabularies. The padding index is obtained using the vocabulary and the `Field` of the text.", "_____no_output_____" ] ], [ [ "INPUT_DIM = len(TEXT.vocab)\nEMBEDDING_DIM = 100\nHIDDEN_DIM = 128\nOUTPUT_DIM = len(UD_TAGS.vocab)\nN_LAYERS = 2\nBIDIRECTIONAL = True\nDROPOUT = 0.25\nPAD_IDX = TEXT.vocab.stoi[TEXT.pad_token]\n\nmodel = BiLSTMPOSTagger(INPUT_DIM, \n EMBEDDING_DIM, \n HIDDEN_DIM, \n OUTPUT_DIM, \n N_LAYERS, \n BIDIRECTIONAL, \n DROPOUT, \n PAD_IDX)", "_____no_output_____" ] ], [ [ "We initialize the weights from a simple Normal distribution. Again, there may be a better initialization scheme for this model and dataset.", "_____no_output_____" ] ], [ [ "def init_weights(m):\n for name, param in m.named_parameters():\n nn.init.normal_(param.data, mean = 0, std = 0.1)\n \nmodel.apply(init_weights)", "_____no_output_____" ] ], [ [ "Next, a small function to tell us how many parameters are in our model. Useful for comparing different models.", "_____no_output_____" ] ], [ [ "def count_parameters(model):\n return sum(p.numel() for p in model.parameters() if p.requires_grad)\n\nprint(f'The model has {count_parameters(model):,} trainable parameters')", "_____no_output_____" ] ], [ [ "We'll now initialize our model's embedding layer with the pre-trained embedding values we loaded earlier.\n\nThis is done by getting them from the vocab's `.vectors` attribute and then performing a `.copy` to overwrite the embedding layer's current weights.", "_____no_output_____" ] ], [ [ "pretrained_embeddings = TEXT.vocab.vectors\n\nprint(pretrained_embeddings.shape)", "_____no_output_____" ], [ "model.embedding.weight.data.copy_(pretrained_embeddings)", "_____no_output_____" ] ], [ [ "It's common to initialize the embedding of the pad token to all zeros. This, along with setting the `padding_idx` in the model's embedding layer, means that the embedding should always output a tensor full of zeros when a pad token is input.", "_____no_output_____" ] ], [ [ "model.embedding.weight.data[PAD_IDX] = torch.zeros(EMBEDDING_DIM)\n\nprint(model.embedding.weight.data)", "_____no_output_____" ] ], [ [ "We then define our optimizer, used to update our parameters w.r.t. their gradients. We use Adam with the default learning rate.", "_____no_output_____" ] ], [ [ "optimizer = optim.Adam(model.parameters())", "_____no_output_____" ] ], [ [ "Next, we define our loss function, cross-entropy loss.\n\nEven though we have no `<unk>` tokens within our tag vocab, we still have `<pad>` tokens. This is because all sentences within a batch need to be the same size. However, we don't want to calculate the loss when the target is a `<pad>` token as we aren't training our model to recognize padding tokens.\n\nWe handle this by setting the `ignore_index` in our loss function to the index of the padding token in our tag vocabulary.", "_____no_output_____" ] ], [ [ "TAG_PAD_IDX = UD_TAGS.vocab.stoi[UD_TAGS.pad_token]\n\ncriterion = nn.CrossEntropyLoss(ignore_index = TAG_PAD_IDX)", "_____no_output_____" ] ], [ [ "We then place our model and loss function on our GPU, if we have one.", "_____no_output_____" ] ], [ [ "model = model.to(device)\ncriterion = criterion.to(device)", "_____no_output_____" ] ], [ [ "We will be using the loss value between our predicted and actual tags to train the network, but ideally we'd like a more interpretable way to see how well our model is doing - accuracy.\n\nThe issue is that we don't want to calculate accuracy over the `<pad>` tokens as we aren't interested in predicting them.\n\nThe function below only calculates accuracy over non-padded tokens. `non_pad_elements` is a tensor containing the indices of the non-pad tokens within an input batch. We then compare the predictions of those elements with the labels to get a count of how many predictions were correct. We then divide this by the number of non-pad elements to get our accuracy value over the batch.", "_____no_output_____" ] ], [ [ "def categorical_accuracy(preds, y, tag_pad_idx):\n \"\"\"\n Returns accuracy per batch, i.e. if you get 8/10 right, this returns 0.8, NOT 8\n \"\"\"\n max_preds = preds.argmax(dim = 1, keepdim = True) # get the index of the max probability\n non_pad_elements = (y != tag_pad_idx).nonzero()\n correct = max_preds[non_pad_elements].squeeze(1).eq(y[non_pad_elements])\n return correct.sum() / torch.FloatTensor([y[non_pad_elements].shape[0]]).to(device)", "_____no_output_____" ] ], [ [ "Next is the function that handles training our model.\n\nWe first set the model to `train` mode to turn on dropout/batch-norm/etc. (if used). Then we iterate over our iterator, which returns a batch of examples. \n\nFor each batch: \n- we zero the gradients over the parameters from the last gradient calculation\n- insert the batch of text into the model to get predictions\n- as PyTorch loss functions cannot handle 3-dimensional predictions we reshape our predictions\n- calculate the loss and accuracy between the predicted tags and actual tags\n- call `backward` to calculate the gradients of the parameters w.r.t. the loss\n- take an optimizer `step` to update the parameters\n- add to the running total of loss and accuracy", "_____no_output_____" ] ], [ [ "def train(model, iterator, optimizer, criterion, tag_pad_idx):\n \n epoch_loss = 0\n epoch_acc = 0\n \n model.train()\n \n for batch in iterator:\n \n text = batch.text\n tags = batch.udtags\n \n optimizer.zero_grad()\n \n #text = [sent len, batch size]\n \n predictions = model(text)\n \n #predictions = [sent len, batch size, output dim]\n #tags = [sent len, batch size]\n \n predictions = predictions.view(-1, predictions.shape[-1])\n tags = tags.view(-1)\n \n #predictions = [sent len * batch size, output dim]\n #tags = [sent len * batch size]\n \n loss = criterion(predictions, tags)\n \n acc = categorical_accuracy(predictions, tags, tag_pad_idx)\n \n loss.backward()\n \n optimizer.step()\n \n epoch_loss += loss.item()\n epoch_acc += acc.item()\n \n return epoch_loss / len(iterator), epoch_acc / len(iterator)", "_____no_output_____" ] ], [ [ "The `evaluate` function is similar to the `train` function, except with changes made so we don't update the model's parameters.\n\n`model.eval()` is used to put the model in evaluation mode, so dropout/batch-norm/etc. are turned off. \n\nThe iteration loop is also wrapped in `torch.no_grad` to ensure we don't calculate any gradients. We also don't need to call `optimizer.zero_grad()` and `optimizer.step()`.", "_____no_output_____" ] ], [ [ "def evaluate(model, iterator, criterion, tag_pad_idx):\n \n epoch_loss = 0\n epoch_acc = 0\n \n model.eval()\n \n with torch.no_grad():\n \n for batch in iterator:\n\n text = batch.text\n tags = batch.udtags\n \n predictions = model(text)\n \n predictions = predictions.view(-1, predictions.shape[-1])\n tags = tags.view(-1)\n \n loss = criterion(predictions, tags)\n \n acc = categorical_accuracy(predictions, tags, tag_pad_idx)\n\n epoch_loss += loss.item()\n epoch_acc += acc.item()\n \n return epoch_loss / len(iterator), epoch_acc / len(iterator)", "_____no_output_____" ] ], [ [ "Next, we have a small function that tells us how long an epoch takes.", "_____no_output_____" ] ], [ [ "def epoch_time(start_time, end_time):\n elapsed_time = end_time - start_time\n elapsed_mins = int(elapsed_time / 60)\n elapsed_secs = int(elapsed_time - (elapsed_mins * 60))\n return elapsed_mins, elapsed_secs", "_____no_output_____" ] ], [ [ "Finally, we train our model!\n\nAfter each epoch we check if our model has achieved the best validation loss so far. If it has then we save the parameters of this model and we will use these \"best\" parameters to calculate performance over our test set.", "_____no_output_____" ] ], [ [ "N_EPOCHS = 15\n\nbest_valid_loss = float('inf')\n\nfor epoch in range(N_EPOCHS):\n\n start_time = time.time()\n \n train_loss, train_acc = train(model, train_iterator, optimizer, criterion, TAG_PAD_IDX)\n valid_loss, valid_acc = evaluate(model, valid_iterator, criterion, TAG_PAD_IDX)\n \n end_time = time.time()\n\n epoch_mins, epoch_secs = epoch_time(start_time, end_time)\n \n if valid_loss < best_valid_loss:\n best_valid_loss = valid_loss\n torch.save(model.state_dict(), 'tut1-model.pt')\n \n print(f'Epoch: {epoch+1:02} | Epoch Time: {epoch_mins}m {epoch_secs}s')\n print(f'\\tTrain Loss: {train_loss:.3f} | Train Acc: {train_acc*100:.2f}%')\n print(f'\\t Val. Loss: {valid_loss:.3f} | Val. Acc: {valid_acc*100:.2f}%')", "_____no_output_____" ] ], [ [ "We then load our \"best\" parameters and evaluate performance on the test set.", "_____no_output_____" ] ], [ [ "model.load_state_dict(torch.load('tut1-model.pt'))\n\ntest_loss, test_acc = evaluate(model, test_iterator, criterion, TAG_PAD_IDX)\n\nprint(f'Test Loss: {test_loss:.3f} | Test Acc: {test_acc*100:.2f}%')", "_____no_output_____" ] ], [ [ "## Inference\n\n88% accuracy looks pretty good, but let's see our model tag some actual sentences.\n\nWe define a `tag_sentence` function that will:\n- put the model into evaluation mode\n- tokenize the sentence with spaCy if it is not a list\n- lowercase the tokens if the `Field` did\n- numericalize the tokens using the vocabulary\n- find out which tokens are not in the vocabulary, i.e. are `<unk>` tokens\n- convert the numericalized tokens into a tensor and add a batch dimension\n- feed the tensor into the model\n- get the predictions over the sentence\n- convert the predictions into readable tags\n\nAs well as returning the tokens and tags, it also returns which tokens were `<unk>` tokens.", "_____no_output_____" ] ], [ [ "def tag_sentence(model, device, sentence, text_field, tag_field):\n \n model.eval()\n \n if isinstance(sentence, str):\n nlp = spacy.load('en')\n tokens = [token.text for token in nlp(sentence)]\n else:\n tokens = [token for token in sentence]\n\n if text_field.lower:\n tokens = [t.lower() for t in tokens]\n \n numericalized_tokens = [text_field.vocab.stoi[t] for t in tokens]\n\n unk_idx = text_field.vocab.stoi[text_field.unk_token]\n \n unks = [t for t, n in zip(tokens, numericalized_tokens) if n == unk_idx]\n \n token_tensor = torch.LongTensor(numericalized_tokens)\n \n token_tensor = token_tensor.unsqueeze(-1).to(device)\n \n predictions = model(token_tensor)\n \n top_predictions = predictions.argmax(-1)\n \n predicted_tags = [tag_field.vocab.itos[t.item()] for t in top_predictions]\n \n return tokens, predicted_tags, unks", "_____no_output_____" ] ], [ [ "We'll get an already tokenized example from the training set and test our model's performance.", "_____no_output_____" ] ], [ [ "example_index = 1\n\nsentence = vars(train_data.examples[example_index])['text']\nactual_tags = vars(train_data.examples[example_index])['udtags']\n\nprint(sentence)", "_____no_output_____" ] ], [ [ "We can then use our `tag_sentence` function to get the tags. Notice how the tokens referring to subject of the sentence, the \"respected cleric\", are both `<unk>` tokens!", "_____no_output_____" ] ], [ [ "tokens, pred_tags, unks = tag_sentence(model, \n device, \n sentence, \n TEXT, \n UD_TAGS)\n\nprint(unks)", "_____no_output_____" ] ], [ [ "We can then check how well it did. Surprisingly, it got every token correct, including the two that were unknown tokens!", "_____no_output_____" ] ], [ [ "print(\"Pred. Tag\\tActual Tag\\tCorrect?\\tToken\\n\")\n\nfor token, pred_tag, actual_tag in zip(tokens, pred_tags, actual_tags):\n correct = '✔' if pred_tag == actual_tag else '✘'\n print(f\"{pred_tag}\\t\\t{actual_tag}\\t\\t{correct}\\t\\t{token}\")", "_____no_output_____" ] ], [ [ "Let's now make up our own sentence and see how well the model does.\n\nOur example sentence below has every token within the model's vocabulary.", "_____no_output_____" ] ], [ [ "sentence = 'The Queen will deliver a speech about the conflict in North Korea at 1pm tomorrow.'\n\ntokens, tags, unks = tag_sentence(model, \n device, \n sentence, \n TEXT, \n UD_TAGS)\n\nprint(unks)", "_____no_output_____" ] ], [ [ "Looking at the sentence it seems like it gave sensible tags to every token!", "_____no_output_____" ] ], [ [ "print(\"Pred. Tag\\tToken\\n\")\n\nfor token, tag in zip(tokens, tags):\n print(f\"{tag}\\t\\t{token}\")", "_____no_output_____" ] ], [ [ "We've now seen how to implement PoS tagging with PyTorch and TorchText! \n\nThe BiLSTM isn't a state-of-the-art model, in terms of performance, but is a strong baseline for PoS tasks and is a good tool to have in your arsenal.", "_____no_output_____" ], [ "### Going deeper\nWhat if we could combine word-level and char-level approaches? \n\n\n\nActually, we can. Let's use LSTM or GRU to generate embedding for every word on char-level.\n\n*Image source: https://guillaumegenthial.github.io/sequence-tagging-with-tensorflow.html*\n\n\n*Image source: https://guillaumegenthial.github.io/sequence-tagging-with-tensorflow.html*", "_____no_output_____" ], [ "To do that we need to make few adjustments to the code above", "_____no_output_____" ] ], [ [ "# Now lets try both word and character embeddings\nWORD = data.Field(lower = True)\nUD_TAG = data.Field(unk_token = None)\nPTB_TAG = data.Field(unk_token = None)\n\n# We'll use NestedField to tokenize each word into list of chars\nCHAR_NESTING = data.Field(tokenize=list, init_token=\"<bos>\", eos_token=\"<eos>\")\nCHAR = data.NestedField(CHAR_NESTING)#, init_token=\"<bos>\", eos_token=\"<eos>\")\n\nfields = [(('word', 'char'), (WORD, CHAR)), ('udtag', UD_TAG), ('ptbtag', PTB_TAG)]\ntrain_data, valid_data, test_data = datasets.UDPOS.splits(fields)\n# train, val, test = datasets.UDPOS.splits(fields=fields)\n\nprint(train_data.fields)\nprint(len(train_data))\nprint(vars(train_data[0]))", "_____no_output_____" ], [ "WORD.build_vocab(\n train_data,\n min_freq = MIN_FREQ,\n vectors=\"glove.6B.100d\",\n unk_init = torch.Tensor.normal_\n)\n\n\nCHAR.build_vocab(train_data)\nUD_TAG.build_vocab(train_data)\nPTB_TAG.build_vocab(train_data)", "_____no_output_____" ], [ "print(f\"Unique tokens in WORD vocabulary: {len(WORD.vocab)}\")\nprint(f\"Unique tokens in CHAR vocabulary: {len(CHAR.vocab)}\")\nprint(f\"Unique tokens in UD_TAG vocabulary: {len(UD_TAG.vocab)}\")\nprint(f\"Unique tokens in PTB_TAG vocabulary: {len(PTB_TAG.vocab)}\")", "_____no_output_____" ], [ "BATCH_SIZE = 64\n\ndevice = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n\ntrain_iterator, valid_iterator, test_iterator = data.BucketIterator.splits(\n (train_data, valid_data, test_data), \n batch_size = BATCH_SIZE,\n device = device)", "_____no_output_____" ], [ "batch = next(iter(train_iterator))", "_____no_output_____" ], [ "text = batch.word\nchars = batch.char\ntags = batch.udtag\n", "_____no_output_____" ], [ "class BiLSTMPOSTaggerWithChars(nn.Module):\n def __init__(self, \n word_input_dim, \n word_embedding_dim,\n char_input_dim,\n char_embedding_dim,\n char_hidden_dim,\n hidden_dim,\n output_dim, \n n_layers, \n bidirectional, \n dropout, \n pad_idx):\n \n super().__init__()\n \n self.char_embedding = # YOUR CODE HERE\n self.char_gru = # YOUR CODE HERE\n \n self.word_embedding = nn.Embedding(word_input_dim, word_embedding_dim, padding_idx = pad_idx)\n self.lstm = nn.LSTM(word_embedding_dim + # YOUR CODE HERE, \n hidden_dim, \n num_layers = n_layers, \n bidirectional = bidirectional,\n dropout = dropout if n_layers > 1 else 0)\n \n self.fc = nn.Linear(hidden_dim * 2 if bidirectional else hidden_dim, output_dim)\n \n self.dropout = nn.Dropout(dropout)\n \n def forward(self, text, chars):\n\n #text = [sent len, batch size]\n \n #pass text through embedding layer\n embedded = self.dropout(self.word_embedding(text))\n #embedded = [sent len, batch size, emb dim]\n \n chars_embedded = # YOUR CODE HERE\n hid_from_chars = # YOUR CODE HERE\n \n embedded_with_chars = torch.cat([embedded, hid_from_chars], dim=2)\n \n \n #pass embeddings into LSTM\n outputs, (hidden, cell) = self.lstm(embedded_with_chars)\n# outputs, (hidden, cell) = self.lstm(hid)\n\n \n #outputs holds the backward and forward hidden states in the final layer\n #hidden and cell are the backward and forward hidden and cell states at the final time-step\n \n #output = [sent len, batch size, hid dim * n directions]\n #hidden/cell = [n layers * n directions, batch size, hid dim]\n \n #we use our outputs to make a prediction of what the tag should be\n predictions = self.fc(self.dropout(outputs))\n \n #predictions = [sent len, batch size, output dim]\n \n return predictions", "_____no_output_____" ], [ "INPUT_DIM = len(WORD.vocab)\nEMBEDDING_DIM = 100\nHIDDEN_DIM = 160\nCHAR_INPUT_DIM = 112\nCHAR_EMBEDDING_DIM = 30\nCHAR_HIDDEN_DIM = 30\nOUTPUT_DIM = len(UD_TAGS.vocab)\nN_LAYERS = 2\nBIDIRECTIONAL = True\nDROPOUT = 0.25\nPAD_IDX = TEXT.vocab.stoi[TEXT.pad_token]\n\nmodel = BiLSTMPOSTaggerWithChars(\n INPUT_DIM, \n EMBEDDING_DIM,\n CHAR_INPUT_DIM,\n CHAR_EMBEDDING_DIM,\n CHAR_HIDDEN_DIM,\n HIDDEN_DIM, \n OUTPUT_DIM, \n N_LAYERS, \n BIDIRECTIONAL, \n DROPOUT, \n PAD_IDX\n)", "_____no_output_____" ] ], [ [ "**Congratulations, you've got LSTM which relies on GRU output on each step.**\n\nNow we need only to train it. Same actions, very small adjustments.", "_____no_output_____" ] ], [ [ "def init_weights(m):\n for name, param in m.named_parameters():\n nn.init.normal_(param.data, mean = 0, std = 0.1)\n \nmodel.apply(init_weights)", "_____no_output_____" ], [ "def count_parameters(model):\n return sum(p.numel() for p in model.parameters() if p.requires_grad)\n\nprint(f'The model has {count_parameters(model):,} trainable parameters')", "_____no_output_____" ], [ "pretrained_embeddings = TEXT.vocab.vectors\n\nprint(pretrained_embeddings.shape)", "_____no_output_____" ], [ "model.word_embedding.weight.data.copy_(pretrained_embeddings)\nmodel.word_embedding.weight.data[PAD_IDX] = torch.zeros(EMBEDDING_DIM)\n\nprint(model.word_embedding.weight.data)", "_____no_output_____" ], [ "optimizer = optim.Adam(model.parameters())\n\nTAG_PAD_IDX = UD_TAGS.vocab.stoi[UD_TAGS.pad_token]\n\ncriterion = nn.CrossEntropyLoss(ignore_index = TAG_PAD_IDX)\n\nmodel = model.to(device)\ncriterion = criterion.to(device)", "_____no_output_____" ], [ "def train(model, iterator, optimizer, criterion, tag_pad_idx):\n \n epoch_loss = 0\n epoch_acc = 0\n \n model.train()\n \n for batch in iterator:\n \n text = batch.word\n chars = batch.char\n tags = batch.udtag\n \n optimizer.zero_grad()\n \n #text = [sent len, batch size]\n \n predictions = model(text, chars)\n \n #predictions = [sent len, batch size, output dim]\n #tags = [sent len, batch size]\n \n predictions = predictions.view(-1, predictions.shape[-1])\n tags = tags.view(-1)\n \n #predictions = [sent len * batch size, output dim]\n #tags = [sent len * batch size]\n \n loss = criterion(predictions, tags)\n \n acc = categorical_accuracy(predictions, tags, tag_pad_idx)\n \n loss.backward()\n \n optimizer.step()\n \n epoch_loss += loss.item()\n epoch_acc += acc.item()\n \n return epoch_loss / len(iterator), epoch_acc / len(iterator)\n\n\ndef evaluate(model, iterator, criterion, tag_pad_idx):\n \n epoch_loss = 0\n epoch_acc = 0\n \n model.eval()\n \n with torch.no_grad():\n \n for batch in iterator:\n\n text = batch.word\n chars = batch.char\n tags = batch.udtag\n \n predictions = model(text, chars)\n \n predictions = predictions.view(-1, predictions.shape[-1])\n tags = tags.view(-1)\n \n loss = criterion(predictions, tags)\n \n acc = categorical_accuracy(predictions, tags, tag_pad_idx)\n\n epoch_loss += loss.item()\n epoch_acc += acc.item()\n \n return epoch_loss / len(iterator), epoch_acc / len(iterator)\n", "_____no_output_____" ], [ "N_EPOCHS = 15\n\nbest_valid_loss = float('inf')\n\nfor epoch in range(N_EPOCHS):\n\n start_time = time.time()\n \n train_loss, train_acc = train(model, train_iterator, optimizer, criterion, TAG_PAD_IDX)\n valid_loss, valid_acc = evaluate(model, valid_iterator, criterion, TAG_PAD_IDX)\n \n end_time = time.time()\n\n epoch_mins, epoch_secs = epoch_time(start_time, end_time)\n \n if valid_loss < best_valid_loss:\n best_valid_loss = valid_loss\n torch.save(model.state_dict(), 'tut2-model.pt')\n \n print(f'Epoch: {epoch+1:02} | Epoch Time: {epoch_mins}m {epoch_secs}s')\n print(f'\\tTrain Loss: {train_loss:.3f} | Train Acc: {train_acc*100:.2f}%')\n print(f'\\t Val. Loss: {valid_loss:.3f} | Val. Acc: {valid_acc*100:.2f}%')", "_____no_output_____" ], [ "# Let's take a look at the model from the last epoch\ntest_loss, test_acc = evaluate(model, test_iterator, criterion, TAG_PAD_IDX)\n\nprint(f'Test Loss: {test_loss:.3f} | Test Acc: {test_acc*100:.2f}%')", "_____no_output_____" ], [ "# And at the best checkpoint (based on validation score)\nmodel.load_state_dict(torch.load('tut2-model.pt'))\n\ntest_loss, test_acc = evaluate(model, test_iterator, criterion, TAG_PAD_IDX)\n\nprint(f'Test Loss: {test_loss:.3f} | Test Acc: {test_acc*100:.2f}%')", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "## 1. Imports", "_____no_output_____" ] ], [ [ "import tensorflow as tf\nfrom PIL.Image import DecompressionBombError\nimport matplotlib.pyplot as plt\nimport json\nimport numpy as np\nimport cv2\nimport praw,requests\nimport psaw\nimport datetime as dt\nimport os\nimport sys\nfrom tensorflow.keras import models\nfrom tensorflow.keras import layers\nfrom tensorflow.keras import optimizers\nimport random", "_____no_output_____" ] ], [ [ "## 2. Functions", "_____no_output_____" ] ], [ [ "#Checks if two images are identical, returns true if they are, returns true if a file is blank\ndef compare2images(original,duplicate):\n if original is None or duplicate is None:\n return True #delete emtpy pictures\n if original.shape == duplicate.shape:\n #print(\"The images have same size and channels\")\n difference = cv2.subtract(original, duplicate)\n b, g, r = cv2.split(difference)\n if cv2.countNonZero(b) == 0 and cv2.countNonZero(g) == 0 and cv2.countNonZero(r) == 0:\n return True\n else:\n return False\n else:\n return False\n\n#A simple progress bar for transparency on the 20000 image processing tasks\ndef progress(purpose,currentcount, maxcount):\n sys.stdout.write('\\r')\n sys.stdout.write(\"{}: {:.1f}%\".format(purpose,(100/(maxcount-1)*currentcount)))\n sys.stdout.flush()\n\n#custom image data generator following this example https://www.pyimagesearch.com/2018/12/24/how-to-use-keras-fit-and-fit_generator-a-hands-on-tutorial/\ndef custom_file_image_generator(inputPath,bs,mode=\"train\",aug=None, max = 1, frompath=\"picsnew\"):\n f = open(inputPath, \"r\")\n while True:\n images = []\n labels = []\n while len(images)<bs:\n line = f.readline()\n if line == \"\":\n f.seek(0)\n line = f.readline()\n # if we are evaluating we should now break from our\n # loop to ensure we don't continue to fill up the\n # batch from samples at the beginning of the file\n if mode == \"eval\":\n break\n label = int(line.split(\".\")[0].split(\"_\")[0])\n stripped = line.strip('\\n')\n image = plt.imread(f\"{frompath}{stripped}\")\n #Removes alpha channel\n image = np.float32(image)[:,:,:3]\n #Neceesary resizing to avoid PIL pixel cap\n while image.shape[0] * image.shape[1]>89478485:\n image = cv2.resize(image, (0,0), fx=0.5, fy=0.5)\n cv2.cvtColor(image,cv2.COLOR_RGB2BGR)\n images.append(image)\n labels.append(label/max)\n labels = np.asarray(labels).T\n yield(np.asarray(images),labels)", "_____no_output_____" ] ], [ [ "## 3. Set up Reddit api for downloading images", "_____no_output_____" ] ], [ [ "#Set up API keys from .gitignored file\nwith open('config.json') as config_file:\n config = json.load(config_file)['keys']\n\n# Sign into Reddit using API Key\nreddit = praw.Reddit(user_agent=\"Downloading images from r/art for a machine learning project\",\n client_id=config['client_id'],\n client_secret=config['client_secret'],\n username=config['username'],\n password=config['password'])", "_____no_output_____" ] ], [ [ "## 4. Downloading pictures from Reddit r/art using PSAW and PRAW", "_____no_output_____" ] ], [ [ "#187mb for 200 pics, approx 18.7gb for 20000\n#Time periods to choose to download from\nJan12018 = int(dt.datetime(2018,1,1).timestamp())\nJan12019 = int(dt.datetime(2019,1,1).timestamp())\nJan12020 = int(dt.datetime(2020,1,1).timestamp())\nJan12021 = int(dt.datetime(2021,1,1).timestamp())\n\n#Pass a PRAW instance into PSAW so that scores are available\napi = psaw.PushshiftAPI(reddit)\n#Number of posts to try and download\nn = 30000\n#Path to download to\ndlpath = \"pics2/\"\n\nprint(\"Looking for posts using Pushshift...\")\n#this step takes a while\nposts = list(api.search_submissions(after = Jan12019, before=Jan12020, subreddit='art', limit = n*10))\nnumpostsfound = len(posts)\nprint(f\"Number of posts found: {numpostsfound}\")\ncounter = 0\n\nfor post in posts:\n if post.score>1:\n progress(\"Downloading\",counter,numpostsfound)\n counter +=1\n url = (post.url)\n #Save score for ML training, and post id for unique file names\n file_name = str(post.score) + \"_\" + str(post.id) + \".jpg\"\n try:\n #use requests to get image\n r = requests.get(url)\n fullfilename = dlpath + file_name\n #save image\n with open(fullfilename,\"wb\") as f:\n f.write(r.content)\n except (\n requests.ConnectionError,\n requests.exceptions.ReadTimeout,\n requests.exceptions.Timeout,\n requests.exceptions.ConnectTimeout,\n ) as e:\n print(e)\n \nfiles = [f for f in os.listdir(dlpath) if os.path.isfile(os.path.join(dlpath, f))]\n#Number of files downloaded not always the same as requested due to connection errors\nprint(f'\\nNumber of files downloaded: {len(files)}')", "_____no_output_____" ] ], [ [ "## 5. Processing code that removes pictures that are deleted/corrupt\nMight need to run multiple times if low on ram", "_____no_output_____" ] ], [ [ "#Path to delete bad pictures from\npath = \"pics2/\"\n\nfiles = [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))]\ncull = []\ncounter = 0\nlength = len(files)\nprint(f\"Original Number of files: {length}\")\n#Template of a bad picture\ndeletedtemplate = cv2.imread(\"exampledeleted.jpg\")\ndeletedtemplate2 = cv2.imread(\"exampledeleted2.jpg\")\nfor file in files:\n progress(\"Deleting bad files\",counter,length)\n counter+=1\n fullfilename = path + file\n candidate = cv2.imread(fullfilename)\n #if it's the same picture as the template or the picture is None\n if compare2images(deletedtemplate,candidate) or compare2images(deletedtemplate2,candidate):\n #delete\n os.remove(fullfilename)\nfiles2 = [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))]\nprint(f\"\\nFinal Number of files: {len(files2)}\")", "Original Number of files: 11377\nDeleting bad files: 100.0%\nFinal Number of files: 11364\n" ] ], [ [ "## 6. Preprocessing code that corrects grayscale images to RGB and rescales pictures to have maximum width or height of 1000\nIf I ran nn training with large images, it would take too long, and if I ran on google colab,\nI wouldn't have the drive space for all the pictrues", "_____no_output_____" ] ], [ [ "#Path being read from\npath = 'pics2/'\n#Path writing to\npath2 = 'picsfix/'\nfiles = [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))]\nlength = len(files)\ncounter = 0\nfailures = []\nfor file in files:\n try:\n progress(\"Resizing and fixing pictures\",counter,length)\n #OpenCV doesn't open jpegs\n img = plt.imread(f'{path}{file}')\n if len(img.shape) <3:\n # print(file)\n # print(img.shape)\n img= cv2.cvtColor(img,cv2.COLOR_GRAY2RGB)\n #Resize to 1000 max\n largestdim = max(img.shape)\n targetlargestdim = 1000\n scaling= targetlargestdim / largestdim\n #print(scaling)\n if(scaling<1): #If image is already smaller, don't bother upscaling\n smaller = cv2.resize(img, (0,0), fx=scaling, fy=scaling)\n else:\n smaller = img\n filename = path2+file\n plt.imsave(filename,smaller)\n counter += 1\n except DecompressionBombError as e:\n print(file)\n print(\"Decomp error\")\nprint(\"\\ndone\")", "_____no_output_____" ] ], [ [ "## 7. Plot histogram of scores to see how bad the bias towards lower scores is", "_____no_output_____" ] ], [ [ "path = \"picsfix2\"\nfiles = [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))]\nnumpics = len(files)\nlabelsall = []\nfor file in files:\n labelsall.append(int(file.split(\".\")[0].split(\"_\")[0]))\n#print(labelsall)\nplt.hist(labelsall)\nplt.yscale(\"log\")\nplt.ylabel(\"Frequency\")\nplt.xlabel(\"Score\")\nplt.title(\"Post score distribution, log scale\")\nplt.show()", "_____no_output_____" ] ], [ [ "## 7. Split files into training and testing sets and write the names of files to txt files\nI'm following [this guide](https://www.pyimagesearch.com/2018/12/24/how-to-use-keras-fit-and-fit_generator-a-hands-on-tutorial/)\nand using a file reader to reset the index to 0 seemed like the easiest solution to mimic what the author set up.", "_____no_output_____" ] ], [ [ "#Path of pictures to split and write txts for\npath = \"picsfix2/\"\ntrainingpath = \"training.txt\"\ntestingpath = \"testing.txt\"\nfiles = [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))]\n#randomize to avoid passing pictures to the neural net in alphabetical order\nrandom.shuffle(files)\n#print(files)\ntrainindex = int(np.round(0.8 * len(files)))\ntraining = files[0:trainindex]\ntesting = files[trainindex:]\nwith open(trainingpath, 'w') as f:\n for item in training:\n f.write(\"%s\\n\" % item)\nwith open(testingpath, 'w') as f:\n for item in testing:\n f.write(\"%s\\n\" % item)", "_____no_output_____" ] ], [ [ "## 8. Actual neural net training using Convolutional Neural Net\nI didn't have enough ram to train locally, so I ended porting to Google Colab and training there.\nThe trainin has not been succesful so far, and I haven't taken the time to diagnose why yet.", "_____no_output_____" ] ], [ [ "#Path of preprocessed pictures\npath = \"picsfix2/\"\n#Paths of training and testing txts that have file names\ntrainPath = 'training.txt'\ntestpath = 'testing.txt'\n#Get all file names\nfiles = [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))]\nnumpics = len(files)\nlabelsall = []\nfor file in files:\n labelsall.append(int(file.split(\".\")[0].split(\"_\")[0]))\nhighestScore = max(labelsall)\nprint(f'Highest score: {highestScore}')\n\n\n#Store all image arrays and image names in a list\ninput_shape=(None, None,3)\n\nNUM_EPOCHS = 12\nBS = 1\nNUM_TRAIN_IMAGES = int(np.round(0.8 * len(files)))\nNUM_TEST_IMAGES = len(files)-NUM_TRAIN_IMAGES\ntraingen = custom_file_image_generator(trainPath,BS, \"train\" , None,highestScore, path)\ntestgen = custom_file_image_generator(testpath,BS, \"train\", None,highestScore, path)\ntf.keras.backend.clear_session()\nconv_model = models.Sequential()\n#normalize pictures to [0 1]\nconv_model.add(layers.experimental.preprocessing.Rescaling(1./255))\nconv_model.add(layers.Conv2D(32, (3, 3), activation='relu',\n input_shape=input_shape))\nconv_model.add(layers.GlobalMaxPooling2D())\n# conv_model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n# conv_model.add(layers.MaxPooling2D(pool_size=(2, 2)))\nconv_model.add(layers.Flatten())\n#conv_model.add(layers.Dropout(0.2))\nconv_model.add(layers.Dense(512, activation='relu'))\nconv_model.add(layers.Dense(1, activation='linear'))\nLEARNING_RATE = 1e-4\nconv_model.compile(loss=tf.keras.losses.MeanSquaredError(),\n optimizer=optimizers.RMSprop(lr=LEARNING_RATE),\n metrics=['acc'])\nhistory_conv = conv_model.fit(traingen,\n steps_per_epoch= NUM_TRAIN_IMAGES // BS,\n validation_data=testgen,\n validation_steps = NUM_TEST_IMAGES // BS,\n epochs=NUM_EPOCHS)\nmodelfilename = 'art2.h5'\nconv_model.save(modelfilename)\n# plt.plot(history_conv.history['loss'])\n# plt.plot(history_conv.history['val_loss'])\n# plt.title('model loss')\n# plt.ylabel('loss')\n# plt.xlabel('epoch')\n# plt.legend(['train loss', 'val loss'], loc='upper right')\n# plt.show()\n#\n#\n# plt.plot(history_conv.history['acc'])\n# plt.plot(history_conv.history['val_acc'])\n# plt.title('model accuracy')\n# plt.ylabel('accuracy (%)')\n# plt.xlabel('epoch')\n# plt.legend(['train accuracy', 'val accuracy'], loc='lower right')\n# plt.show()\n", "Highest score: 54157\nEpoch 1/12\n 1443/14918 [=>............................] - ETA: 1:37:21 - loss: 0.0014 - acc: 0.0049" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "<a href=\"https://colab.research.google.com/github/skywalker0803r/c620/blob/main/notebook/experiment/gan_style_model.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>", "_____no_output_____" ], [ "# load data", "_____no_output_____" ] ], [ [ "import pandas as pd\nimport joblib\nfrom urllib.request import urlopen\nimport numpy as np\n\ndf_url = 'https://c620.s3-ap-northeast-1.amazonaws.com/c620_train.csv'\nc_url = 'https://c620.s3-ap-northeast-1.amazonaws.com/c620_col_names.pkl'\n\ndf = pd.read_csv(df_url,index_col=0)\nc = joblib.load(urlopen(c_url))\n\ncase_col = c['case']\nfeed_col = c['x41']\nop_col = c['density']+c['yRefluxRate']+c['yHeatDuty']+c['yControl']\nsp_col = c['vent_gas_sf'] + c['distillate_sf'] + c['sidedraw_sf'] + c['bottoms_sf']\nwt_col = c['vent_gas_x']+c['distillate_x']+c['sidedraw_x']+c['bottoms_x']\nall_col = case_col + feed_col + op_col + sp_col + wt_col\n\nprint(len(case_col))\nprint(len(feed_col))\nprint(len(op_col))\nprint(len(sp_col))\nprint(len(wt_col))\n\ndf[all_col].head(1)", "3\n41\n10\n164\n164\n" ], [ "case_col_idx = [all_col.index(i) for i in case_col]\nfeed_col_idx = [all_col.index(i) for i in feed_col]\nop_col_idx = [all_col.index(i) for i in op_col]\nsp_col_idx = [all_col.index(i) for i in sp_col]\nwt_col_idx = [all_col.index(i) for i in wt_col]", "_____no_output_____" ] ], [ [ "# preprocess data", "_____no_output_____" ] ], [ [ "from sklearn.utils import shuffle\nfrom torch.utils.data import TensorDataset,DataLoader\nfrom sklearn.preprocessing import MinMaxScaler\nimport torch\n\n# split data\ndf = shuffle(df)\np1 = int(len(df)*0.8)\np2 = int(len(df)*0.9)\n\n# to FloatTensor\ntrain = torch.FloatTensor(df[all_col].values[:p1])\nvaild = torch.FloatTensor(df[all_col].values[p1:p2])\ntest = torch.FloatTensor(df[all_col].values[p2:])\n\n# create DataLoader\ntrainset = TensorDataset(train[:,case_col_idx],train[:,feed_col_idx],train[:,op_col_idx],train[:,sp_col_idx],train[:,wt_col_idx])\ntrain_iter = DataLoader(trainset,batch_size=64)\n\nvaildset = TensorDataset(vaild[:,case_col_idx],vaild[:,feed_col_idx],vaild[:,op_col_idx],vaild[:,sp_col_idx],vaild[:,wt_col_idx])\nvaild_iter = DataLoader(vaildset,batch_size=64)\n\ntestset = TensorDataset(test[:,case_col_idx],test[:,feed_col_idx],test[:,op_col_idx],test[:,sp_col_idx],test[:,wt_col_idx])\ntest_iter = DataLoader(testset,batch_size=64)", "_____no_output_____" ] ], [ [ "# def model,loss,optimizer", "_____no_output_____" ] ], [ [ "import torch\nfrom torch import nn\nimport torch.nn.functional as F\n\ndef mlp(sizes, activation, output_activation=nn.Identity):\n layers = []\n for j in range(len(sizes)-1):\n act = activation if j < len(sizes)-2 else output_activation\n layers += [nn.Linear(sizes[j], sizes[j+1]), act()]\n return nn.Sequential(*layers)\n\nclass Model(nn.Module):\n def __init__(self):\n super(Model, self).__init__()\n self.op_model = mlp(\n [len(case_col)+len(feed_col),128,len(op_col)],\n nn.ReLU\n )\n self.sp_model = mlp(\n [len(case_col)+len(feed_col)+len(op_col),128,len(wt_col)],\n nn.ReLU,\n nn.Sigmoid\n )\n\n def forward(self,case,feed):\n op = self.op_model(torch.cat((case,feed),dim=-1)).clone()\n sp = self.sp_model(torch.cat((case,feed,op),dim=-1)).clone()\n for idx in range(41):\n sp[:,[idx,idx+41,idx+41*2,idx+41*3]] = self.normalize(sp[:,[idx,idx+41,idx+41*2,idx+41*3]])\n s1,s2,s3,s4 = sp[:,:41],sp[:,41:41*2],sp[:,41*2:41*3],sp[:,41*3:41*4]\n w1,w2,w3,w4 = self.sp2wt(feed,s1),self.sp2wt(feed,s2),self.sp2wt(feed,s3),self.sp2wt(feed,s4)\n wt = torch.cat((w1,w2,w3,w4),dim=-1)\n return op,sp,wt\n\n @staticmethod\n def normalize(x):\n return x / x.sum(dim=1).reshape(-1,1)\n \n @staticmethod\n def sp2wt(x,s):\n a = 100*x*s\n b = torch.diag([email protected]).reshape(-1,1)\n b = torch.clamp(b,1e-8,float('inf'))\n return a/b\n\n# model optimizer loss_fn\nmodel = Model()\noptimizer = torch.optim.Adam(model.parameters())\nloss_fn = nn.SmoothL1Loss()\n\n# forward test\nfor case,feed,op,sp,wt in train_iter:\n op_hat,sp_hat,wt_hat = model(case,feed)\n print(op_hat.shape)\n print(sp_hat.shape)\n print(wt_hat.shape)\n break", "torch.Size([64, 10])\ntorch.Size([64, 164])\ntorch.Size([64, 164])\n" ] ], [ [ "# tensorboard", "_____no_output_____" ] ], [ [ "from torch.utils.tensorboard import SummaryWriter\nwriter = SummaryWriter()\ncase,feed,op,sp,wt = next(iter(train_iter))\nwriter.add_graph(model,[case,feed])\nwriter.close()", "_____no_output_____" ], [ "%load_ext tensorboard\n%tensorboard --logdir runs", "The tensorboard extension is already loaded. To reload it, use:\n %reload_ext tensorboard\n" ] ], [ [ "# train model", "_____no_output_____" ] ], [ [ "import matplotlib.pyplot as plt\nfrom tqdm import tqdm_notebook as tqdm\nfrom copy import deepcopy\n\n# train step\ndef train_step(model):\n model.train()\n total_loss = 0\n for t,(case,feed,op,sp,wt) in enumerate(train_iter):\n op_hat,sp_hat,wt_hat = model(case,feed)\n op_loss = loss_fn(op_hat,op)\n sp_loss = loss_fn(sp_hat,sp)\n wt_loss = loss_fn(wt_hat,wt)\n Sidedraw_Benzene_loss = loss_fn(\n wt_hat[:,wt_col.index('Tatoray Stripper C620 Operation_Sidedraw Production Rate and Composition_Benzene_wt%')],\n case[:,case_col.index('Tatoray Stripper C620 Operation_Specifications_Spec 3 : Benzene in Sidedraw_wt%')])\n loss = op_loss + sp_loss + wt_loss + Sidedraw_Benzene_loss\n # update model\n loss.backward()\n optimizer.step()\n optimizer.zero_grad()\n total_loss += loss.item()\n return total_loss/(t+1)\n\n# valid step\ndef valid_step(model):\n model.eval()\n total_loss = 0\n for t,(case,feed,op,sp,wt) in enumerate(vaild_iter):\n op_hat,sp_hat,wt_hat = model(case,feed)\n op_loss = loss_fn(op_hat,op)\n sp_loss = loss_fn(sp_hat,sp)\n wt_loss = loss_fn(wt_hat,wt)\n Sidedraw_Benzene_loss = loss_fn(\n wt_hat[:,wt_col.index('Tatoray Stripper C620 Operation_Sidedraw Production Rate and Composition_Benzene_wt%')],\n case[:,case_col.index('Tatoray Stripper C620 Operation_Specifications_Spec 3 : Benzene in Sidedraw_wt%')])\n loss = op_loss + sp_loss + wt_loss + Sidedraw_Benzene_loss\n total_loss += loss.item()\n return total_loss/(t+1)\n\ndef train(model,max_epochs): \n history = {'train_loss':[],'valid_loss':[]}\n current_loss = np.inf\n best_model = None\n for i in tqdm(range(max_epochs)):\n history['train_loss'].append(train_step(model))\n history['valid_loss'].append(valid_step(model))\n if i % 10 == 0:\n print(\"epoch:{} train_loss:{:.4f} valid_loss:{:.4f}\".format(i,history['train_loss'][-1],history['valid_loss'][-1]))\n if history['valid_loss'][-1] <= current_loss:\n best_model = deepcopy(model.eval())\n current_loss = history['valid_loss'][-1]\n model = deepcopy(best_model.eval())\n plt.plot(history['train_loss'],label='train_loss')\n plt.plot(history['valid_loss'],label='valid_loss')\n plt.legend()\n plt.show()\n return model", "_____no_output_____" ], [ "model = train(model,max_epochs=250)", "_____no_output_____" ], [ "op_pred,sp_pred,wt_pred = model(test[:,case_col_idx],test[:,feed_col_idx])\n\nwt_pred = pd.DataFrame(wt_pred.detach().cpu().numpy(),columns=wt_col)\nop_pred = pd.DataFrame(op_pred.detach().cpu().numpy(),columns=op_col)\n\nwt_real = pd.DataFrame(test[:,wt_col_idx].detach().cpu().numpy(),columns=wt_col)\nop_real = pd.DataFrame(test[:,op_col_idx].detach().cpu().numpy(),columns=op_col)", "_____no_output_____" ], [ "from sklearn.metrics import r2_score,mean_squared_error\nimport numpy as np\nimport warnings \nwarnings.filterwarnings('ignore')\n\ndef mape(y_true, y_pred, e = 2e-2):\n y_true, y_pred = np.array(y_true), np.array(y_pred)\n mask = y_true > e\n y_true, y_pred = y_true[mask], y_pred[mask]\n return np.mean(np.abs((y_true - y_pred) / y_true)) * 100\n\ndef show_metrics(y_real,y_pred,e=2e-2):\n res = pd.DataFrame(index=y_pred.columns,columns=['R2','MSE','MAPE'])\n for i in y_pred.columns:\n res.loc[i,'R2'] = np.clip(r2_score(y_real[i],y_pred[i]),0,1)\n res.loc[i,'MSE'] = mean_squared_error(y_real[i],y_pred[i])\n res.loc[i,'MAPE'] = mape(y_real[i],y_pred[i],e)\n res.loc['AVG'] = res.mean(axis=0)\n return res", "_____no_output_____" ], [ "show_metrics(op_real,op_pred)", "_____no_output_____" ], [ "show_metrics(wt_real,wt_pred)", "_____no_output_____" ], [ "case = pd.DataFrame(test[:,case_col_idx].detach().cpu().numpy(),columns=case_col)\ncase.iloc[:,[2]]", "_____no_output_____" ], [ "wt_pred.iloc[:,[89]]", "_____no_output_____" ], [ "wt_real.head()", "_____no_output_____" ], [ "wt_pred.head()", "_____no_output_____" ], [ "op_real.head()", "_____no_output_____" ], [ "op_pred.head()", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "## 練習\n\n1. 数値 `x` の絶対値を求める関数 `absolute(x)` を定義してください。\n （Pythonには `abs` という組み込み関数が用意されていますが。）\n2. `x` が正ならば 1、負ならば -1、ゼロならば 0 を返す `sign(x)` という関数を定義してください。\n\n定義ができたら、その次のセルを実行して、`True` のみが表示されることを確認してください。", "_____no_output_____" ] ], [ [ "def absolute(x):\n ...", "_____no_output_____" ], [ "def sign(x):\n ...", "_____no_output_____" ], [ "print(absolute(5) == 5)\nprint(absolute(-5) == 5)\nprint(absolute(0) == 0)\nprint(sign(5) == 1)\nprint(sign(-5) == -1)\nprint(sign(0) == 0)", "_____no_output_____" ] ], [ [ "## 練習の解答", "_____no_output_____" ] ], [ [ "def absolute(x):\n if x<0:\n return -x\n else:\n return x", "_____no_output_____" ], [ "def sign(x):\n if x<0:\n return -1\n if x>0:\n return 1\n return 0", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "## Objective\n\nIn my previous tutorial, I showed how to use `apply_rows` and `apply_chunks` methods in cuDF to implement customized data transformations. Under the hood, they are all using [Numba library](https://numba.pydata.org/) to compile the normal python code into GPU kernels. Numba is an excellent python library that accelerates the numerical computations. Most importantly, Numba has direct CUDA programming support. For detailed information, please check out this [Numba CUDA document](https://numba.pydata.org/numba-doc/dev/cuda/index.html). As we know, the underlying data structure of cuDF is a GPU version of Apache Arrow. We can directly pass the GPU array around without the copying operation. Once we have the nice Numba library and standard GPU array, the sky is the limit. In this tutorial, I will show how to use Numba CUDA to accelerate cuDF data transformation and how to step by step accelerate it using CUDA programming tricks. \n\nThe following experiments are performed at DGX V100 node.", "_____no_output_____" ], [ "## A simple example\nAs usual, I am going to start with a simple example of doubling the numbers in an array:", "_____no_output_____" ] ], [ [ "import cudf\nimport numpy as np\nfrom numba import cuda\n \narray_len = 1000\nnumber_of_threads = 128\nnumber_of_blocks = (array_len + (number_of_threads - 1)) // number_of_threads\ndf = cudf.DataFrame()\ndf['in'] = np.arange(array_len, dtype=np.float64)\n \n \[email protected]\ndef double_kernel(result, array_len):\n \"\"\"\n double each element of the array\n \"\"\"\n i = cuda.grid(1)\n if i < array_len:\n result[i] = result[i] * 2.0\n \n \nbefore = df['in'].sum()\ngpu_array = df['in'].to_gpu_array()\nprint(type(gpu_array))\ndouble_kernel[(number_of_blocks,), (number_of_threads,)](gpu_array, array_len)\nafter = df['in'].sum()\nassert(np.isclose(before * 2.0, after))", "<class 'numba.cuda.cudadrv.devicearray.DeviceNDArray'>\n" ] ], [ [ "From the output of this code, it shows the underlying GPU array is of type `numba.cuda.cudadrv.devicearray.DeviceNDArray`. We can directly pass it to the kernel function that is compiled by the `cuda.jit`. Because we passed in the reference, the effect of number transformation will automatically show up in the original cuDF Dataframe. Note we have to manually enter the block size and grid size, which gives us the maximum of GPU programming control. The `cuda.grid` is a convenient method to compute the absolute position for the threads. It is equivalent to the normal `block_id * block_dim + thread_id` formula.", "_____no_output_____" ], [ "## Practical example\n\n### Baseline\n\nWe will work on the moving average problem as the last time. Because we have the full control of the grid and block size allocation, the vanilla moving average implementation code is much simpler compared to the `apply_chunks` implementation. ", "_____no_output_____" ] ], [ [ "%reset -s -f", "_____no_output_____" ], [ "import cudf\nimport numpy as np\nimport pandas as pd\nfrom numba import cuda\nimport numba\nimport time\n \narray_len = int(5e8)\naverage_window = 3000\nnumber_of_threads = 128\nnumber_of_blocks = (array_len + (number_of_threads - 1)) // number_of_threads\ndf = cudf.DataFrame()\ndf['in'] = np.arange(array_len, dtype=np.float64)\ndf['out'] = np.arange(array_len, dtype=np.float64)\n \n \[email protected]\ndef kernel1(in_arr, out_arr, average_length, arr_len):\n s = numba.cuda.local.array(1, numba.float64)\n s[0] = 0.0\n i = cuda.grid(1)\n if i < arr_len:\n if i < average_length-1:\n out_arr[i] = np.inf\n else:\n for j in range(0, average_length):\n s[0] += in_arr[i-j]\n out_arr[i] = s[0] / np.float64(average_length)\n \n \ngpu_in = df['in'].to_gpu_array()\ngpu_out = df['out'].to_gpu_array()\nstart = time.time()\nkernel1[(number_of_blocks,), (number_of_threads,)](gpu_in, gpu_out,\n average_window, array_len)\ncuda.synchronize()\nend = time.time()\nprint('Numba with comipile time', end-start)\n \nstart = time.time()\nkernel1[(number_of_blocks,), (number_of_threads,)](gpu_in, gpu_out,\n average_window, array_len)\ncuda.synchronize()\nend = time.time()\nprint('Numba without comipile time', end-start)\n \npdf = pd.DataFrame()\npdf['in'] = np.arange(array_len, dtype=np.float64)\nstart = time.time()\npdf['out'] = pdf.rolling(average_window).mean()\nend = time.time()\nprint('pandas time', end-start)\n \nassert(np.isclose(pdf.out.values[average_window:].mean(),\n df.out.to_array()[average_window:].mean()))", "Numba with comipile time 2.067620038986206\nNumba without comipile time 1.9229750633239746\npandas time 5.2932703495025635\n" ] ], [ [ "Note, in order to compare the computation time accurately, I launch the kernel twice. The first time kernel launching will include the kernel compilation time. In this example, it takes 1.9s for the kernel to run without compilation. ", "_____no_output_____" ], [ "### Use shared memory\n\nIn the baseline code, each thread is reading the numbers from the global memory. When doing the moving average, the same number is read multiple times by different threads. GPU global memory IO, in this case, is the speed bottleneck. To mitigate it, we load the data into shared memory for each of the computation blocks. Then the threads are doing summation from the numbers in the cache. To do the moving average for the elements at the beginning of the array, we make sure to load the `average_window` more data in the shared_memory. ", "_____no_output_____" ] ], [ [ "%reset -s -f", "_____no_output_____" ], [ "import cudf\nimport numpy as np\nimport pandas as pd\nfrom numba import cuda\nimport numba\nimport time\n \narray_len = int(5e8)\naverage_window = 3000\nnumber_of_threads = 128\nnumber_of_blocks = (array_len + (number_of_threads - 1)) // number_of_threads\nshared_buffer_size = number_of_threads + average_window - 1\ndf = cudf.DataFrame()\ndf['in'] = np.arange(array_len, dtype=np.float64)\ndf['out'] = np.arange(array_len, dtype=np.float64)\n \n \[email protected]\ndef kernel1(in_arr, out_arr, average_length, arr_len):\n block_size = cuda.blockDim.x\n shared = cuda.shared.array(shape=(shared_buffer_size),\n dtype=numba.float64)\n i = cuda.grid(1)\n tx = cuda.threadIdx.x\n # Block id in a 1D grid\n bid = cuda.blockIdx.x\n starting_id = bid * block_size\n \n shared[tx + average_length - 1] = in_arr[i]\n cuda.syncthreads()\n for j in range(0, average_length - 1, block_size):\n if (tx + j) < average_length - 1:\n shared[tx + j] = in_arr[starting_id -\n average_length + 1 +\n tx + j]\n cuda.syncthreads()\n \n s = numba.cuda.local.array(1, numba.float64)\n s[0] = 0.0\n if i < arr_len:\n if i < average_length-1:\n out_arr[i] = np.inf\n else:\n for j in range(0, average_length):\n s[0] += shared[tx + average_length - 1 - j]\n out_arr[i] = s[0] / np.float64(average_length)\n \n \ngpu_in = df['in'].to_gpu_array()\ngpu_out = df['out'].to_gpu_array()\nstart = time.time()\nkernel1[(number_of_blocks,), (number_of_threads,)](gpu_in, gpu_out,\n average_window, array_len)\ncuda.synchronize()\nend = time.time()\n \nprint('Numba with comipile time', end-start)\n \nstart = time.time()\nkernel1[(number_of_blocks,), (number_of_threads,)](gpu_in, gpu_out,\n average_window, array_len)\ncuda.synchronize()\nend = time.time()\nprint('Numba without comipile time', end-start)\n \npdf = pd.DataFrame()\npdf['in'] = np.arange(array_len, dtype=np.float64)\nstart = time.time()\npdf['out'] = pdf.rolling(average_window).mean()\nend = time.time()\nprint('pandas time', end-start)\n \nassert(np.isclose(pdf.out.values[average_window:].mean(),\n df.out.to_array()[average_window:].mean()))", "Numba with comipile time 1.3115026950836182\nNumba without comipile time 1.085998773574829\npandas time 5.594487428665161\n" ] ], [ [ "Running this, the computation time is reduced to 1.09s without kernel compilation time. ", "_____no_output_____" ], [ "### Reduced redundant summations\n\nEach thread in the above code is doing one moving average in a for-loop. It is easy to see that there are a lot of redundant summation operations done by different threads. To reduce the redundancy, the following code is changed to let each thread to compute a consecutive number of moving averages. The later moving average step is able to reuse the sum of the previous steps. This eliminated `thread_tile` number of for-loops. ", "_____no_output_____" ] ], [ [ "%reset -s -f", "_____no_output_____" ], [ "import cudf\nimport numpy as np\nimport pandas as pd\nfrom numba import cuda\nimport numba\nimport time\n \narray_len = int(5e8)\naverage_window = 3000\nnumber_of_threads = 64\nthread_tile = 48\nnumber_of_blocks = (array_len + (number_of_threads * thread_tile - 1)) // (number_of_threads * thread_tile)\nshared_buffer_size = number_of_threads * thread_tile + average_window - 1\ndf = cudf.DataFrame()\ndf['in'] = np.arange(array_len, dtype=np.float64)\ndf['out'] = np.arange(array_len, dtype=np.float64)\n \n \[email protected]\ndef kernel1(in_arr, out_arr, average_length, arr_len):\n block_size = cuda.blockDim.x\n shared = cuda.shared.array(shape=(shared_buffer_size),\n dtype=numba.float64)\n tx = cuda.threadIdx.x\n # Block id in a 1D grid\n bid = cuda.blockIdx.x\n starting_id = bid * block_size * thread_tile\n \n for j in range(thread_tile):\n shared[tx + j * block_size + average_length - 1] = in_arr[starting_id\n + tx +\n j * block_size]\n cuda.syncthreads()\n for j in range(0, average_length - 1, block_size):\n if (tx + j) < average_length - 1:\n shared[tx + j] = in_arr[starting_id -\n average_length + 1 +\n tx + j]\n cuda.syncthreads()\n \n s = numba.cuda.local.array(1, numba.float64)\n first = False\n s[0] = 0.0\n for k in range(thread_tile):\n i = starting_id + tx * thread_tile + k\n if i < arr_len:\n if i < average_length-1:\n out_arr[i] = np.inf\n else:\n if not first:\n for j in range(0, average_length):\n s[0] += shared[tx * thread_tile + k + average_length - 1 - j]\n s[0] = s[0] / np.float64(average_length)\n out_arr[i] = s[0]\n first = True\n else:\n s[0] = s[0] + (shared[tx * thread_tile + k + average_length - 1]\n - shared[tx * thread_tile + k + average_length - 1 - average_length]) / np.float64(average_length)\n \n out_arr[i] = s[0]\n \n \ngpu_in = df['in'].to_gpu_array()\ngpu_out = df['out'].to_gpu_array()\nstart = time.time()\nkernel1[(number_of_blocks,), (number_of_threads,)](gpu_in, gpu_out,\n average_window, array_len)\ncuda.synchronize()\nend = time.time()\nprint('Numba with comipile time', end-start)\n \nstart = time.time()\nkernel1[(number_of_blocks,), (number_of_threads,)](gpu_in, gpu_out,\n average_window, array_len)\ncuda.synchronize()\nend = time.time()\nprint('Numba without comipile time', end-start)\n \npdf = pd.DataFrame()\npdf['in'] = np.arange(array_len, dtype=np.float64)\nstart = time.time()\npdf['out'] = pdf.rolling(average_window).mean()\nend = time.time()\nprint('pandas time', end-start)\n \nassert(np.isclose(pdf.out.values[average_window:].mean(),\n df.out.to_array()[average_window:].mean()))", "Numba with comipile time 0.6331000328063965\nNumba without comipile time 0.30219364166259766\npandas time 6.03054666519165\n" ] ], [ [ "After this change, the computation time is reduced to 0.3s without kernel compilation time, we achieved a total of 6x speedup compared with the baseline.", "_____no_output_____" ], [ "## Conclusion\n\nIn this tutorial, we take advantage of CUDA programming model in the Numba library to do moving average computation. We show by using a few CUDA programming tricks, we can achieve **6x** speed up in moving average computations for long arrays.\n\ncuDF is a powerful tool for data scientists to use. It provides the high-level API that covers most of the use cases. However, it also exposes its low-level components. Those components including gpu_array and Numba integration make the cuDF library to be very flexible to process data in a customized way. ", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import glob\nimport os\nfrom typing import Any, Dict, List, Tuple, Union\n\nimport torch\nimport yaml\nfrom torch.utils.data import DataLoader, random_split\nfrom torchvision.datasets import ImageFolder, VisionDataset\n\nfrom torchvision import transforms\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom tqdm import tqdm\n\nfrom model import CustomVGG\nimport torchvision", "_____no_output_____" ], [ "device = 'cuda'\nlr = 0.0001\nnum_epoch = 100\nl1_weight = 0.01\n\ninput_size = 128\nbatch_size = 128\nn_worker = 8", "_____no_output_____" ], [ "import torchvision.transforms.functional as TF\nimport random\n\nclass MyRotationTransform:\n \"\"\"Rotate by one of the given angles.\"\"\"\n\n def __init__(self, angles):\n self.angles = angles\n\n def __call__(self, x):\n angle = random.choice(self.angles)\n return TF.rotate(x, angle)\n\nrotation_transform = MyRotationTransform(angles=[0, 180, 90, 270])", "_____no_output_____" ], [ "normalize = transforms.Normalize(mean= [0.485, 0.456, 0.406],\n std= [0.229, 0.224, 0.225])\n\ntrain_dataset = ImageFolder(\n \"/opt/ml/data/train\", transforms.Compose([\n transforms.Resize((input_size, input_size)),\n #transforms.RandomCrop(input_size),\n transforms.RandomHorizontalFlip(),\n #transforms.ColorJitter(brightness=0.5, contrast=0.2, saturation=0.5, hue=0.1),\n MyRotationTransform(angles=[0, 180, 90, 270]),\n transforms.ToTensor(),\n normalize,\n ]))\n\nval_dataset = ImageFolder(\"/opt/ml/data/val\", transforms.Compose([\n transforms.Resize((input_size, input_size)),\n #transforms.Resize(int(input_size/0.875)),\n #transforms.CenterCrop(input_size),\n transforms.ToTensor(),\n normalize,\n ]))", "_____no_output_____" ], [ "from torch.utils.data.sampler import WeightedRandomSampler\n\nsample_freq = [1169, 4826, 1020, 2655, 4879, 1092] #[0] * len(train_dataset.classes) #df_ff.gender.value_counts().sort_index().to_numpy()\nsample_weight = np.concatenate([[1/f]*f for f in sample_freq])\nsample_weight = torch.from_numpy(sample_weight)\nsampler = WeightedRandomSampler(sample_weight.type('torch.DoubleTensor'), len(sample_weight)//2)", "_____no_output_____" ], [ "idx = np.random.randint(0, len(train_dataset))\n\nfig, axes = plt.subplots(1, 5, figsize=(15, 3))\nfor i in range(5):\n img, label = train_dataset[idx]\n img = img.permute(1,2,0) * np.array([0.229, 0.224, 0.225]) + np.array([0.485, 0.456, 0.406])\n axes[i].imshow(img)\n axes[i].set_title(train_dataset.classes[label])\n axes[i].axis('off')\nplt.show()", "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" ], [ "train_loader = torch.utils.data.DataLoader(\n train_dataset,\n batch_size=batch_size, drop_last=True, sampler = sampler,\n num_workers=n_worker)\n\nval_loader = torch.utils.data.DataLoader(\n val_dataset,\n batch_size=batch_size, shuffle=False,\n num_workers=n_worker)\n\ndataloaders = { 'train' : train_loader, 'valid' : val_loader}", "_____no_output_____" ], [ "model = CustomVGG()\nmodel.to(device)\nmodel.load_state_dict(torch.load('save/vgg9_112.pt'))", "_____no_output_____" ], [ "model = torchvision.models.vgg19_bn(pretrained=True)\nwith torch.no_grad():\n for m in model.features:\n if isinstance(m, torch.nn.Conv2d):\n m.bias = None\n # elif isinstance(m, torch.nn.BatchNorm2d):\n # m.weight.fill_(0.5)\nmodel.avgpool = torch.nn.AvgPool2d(4)\nmodel.classifier = torch.nn.Linear(512, 6)\nmodel.to(device)", "_____no_output_____" ], [ "import torch.optim as optim\nfrom torch.nn import CrossEntropyLoss\n\ncriterion = CrossEntropyLoss()\noptimizer = optim.Adam(model.parameters(), lr=lr)\nlr_scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'max', verbose=True, patience=5) # optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=60, eta_min=0.000001)#", "_____no_output_____" ], [ "from trainer_reg import Trainer\n\ntrainer = Trainer('/opt/ml/code/save', seed=42)", "_____no_output_____" ], [ "trainer.train(model, dataloaders, criterion, optimizer, lr_scheduler, num_epoch, 10, l1_weight, 'test')", "Epoch 1/100\n----------\n" ], [ "bn = []\n\nfor m in model.modules():\n if isinstance(m, torch.nn.BatchNorm2d):\n #print(m.weight)\n #break\n bn += m.weight.tolist()", "_____no_output_____" ], [ "model_base = CustomVGG()\nmodel_base.load_state_dict(torch.load('save/vgg9_112_reg.pt'))\nmodel_base = model_base.eval()", "_____no_output_____" ], [ "bn_base = []\n\nfor m in model_base.modules():\n if isinstance(m, torch.nn.BatchNorm2d):\n #print(m.weight)\n #break\n bn_base += m.weight.tolist()", "_____no_output_____" ], [ "plt.plot(sorted(bn), label='regularized')\nplt.plot(sorted(bn_base), label='base')\nplt.legend()\nplt.show()", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# DS107 Big Data : Lesson Five Companion Notebook", "_____no_output_____" ], [ "### Table of Contents <a class=\"anchor\" id=\"DS107L5_toc\"></a>\n\n* [Table of Contents](#DS107L5_toc)\n * [Page 1 - Introduction](#DS107L5_page_1)\n * [Page 2 - Spark](#DS107L5_page_2)\n * [Page 3 - Running Spark in Hadoop](#DS107L5_page_3)\n * [Page 4 - Spark Data Storage](#DS107L5_page_4)\n * [Page 5 - Introduction to Scala](#DS107L5_page_5)\n * [Page 6 - Using Spark 2.0](#DS107L5_page_6)\n * [Page 7 - Using Spark SQL](#DS107L5_page_7)\n * [Page 8 - Spark Shell](#DS107L5_page_8)\n * [Page 9 - Decision Trees in Spark MLLib](#DS107L5_page_9)\n * [Page 10 - Decision Trees and Accuracy](#DS107L5_page_10)\n * [Page 11 - Hyperparameter Tuning](#DS107L5_page_11)\n * [Page 12 - Best Fit Model](#DS107L5_page_12)\n * [Page 13 - Key Terms](#DS107L5_page_13)\n * [Page 14 - Lesson 5 Practice Hands-On](#DS107L5_page_14)\n * [Page 15 - Lesson 5 Practice Hands-On Solution](#DS107L5_page_15)\n * [Page 16 - Lesson 5 Practice Hands-On Solution - Alternative Assignment](#DS107L5_page_16)\n ", "_____no_output_____" ], [ "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n\n# Page 1 - Overview of this Module<a class=\"anchor\" id=\"DS107L5_page_1\"></a>\n\n[Back to Top](#DS107L5_toc)\n\n<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">", "_____no_output_____" ] ], [ [ "from IPython.display import VimeoVideo\n# Tutorial Video Name: Spark 2.0 and Zeppelin\nVimeoVideo('388865681', width=720, height=480)", "_____no_output_____" ] ], [ [ "The transcript for the above overview video **[is located here](https://repo.exeterlms.com/documents/V2/DataScience/Video-Transcripts/DSO107L05overview.zip)**.\n\n# Introduction\n\nProbably the most useful and versatile big data program you could utilize is *Spark*. It has wide-reaching functionality, including a SQL and a machine learning module, and can be used in many different languages. In this lesson, you will learn about: \n\n* Different components of Spark\n* Ways to run Spark on your Hadoop cluster\n* Apache Zeppelin, a notebook interface for Hadoop\n* Three ways to store data in Spark\n* Scala basics\n* Using Spark 2.0\n* Using Spark SQL\n* Launching the Spark Shell\n* Decision Trees in Spark using Scala\n\nThis lesson will culminate in a hands-on in which you perform your own decision tree machine learning model in Spark and Scala.\n\n<div class=\"panel panel-success\">\n <div class=\"panel-heading\">\n <h3 class=\"panel-title\">Additional Info!</h3>\n </div>\n <div class=\"panel-body\">\n <p>You may want to watch this <a href=\"https://vimeo.com/458401059\"> recorded live workshop on the concepts in this lesson. </a> </p>\n </div>\n</div>", "_____no_output_____" ], [ "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n\n# Page 2 - Spark<a class=\"anchor\" id=\"DS107L5_page_2\"></a>\n\n[Back to Top](#DS107L5_toc)\n\n<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n", "_____no_output_____" ], [ "# Spark\n\n*Spark* is a data processing program built on top of MapReduce in the Hadoop ecosystem. Among many, many other things, it allows you to perform machine learning, data mining, and data streaming. It is powerful, fast, and scalable. How fast, you ask? 100 times faster than MapReduce, which is why MapReduce has pretty much become obsolete as an actual tool, though it remains an incredibly important and foundational big data concept. It uses the same kind of framework as TEZ to work backwards and find the fastest solution to your queries. Spark is actually written in *Scala*, but you can code in Spark using Python, Scala, or Java, with Python and Scala being the most popular languages. When using Spark, there are a lot of similarities between Python and Scala.\n\n---\n\n## Spark Components \n\nSpark has come a long way in the last several years, and now has a lot of different components that you can utilize within Spark to get varying data science tasks completed. These components include:\n\n* **Spark Core:** This is the base program for Spark. It is also known as *Spark 1.0*. \n* **Spark Streaming:** Allows you to feed in real-time data and provide real-time output. \n* **Spark SQL:** Write SQL queries and use SQLite functions in Spark. This is part of *Spark 2.0.* \n* **MLLib:** A library of machine learning and data mining tools you can use in Spark. This is also part of *Spark 2.0*.\n* **GraphX:** Allows you to create social network graphs and determine the degrees of separation in your data.\n\nOf these Spark components, you will be introduced to all but GraphX, which is quite specialized.\n\n---\n\n## Basic Programming Steps in Spark\n\nAlthough you will be using Spark to do all kinds of big data work, there are a few general steps that you will most likely always take when working in Spark:\n\n* Run transformations on the input data set\n* Run actions on the transformed data that can be stored or used\n* Work further with the results in a distributed fashion and see where to go next.\n\n---\n\n## Spark SQL\n\nSpark SQL allows you to transform your Spark DataFrames and DataSets into SQL tables, so that you can run SQL queries in Spark. With Spark SQL, you have the ability to read and write to a variety of file types, including JSON, Hive, and Parquet, and you can communicate with database connectors and with Tableau. \n\n---", "_____no_output_____" ], [ "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n\n# Page 3 - Running Spark in Hadoop<a class=\"anchor\" id=\"DS107L5_page_3\"></a>\n\n[Back to Top](#DS107L5_toc)\n\n<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n", "_____no_output_____" ], [ "# Running Spark in Hadoop\n\nThere are three ways you can interact with Spark on your Hadoop cluster: \n\n1. Write files in a text editor and then run them through the command prompt. \n2. Use the Spark Shell.\n3. Interact with Spark in *Zeppelin*, which is a notebook system similar to Jupyter Notebook that you can access on Hadoop.\n\nYou will make use of Apache Zeppelin over the next few pages, then you'll switch to using the Spark Shell.\n\n---\n\n## Apache Zeppelin\n\nLuckily for you, Zeppelin comes pre-installed on your Hortonworks instance of Hadoop, and Zeppelin even comes with interaction to Spark 1.0 and 2.0, so that you can hit the ground running! You will access your Zeppelin notebook by typing **[http://127.0.0.1:9995](http://127.0.0.1:9995)** into your browser. \n\nHere's what it will look like when you get there:\n\n\n\n<div class=\"panel panel-success\">\n <div class=\"panel-heading\">\n <h3 class=\"panel-title\">Additional Info!</h3>\n </div>\n <div class=\"panel-body\">\n <p>You will learn the basics here, but if you want more tutorials, Zeppelin just happens to have them for you here - in particular look at the ones labeled Lab... and the ones labeled Zeppelin Tutorial if you want to go into more detail!</p>\n </div>\n</div>\n\nYou can get started by clicking on `Create new note`. When you do, it will ask you to give it a name:\n\n\n\nOnce you do, you'll get to this section here:\n\n\n\nYou will be able to type code into the cell, and just like Jupyter Notebook, either pressing the arrow button or typing `shift + enter` will run the cell.\n\n---\n\n### Ensure it Interprets Spark and Markdown\n\nClick the little black gear icon in the upper right hand corner of your Zeppelin notebook, which will bring up a menu looking something like this:\n\n\n\nYou will want to ensure that `spark` is first on that list, followed by `md`, for Markdown. Changing these settings makes sure that the Notebook processes the right type of languages or programs.\n\n---\n\n### Tell Zeppelin the Language\n\nThe `%` sign tells Zeppelin what language you want to use for each cell. Try out something in Markdown, just to get a feel for it. Type in:\n\n```\n%md\n# Testing out Markdown\nThis is text\n```\n\nAnd hit `shift + enter`. It should start running for you, and when it's done, the information you have should be output in Markdown, which can make web text much prettier. You can use Markdown for all your notes, just like you do in Jupyter.\n\n\n\n---", "_____no_output_____" ], [ "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n\n# Page 4 - Spark Data Storage<a class=\"anchor\" id=\"DS107L5_page_4\"></a>\n\n[Back to Top](#DS107L5_toc)\n\n<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n", "_____no_output_____" ], [ "# Spark Data Storage\n\nThere are three main ways that data can be stored in Spark:\n\n* Resilient Distributed Datasets (RDDs)\n* DataSets\n* DataFrames\n\nRDDs are an artifact of Spark 1.0, and they will covered in more detail later on. This lesson will cover both DataSets and DataFrames, which are part of Spark 2.0's architecture. *RDDs* are a type of data storage that distribute your data across your Hadoop cluster, but they are somewhat slow. Mostly, you will only utilize them in Spark 1.0. \n\n*DataSets* are similar to RDDs, but they speed up the process, by utilizing more efficient memory representation in Spark. \n\nA *DataFrame* is a subclass of a DataSet, and they are specifically meant for relational data. A DataFrame keeps ahold of rows and columns in Spark, which allows you to do more with your data.\n\n<div class=\"panel panel-info\">\n <div class=\"panel-heading\">\n <h3 class=\"panel-title\">Tip!</h3>\n </div>\n <div class=\"panel-body\">\n <p>If you ever need to really optimize something, and pick up the speed of your work, use DataSets instead of DataFrames, since they don't have to store a structure.</p>\n </div>\n</div>\n\n---", "_____no_output_____" ], [ "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n\n# Page 5 - Introduction to Scala<a class=\"anchor\" id=\"DS107L5_page_5\"></a>\n\n[Back to Top](#DS107L5_toc)\n\n<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n", "_____no_output_____" ], [ "# Introduction to Scala\n\nAlthough you can and will utilize Spark through Python in later lessons, which together is called *PySpark*, this lesson will make use of Scala. That means you can check another language off your bucket list! There are a few advantages to using Scala when it comes to Spark, since Spark is natively written in Scala. Those advantages include:\n\n* Your program is more likely to run as intended, because your code does not have to get translated between languages or environments.\n* Access to the most recent updates. It takes time to translate the most recent changes into other languages, so you might be a step or two behind in technology without using Scala.\n* You will understand Spark better, because it is natively written in Scala.\n* You save time and are more efficient because you will never need to switch between languages when using Spark.\n\n<div class=\"panel panel-success\">\n <div class=\"panel-heading\">\n <h3 class=\"panel-title\">Additional Info!</h3>\n </div>\n <div class=\"panel-body\">\n <p>Here is a list of <a href=\"https://alvinalexander.com/scala/scala-data-types-bits-ranges-int-short-long-float-double\"> all the different data types in Scala! </a></p>\n </div>\n</div>\n\n---\n\n## Values and Variables in Scala\n\nOften you will see in Scala code the designations of `val` and `var`. `val` stands for a value, and it is something that cannot be changed once it has been assigned. `var` stands for variable, and you can change it. When creating objects, you will need to designate them as either `val` or `var`, with `val` being by far the most common.\n\n---\n\n## How to Comment in Scala\n\nYou can comment out code in scala for a single line using `//` at the beginning. It would look something like this:\n\n```scala\n//This is a comment! Scala won't read it as code.\n```\n\n---", "_____no_output_____" ], [ "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n\n# Page 6 - Using Spark 2.0<a class=\"anchor\" id=\"DS107L5_page_6\"></a>\n\n[Back to Top](#DS107L5_toc)\n\n<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n", "_____no_output_____" ], [ "# Using Spark 2.0\n\nNow that you've been introduced to Zeppelin, and thus have the environment you'll use to interact with Spark, you will really start to get into Spark 2.0 and Scala! You will do the work on this page in Zeppelin.\n\n---\n\n## Reading in Data\n\nThe first thing you will do is read in your data. For learning Spark 2.0 and Spark SQL, you will be looking at **[data with movie ratings](https://repo.exeterlms.com/documents/V2/DataScience/Big-Data/u.data.zip)**. There is also a file that has the **[movie names](https://repo.exeterlms.com/documents/V2/DataScience/Big-Data/u.item.zip)** contained in it. Make sure you upload these files to the `files` view, which will allow you to follow along with the lesson.\n\nYou'll start by creating a line that identifies the structure that your data will have:\n\n```scala\nfinal case class Table(movieID: Int, rating: Int)\n```\n\n`Table` is just the name you will give to your data; it could be anything you like. Within the parentheses, you have key-value pairs that represents the header and data type of each column. In this case, the data only has two rows, so that keeps it nice and simple! Further, both are integers (`Int`), making this even easier.\n\nThen, you will need to transform your file into an RDD, by mapping. In Scala, you will always start this with `val`. Next, you'll give your RDD a name; in this case, `MappedTable`. Then you will call `sc` for `Spark Context`, which just tells Zeppelin you are using Spark, and use the `textFile.map` command to map a flat text file into a usable RDD. You will put the file pathway in for the data. Since you uploaded it earlier to your `maria_dev` section of your `Files View` in Ambari, the pathway below should work for you.\n\nNext, call the `map` function. Here, you are basically separating your data into columns. `x =>` basically tells it that you are going to define the way to split things next, and in the curly brackets `{}`, you will find that map of how to split, based on `val fields`. This uses the `.split` function to break at the delimiter specified in the parentheses - in this case, tab: `\\t`. You could also split by other things, including, but not limited to, commas. Then, you will call the `Table` structure you created earlier, and map each field to the appropriate data structure. Each field will be numbered in parentheses (i.e.`fields(1)`), and should be followed by `.to` the data type. Since these were both `Int`, they are going to `Int`. The data type you specified above for `Table` must match what you call here.\n\n```scala\nval MappedTable = sc.textFile(\"hdfs:///user/maria_dev/u.data\").map(x => {val fields = x.split(\"\\t\"); Table(fields(1).toInt, fields(2).toInt)})\n```\n\nWhen you run those two lines together up above, you will most likely get a warning looking something like this:\n\n```text\nwarning: there were 1 unchecked warning(s); re-run with -unchecked for details\ndefined class Rating\nlines: org.apache.spark.rdd.RDD[Rating] = MapPartitionsRDD[85] at map at <console>:43\n```\n\nThat is perfectly fine; just a warning and something you can ignore.\n\n---\n\n## Making Data into a Spark 2.0 DataFrame\n\nYou now have your data in an RDD, which is serviceable, but slow and clunky compared to Spark 2.0's concept of a DataFrame. So, from this RDD, you will transfer to a DataFrame. Start by importing `sqlContext.implicits._`, which is what tells Zeppelin that you are now working with Spark 2.0.\n\nThen, you will use the function `.toDF()` to turn the `MappedTable` from above into a DataFrame. You will need to start the line with `val` and give it a name; in this case `DFtable` is being used.\n\nLastly, you can call the `printSchema()` function on your newly created DataFrame, which will provide you with the structure of the data.\n\n```scala\nimport sqlContext.implicits._\nval DFtable = MappedTable.toDF()\n\nDFtable.printSchema()\n```\n\nHere is the end result: \n\n```text\n |-- movieID: integer (nullable = false)\n |-- rating: integer (nullable = false)\n```\n\nAs you can see, they are both integers and they do not allow null values.\n\n---\n\n## Find the Most Popular Movies\n\nNow, you can leverage the power of Spark 2.0 and Scala to find the highest rated movies! You'll make use of the functions `groupBy()`, `count()` and `orderBy()` to produce some meaningful results: \n\n```scala\nval MostPopularMovies = DFtable.groupBy(\"movieID\").count().orderBy(desc(\"count\")).cache()\nMostPopularMovies.show()\n```\n\nThe code above first creates a table named `MostPopularMovies`. Then it uses the `DFtable` you created in the previously code line to group the data by `movieID` and get a count of how many times each `movieID` was referenced. Then, it orders the data by that `count` that was just created. Finally, this newly created table is cached (`.cache()`), so that it will stay in memory and will make referencing it faster.\n\n<div class=\"panel panel-info\">\n <div class=\"panel-heading\">\n <h3 class=\"panel-title\">To Cache or Not to Cache?</h3>\n </div>\n <div class=\"panel-body\">\n <p>That 'tis the question! Typically, if you are going to use data more than once and it is relatively small, you will save more memory and data usage on your cluster than if you didn't cache.</p>\n </div>\n</div>\n\nWith all that done, it is easy to use the `.show()` command, which is much like printing something, to display your results:\n\n```text\ntopMovieIDS: org.apache.spark.sql.DataFrame = [movieID: int, count: bigint]\n+-------+-----+\n|movieID|count|\n+-------+-----+\n| 50| 583|\n| 258| 509|\n| 100| 508|\n| 181| 507|\n| 294| 485|\n| 286| 481|\n| 288| 478|\n| 1| 452|\n| 300| 431|\n| 121| 429|\n| 174| 420|\n| 127| 413|\n| 56| 394|\n| 7| 392|\n| 98| 390|\n| 237| 384|\n| 117| 378|\n| 172| 367|\n| 222| 365|\n| 313| 350|\n+-------+-----+\nonly showing top 20 rows\n```\n\nAnd there you have it! Of course, without a key for what the `movieID`s are, this is not incredibly useful, but you should still be proud of your first execution in Spark 2.0!\n\n---", "_____no_output_____" ], [ "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n\n# Page 7 - Using Spark SQL<a class=\"anchor\" id=\"DS107L5_page_7\"></a>\n\n[Back to Top](#DS107L5_toc)\n\n<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n", "_____no_output_____" ], [ "# Using Spark SQL\n\nInstead of using SQL through Pig or Hive, you could also use SQL through Spark! In a lovely, in-line interface like Zeppelin! Keep reading to get in on the fun.\n\n---\n\n## Create a Temporary Table\n\nFirst, you need to create a temporary table from the data frame you had created on the last page, using the function `registerTempTable`. You'll give this new table a name called `MovieRatings`.\n\n```scala\nDFtable.registerTempTable(\"MovieRatings\")\n```\n\n---\n\n## Run SQL Queries\n\nThen you're all set to run SQL queries! \n\n---\n\n### Show the First Ten Movies\n\nThese can be as simple as just showing the first ten movie ratings:\n\n```sql\n%sql\n\nselect * from MovieRatings limit 10\n```\n\nIn order to use Spark SQL, you'll need to include the `%sql` in your notebook, so that Zeppelin knows what type of code it is! And here is the result:\n\n\n\n<div class=\"panel panel-info\">\n <div class=\"panel-heading\">\n <h3 class=\"panel-title\">Tip!</h3>\n </div>\n <div class=\"panel-body\">\n <p>In Spark SQL, the only thing that differs is that you DON'T end your lines with a semi-colon! It won't run if you do.</p>\n </div>\n</div>\n\n---\n\n### Show the Frequency of Ratings\n\nNow, try and step up the complexity a notch. How about using the `count` function to get the frequency of each rating type? Ratings range from 1-5. \n\n```sql\n%sql\n\nselect rating, count(*) as count from MovieRatings group by rating\n```\n\nAnd here is that result:\n\n\n\n---\n\n## Visualize your Data\n\nIf your mind isn't blown already, get ready to hang on to something! Because Zeppelin in conjunction with Spark 2.0 SQL can automatically visualize your results! You just need to press a button! \n\n\n\nThe buttons from left to right show the following:\n\n* Table\n* Bar graph (like above)\n* Pie chart\n* Area graph\n* Line plot\n* Scatter plot\n\nYou can play with them here, but with frequencies and a category, bar chart is definitely the appropriate visual for this data.\n\n---\n\n## Find the Most Popular Movie\n\nWhat if you wanted to join some data, so you can actually find out the name of the most popular movie? Well, you can bring in data from the **[u.item]()** file as well, which contains movie IDs and titles, and merge it with your current data!\n\nThe first step is to read in that file:\n\n```scala\nfinal case class Movie(movieID: Int, title: String)\n\nval lines = sc.textFile(\"hdfs:///user/maria_dev/u.item\").map(x => {val fields = x.split('|'); Movie(fields(0).toInt, fields(1))})\n\nimport sqlContext.implicits._\nval moviesDF = lines.toDF()\n\nmoviesDF.show()\n```\n\nYou should get something like this:\n\n```text\nines: org.apache.spark.rdd.RDD[Movie] = MapPartitionsRDD[7] at map at <console>:34\nimport sqlContext.implicits._\nmoviesDF: org.apache.spark.sql.DataFrame = [movieID: int, title: string]\n+-------+--------------------+\n|movieID| title|\n+-------+--------------------+\n| 1| Toy Story (1995)|\n| 2| GoldenEye (1995)|\n| 3| Four Rooms (1995)|\n| 4| Get Shorty (1995)|\n| 5| Copycat (1995)|\n| 6|Shanghai Triad (Y...|\n| 7|Twelve Monkeys (1...|\n| 8| Babe (1995)|\n| 9|Dead Man Walking ...|\n| 10| Richard III (1995)|\n| 11|Seven (Se7en) (1995)|\n| 12|Usual Suspects, T...|\n| 13|Mighty Aphrodite ...|\n| 14| Postino, Il (1994)|\n| 15|Mr. Holland's Opu...|\n| 16|French Twist (Gaz...|\n| 17|From Dusk Till Da...|\n| 18|White Balloon, Th...|\n| 19|Antonia's Line (1...|\n| 20|Angels and Insect...|\n+-------+--------------------+\nonly showing top 20 rows\n```\n\nThen the next step is to create a temporary table:\n\n```scala\nmoviesDF.registerTempTable(\"MovieTitles\")\n```\n\nAnd then lastly, you can do your SQL query:\n\n```sql\n%sql \n\nselect t.title, count(*) count from MovieRatings r join MovieTitles t on r.movieID = t.movieID group by t.title order by count desc limit 20\n```\n\nYou will give the table `MovieRatings` an alias of `r` and the `MovieTitles` table an alias of `t` to make this a little easier to join. Then you'll count the ratings, group by the title, and order by the count. Results should look like this:\n\n\n\nNote that you can't see all 20 results, but that there is a scroll bar on the right that can help.\n\n---", "_____no_output_____" ], [ "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n\n# Page 8 - Spark Shell<a class=\"anchor\" id=\"DS107L5_page_8\"></a>\n\n[Back to Top](#DS107L5_toc)\n\n<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n", "_____no_output_____" ], [ "# Spark Shell\n\nNext, you will move into using the Spark MLLib, and for best results, this must be done in the Spark Shell and in Scala. The next several pages contain directions for how run decision trees in Spark MLLib, using Scala. Get your swagger on, because this officially makes you cool! Or geeky. Do you find the line is so fine?\n\n---\n\n## Specify the Spark Version\n\nYour Hadoop Cluster comes with both versions of Spark, 1.0 and 2.0, so you will need to specify which version you want to use. If you don't, it will run 1.0 by default, which won't be any help to you, since Spark MLLib is contained within Spark 2.0. \n\n```bash\nexport SPARK_MAJOR_VERSION=2\n```\n\nNothing should happen when you run this code, so if you get a clean line, you are good to go.\n\n<div class=\"panel panel-danger\">\n <div class=\"panel-heading\">\n <h3 class=\"panel-title\">Caution!</h3>\n </div>\n <div class=\"panel-body\">\n <p>You will need to run the export line every time you run the shell - it is not a permanent setting that sticks around.</p>\n </div>\n</div>\n\n---\n\n## Start Spark Shell Locally\n\nThen you can open up the Spark Shell, using ths command. This has you opening Spark on your local machine, and not through your Hadoop cluster, because you don't actually have a real cluster with multiple nodes here.\n\n```bash\nspark-shell --master local[*]\n```\n\nThis may take a little while - so don't be alarmed if you have enough time to grab a cup o' tea!\n\n---\n\n### Start Spark through YARN\n\nIf you were using this in a real big data situation, in which you had multiple nodes, you would use a command like this, which has you open Spark through YARN:\n\n```bash\nspark-shell --master yarn --deploy-mode client\n```\n\nNow that you are in the Spark Shell, there are all sorts of things you can do to interact with Spark. You will know you are in and ready to roll when you see the `scala>` prompt.\n\n---\n\n## Exiting Spark Shell\n\nTo exit the Spark Shell, use `Ctrl + C`. \n\n---", "_____no_output_____" ], [ "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n\n# Page 9 - Decision Trees in Spark MLLib<a class=\"anchor\" id=\"DS107L5_page_9\"></a>\n\n[Back to Top](#DS107L5_toc)\n\n<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n", "_____no_output_____" ], [ "# Decision Trees in Spark MLLib\n\nNow that you're into Spark Shell, you will need to do a fair amount of data wrangling and prep work before you can actually launch into your decision tree model. You'll need to read in your data, change the outcome variable data type, split your data up into testing and training data sets, and create a feature vector which contains all of your predictor variables.\n\n---\n\n## Read in Data\n\nFirst, you will need to read in your data. Spark 2.0 allows you to easily read-in CSVs, with options to bring with it the schema, or structure, of the data, and the headers. Brilliant! You'll be using **[a dataset](https://repo.exeterlms.com/documents/V2/DataScience/Big-Data/glass1.zip)** that will allow you to predict what kind of glass you have based on the component elements in it. \n\nThe `Type` variable is the type of glass, and the options are:\n\n* 1: Building Windows Float Processed\n* 2: Building Windows Non-Float Processed\n* 3: Vehicle Windows Float Processed\n* 4: Vehicle Windows Non-Float Processed\n* 5: Containers\n* 6: Tableware\n* 7: Headlamps\n\nFor those of you who care, float processed glass is made by floating molten glass along on a bed of molten metal. Hot stuff! \n\nMake sure you add this dataset to your `Files` view in Ambari in the `user/maria_dev` folder, so that you can use the code below to read in your data.\n\n```scala\nval data = spark.read.\noption(\"inferSchema\", true).\noption(\"header\", true).\ncsv(\"hdfs:///user/maria_dev/glass1.csv\")\n```\n\nThe code above tells Spark to pull in the structure of your data with the `inferSchema` option, and that your data has headers (`header` option). You'll also use the argument `csv` because your data is a CSV file.\n\nIf this works for you, Scala should spit out some basic information about your structure:\n\n```text\ndata: org.apache.spark.sql.DataFrame = [RI: double, Na: double ... 8 more fields]\n```\n\n---\n\n## Convert Outcome Variable to Double\n\nWhen you actually get to running your decision trees, all of the variables must be doubles. So, you'll need to convert any that aren't. You can do that by *casting* the variable to `double`. \n\n```scala\nval data1 = data.\nwithColumn(\"Type\", $\"Type\".cast(\"double\"))\n```\n\n---\n\n## Train Test Split\n\nThen, you need to split your data into training and testing data. In this case, you are keeping 90% of the data for training, and 10% for testing. Of the 90% of the training data, you will actually later be reserving 10% for additional testing, so if the high percentage of training data surprised you, it's actually really an 80-20 split rather than 90-10; it just doesn't look like it here.\n\n```scala\nval Array(trainData, testData) = data1.randomSplit(Array(0.9, 0.1))\ntrainData.cache()\ntestData.cache()\n```\n\nIf that has worked, Scala will echo back the fields for the training and the testing data:\n\n```text\nres0: trainData.type = [RI: double, Na: double ... 8 more fields]\nres1: testData.type = [RI: double, Na: double ... 8 more fields]\n```\n\n---\n\n## Create a Feature Vector\n\nNext, you will prep your data for machine learning in Spark MLLib. When you feed in data, it does not allow more than one column, so you will need to arrange all your data into only one column, which has a value of vector. Luckily, there is a function for this: `VectorAssembler`. \n\nIn the second line of the code below, you will state that you want to utilize all columns except for `Type`, which is what you are going to predict - the type of glass. The `_!=` is what specifies the exception. Then, in line 3, you will make use of the `VectorAssembler()` function to put the rest of the columns altogether in one vector. You'll then actually run this on your `trainData`, and then `show()` it, so you know it worked. \n\n```scala\nimport org.apache.spark.ml.feature.VectorAssembler\nval inputCols = trainData.columns.filter(_ != \"Type\")\nval assembler = new VectorAssembler().\nsetInputCols(inputCols).\nsetOutputCol(\"featureVector\")\nval assembledTrainData = assembler.transform(trainData)\nassembledTrainData.select(\"featureVector\").show(truncate = false)\n```\n\nYou should get output looking like this back, showing your vector:\n\n```text\n19/11/15 04:09:05 WARN Executor: 1 block locks were not released by TID = 4:\n[rdd_9_0]\n+--------------------------------------------------+\n|featureVector |\n+--------------------------------------------------+\n|[1.51115,17.38,0.0,0.34,75.41,0.0,6.65,0.0,0.0] |\n|[1.51131,13.69,3.2,1.81,72.81,1.76,5.43,1.19,0.0] |\n|[1.51215,12.99,3.47,1.12,72.98,0.62,8.35,0.0,0.31]|\n|[1.51299,14.4,1.74,1.54,74.55,0.0,7.59,0.0,0.0] |\n|[1.51316,13.02,0.0,3.04,70.48,6.21,6.96,0.0,0.0] |\n|[1.51321,13.0,0.0,3.02,70.7,6.21,6.93,0.0,0.0] |\n|[1.51409,14.25,3.09,2.08,72.28,1.1,7.08,0.0,0.0] |\n|[1.51508,15.15,0.0,2.25,73.5,0.0,8.34,0.63,0.0] |\n|[1.51514,14.01,2.68,3.5,69.89,1.68,5.87,2.2,0.0] |\n|[1.51514,14.85,0.0,2.42,73.72,0.0,8.39,0.56,0.0] |\n|[1.51531,14.38,0.0,2.66,73.1,0.04,9.08,0.64,0.0] |\n|[1.51545,14.14,0.0,2.68,73.39,0.08,9.07,0.61,0.05]|\n|[1.51556,13.87,0.0,2.54,73.23,0.14,9.41,0.81,0.01]|\n|[1.51567,13.29,3.45,1.21,72.74,0.56,8.57,0.0,0.0] |\n|[1.51569,13.24,3.49,1.47,73.25,0.38,8.03,0.0,0.0] |\n|[1.51571,12.72,3.46,1.56,73.2,0.67,8.09,0.0,0.24] |\n|[1.51574,14.86,3.67,1.74,71.87,0.16,7.36,0.0,0.12]|\n|[1.5159,12.82,3.52,1.9,72.86,0.69,7.97,0.0,0.0] |\n|[1.5159,13.24,3.34,1.47,73.1,0.39,8.22,0.0,0.0] |\n|[1.51593,13.09,3.59,1.52,73.1,0.67,7.83,0.0,0.0] |\n+--------------------------------------------------+\nonly showing top 20 rows\n```\n\n---", "_____no_output_____" ], [ "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n\n# Page 10 - Decision Trees and Accuracy<a class=\"anchor\" id=\"DS107L5_page_10\"></a>\n\n[Back to Top](#DS107L5_toc)\n\n<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">", "_____no_output_____" ], [ "# Decision Trees and Accuracy\n\nNow that you've done all the prep work, it's time to actually run your decision tree and see how accurate it is! A decision tree is a type of machine learning model in which the computer finds the best way to differentiate between outcomes.\n\n---\n\n## Decision Tree Classifier\n\nIt's time to actually run the decision tree classifier! You'll save it in a `val` named `model`, and if you print those lines out (`println`), you can see the different branches of the decision tree.\n\n\n```scala\nimport org.apache.spark.ml.classification.DecisionTreeClassifier\nimport scala.util.Random\nval classifier = new DecisionTreeClassifier().\nsetSeed(Random.nextLong()).\nsetLabelCol(\"Type\").\nsetFeaturesCol(\"featureVector\").\nsetPredictionCol(\"prediction\")\nval model = classifier.fit(assembledTrainData)\nprintln(model.toDebugString)\n```\n\nHere are the branching results, meaning all the steps that the algorithm took to separate out the different types of glass:\n\n```text\nDecisionTreeClassificationModel (uid=dtc_5e57af65a40f) of depth 5 with 37 nodes\n If (feature 7 <= 0.27)\n If (feature 3 <= 1.38)\n If (feature 2 <= 3.25)\n If (feature 0 <= 1.5202)\n If (feature 1 <= 13.78)\n Predict: 2.0\n Else (feature 1 > 13.78)\n Predict: 6.0\n Else (feature 0 > 1.5202)\n Predict: 2.0\n Else (feature 2 > 3.25)\n If (feature 0 <= 1.5167)\n If (feature 0 <= 1.51567)\n Predict: 1.0\n Else (feature 0 > 1.51567)\n Predict: 3.0\n Else (feature 0 > 1.5167)\n If (feature 2 <= 3.61)\n Predict: 1.0\n Else (feature 2 > 3.61)\n Predict: 1.0\n Else (feature 3 > 1.38)\n If (feature 2 <= 1.88)\n If (feature 1 <= 13.44)\n If (feature 0 <= 1.52172)\n Predict: 5.0\n Else (feature 0 > 1.52172)\n Predict: 2.0\n Else (feature 1 > 13.44)\n If (feature 0 <= 1.519)\n Predict: 6.0\n Else (feature 0 > 1.519)\n Predict: 2.0\n Else (feature 2 > 1.88)\n If (feature 5 <= 0.0)\n Predict: 6.0\n Else (feature 5 > 0.0)\n If (feature 6 <= 8.31)\n Predict: 2.0\n Else (feature 6 > 8.31)\n Predict: 2.0\n Else (feature 7 > 0.27)\n If (feature 1 <= 14.01)\n If (feature 4 <= 71.76)\n If (feature 0 <= 1.51567)\n Predict: 5.0\n Else (feature 0 > 1.51567)\n If (feature 0 <= 1.5202)\n Predict: 1.0\n Else (feature 0 > 1.5202)\n Predict: 2.0\n Else (feature 4 > 71.76)\n Predict: 7.0\n Else (feature 1 > 14.01)\n Predict: 7.0\n```\n\nYou'll notice that the features are just numbered, which makes this a little difficult to interpret, but since you have neither fed it a codebook nor could use one in a decision tree, since they all have to be doubles, this makes sense.\n\n---\n\n## Assess the Importance of Features\n\nNext, you can use the `model` you created to assess the importance of the features, or variables, in your decision tree. You'll use the function `featureImportances` to do so, and then can sort them in reverse order and print, so you get the most important feature first on your list!\n\n```scala\nmodel.featureImportances.toArray.zip(inputCols).\nsorted.reverse.foreach(println)\n```\n\nHere are the results:\n\n```text\n(0.2694959533428122,Mg)\n(0.22949708599977559,Ba)\n(0.17868395220045094,Al)\n(0.1575592774341163,RI)\n(0.08972321273293513,Na)\n(0.03538920228307928,K)\n(0.022147581913725102,Ca)\n(0.0175037340931054,Si)\n(0.0,Fe)\n```\n\nThe higher the number, the better, which is why they have been printed in reverse order. The weight is printed first for the feature, and then the feature name. So, you can see up above that the most important feature is whether Magnesium (Mg) is present in the glass, followed by whether Barium (Ba) is present in the glass, etc. The least important feature is Iron (Fe). \n\n---\n\n## See the Accuracy of the Training Data\n\nNow you can start investigating how well your model is doing. The first thing to do is to examine the training data, and see if the actual glass `Type` matches the `prediction` that the decision tree made:\n\n```scala\nval predictions = model.transform(assembledTrainData)\npredictions.select(\"Type\", \"prediction\", \"probability\").\nshow(truncate = false)\n```\n\nHere are the results from the first 20 rows:\n\n```text\n19/11/15 06:53:07 WARN Executor: 1 block locks were not released by TID = 24:\n[rdd_24_0]\n+----+----------+-------------------------------------------------------------------------------+\n|Type|prediction|probability |\n+----+----------+-------------------------------------------------------------------------------+\n|6.0 |6.0 |[0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0] |\n|1.0 |1.0 |[0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0] |\n|6.0 |6.0 |[0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0] |\n|5.0 |5.0 |[0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0] |\n|5.0 |5.0 |[0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0] |\n|2.0 |2.0 |[0.0,0.08571428571428572,0.9142857142857143,0.0,0.0,0.0,0.0,0.0] |\n|7.0 |7.0 |[0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0] |\n|5.0 |5.0 |[0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0] |\n|7.0 |7.0 |[0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0] |\n|7.0 |7.0 |[0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0] |\n|7.0 |7.0 |[0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0] |\n|1.0 |1.0 |[0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0] |\n|2.0 |2.0 |[0.0,0.08571428571428572,0.9142857142857143,0.0,0.0,0.0,0.0,0.0] |\n|1.0 |2.0 |[0.0,0.08571428571428572,0.9142857142857143,0.0,0.0,0.0,0.0,0.0] |\n|2.0 |2.0 |[0.0,0.08571428571428572,0.9142857142857143,0.0,0.0,0.0,0.0,0.0] |\n|2.0 |2.0 |[0.0,0.14285714285714285,0.5714285714285714,0.2857142857142857,0.0,0.0,0.0,0.0]|\n|2.0 |2.0 |[0.0,0.08571428571428572,0.9142857142857143,0.0,0.0,0.0,0.0,0.0] |\n|2.0 |2.0 |[0.0,0.08571428571428572,0.9142857142857143,0.0,0.0,0.0,0.0,0.0] |\n|2.0 |2.0 |[0.0,0.08571428571428572,0.9142857142857143,0.0,0.0,0.0,0.0,0.0] |\n|2.0 |2.0 |[0.0,0.08571428571428572,0.9142857142857143,0.0,0.0,0.0,0.0,0.0] |\n+----+----------+-------------------------------------------------------------------------------+\nonly showing top 20 rows\n```\n\nThe `Type` column is the actual data, and the `prediction` column is what the decision tree predicted based on the model. The `probability` column shows the likelihood that each `Type` is correct. So you can read the first row as: \n\n```text\nIndex - ignore\n0% chance that the glass type is 1\n0% chance that the glass type is 2\n0% chance that the glass type is 3\n0% chance that the glass type is 4\n0% chance that the glass type is 5\n100% chance that the glass type is 6\n0% chance that the glass type is 7\n```\n\nYou'll notice that there are actually eight numbers, not seven, even though there are only seven glass types. This is because the first probability value is just the zero index, and it will always show a probability of zero.\n\nLooking at just the first 20 rows, it looks like you have created a decently accurate decision tree, but you'll also want to take a look at the accuracy values as well. \n\n---\n\n## Print Total Model Accuracy Values\n\nJust looking at the first twenty rows is a good eyeball check, but doesn't give you the total accuracy for the model. Good thing the function `MulticlassClassificationEvaluator` has your back! \n\n```scala\nimport org.apache.spark.ml.evaluation.MulticlassClassificationEvaluator\nval evaluator = new MulticlassClassificationEvaluator().\nsetLabelCol(\"Type\").\nsetPredictionCol(\"prediction\")\nevaluator.setMetricName(\"accuracy\").evaluate(predictions)\n```\n\nHere is the result:\n\n```text\nres25: Double = 0.8201058201058201\n```\n\nThis shows that the model accurately predicts the glass type 82% of the time. That's not bad...but it could be much higher! \n\n<div class=\"panel panel-info\">\n <div class=\"panel-heading\">\n <h3 class=\"panel-title\">Tip!</h3>\n </div>\n <div class=\"panel-body\">\n <p>Your accuracy value may come out slightly different than what is here, because by default, the decisions in a decision tree are random, and your computer may have done it slightly differently than the instructor's!</p>\n </div>\n</div>\n\n---\n\n## Examine the Classification Matrix\n\nAnother way you can examine accuracy, which will give you a little more detail about what is going well and what isn't, is to look at a confusion matrix. This will compare the predictions to the actual data, so that you can see where the decision tree got it right, and if it didn't, as what type of glass it was misclassified.\n\n```scala\nval confusionMatrix = predictions.\ngroupBy(\"Type\").\npivot(\"prediction\", (1 to 7)).\ncount().\nna.fill(0.0).\norderBy(\"Type\")\nconfusionMatrix.show()\n```\n\nThe output shows the predicted versus actual types. Along the diagonal (54, 56, etc.) you will find the number that was correctly classified. So in reading this matrix, you find that for type 1, 54 pieces of glass were correctly classified as 1s and 8 were incorrectly classified as type 2. You want to see lots of zeros for things not on the diagonal, so at a glance, this it looking pretty decent.\n\n```text\n+----+---+---+---+---+---+---+---+\n|Type| 1| 2| 3| 4| 5| 6| 7|\n+----+---+---+---+---+---+---+---+\n| 1.0| 54| 8| 0| 0| 0| 0| 0|\n| 2.0| 11| 56| 2| 0| 0| 0| 0|\n| 3.0| 6| 4| 6| 0| 0| 0| 0|\n| 5.0| 0| 1| 0| 0| 11| 0| 0|\n| 6.0| 0| 0| 0| 0| 0| 7| 0|\n| 7.0| 1| 1| 0| 0| 0| 0| 21|\n+----+---+---+---+---+---+---+---+\n```\n\n---\n\n## Is Your Accuracy Better than Random?\n\nIt is pretty difficult to benchmark accuracy. Is 82% good? Bad? Ugly? One way to determine at first blush whether your accuracy is any good at all is to find out what the accuracy would be like if you were random guessing. Here's the code to attempt that:\n\n```scala\nimport org.apache.spark.sql.DataFrame\ndef classProbabilities(data: DataFrame): Array[Double] = {\nval total = data.count()\ndata.groupBy(\"Type\").count().\norderBy(\"Type\").\nselect(\"count\").as[Double].\nmap(_ / total).\ncollect()\n}\n\nval trainPriorProbabilities = classProbabilities(trainData)\nval testPriorProbabilities = classProbabilities(testData)\ntrainPriorProbabilities.zip(testPriorProbabilities).map {\ncase (trainProb, cvProb) => trainProb * cvProb\n}.sum\n```\n\nAnd here is the result:\n\n```text\nres33: Double = 0.2452910052910053\n```\n\nLooks like random guessing will give you an accuracy of 25%, so 82% accuracy with your decision tree is looking spectacular now, isn't it?! \n\n---", "_____no_output_____" ], [ "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n\n# Page 11 - Hyperparameter Tuning<a class=\"anchor\" id=\"DS107L5_page_11\"></a>\n\n[Back to Top](#DS107L5_toc)\n\n<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">", "_____no_output_____" ], [ "# Hyperparameter Tuning\n\nThe decision tree was fun, and it was decently accurate. But why stop there? Don't you want to be the best you possibly can? Well, you can probably improve things by playing with the *hyperparameters*. Hyperparameters are the components of the way your model has been created, and by changing them, you can get a better model fit. A decision tree has the following hyperparameters:\n\n* **Maximum depth:** Limits the number of decisions you can make in a decision tree. Sometimes having too many can lead to overfitting of data.\n* **Maximum bins:** Limits the number of decision rules the decision tree can have. A lot will probably make your decision tree more accurate, but could take up too much processing power.\n* **Impurity measure:** *Purity* is how good you are at classifying accurately. If you have two categories, and each group only contains the appropriate data for that category, then you have complete purity. If you have some mix-up in there, then you have *impurity*. You want to have low impurity.\n* **Minimum information gain:** If you include a decision rule that does not make the data more pure, then what good is it? Including a hyperparameter of minimum information gain allows you to only keep levels that will actually add to the accuracy of your data, and it can help ensure you don't overfit the model.\n\n\n---\n\n## Create a Pipeline for Hyperparameter Tuning\n\nNow that you know what the hyperparameters are for decision trees, you can start playing with them! The code below will create a *pipeline* for your decision tree data, and then the next set of code after that will be for trying all different varieties of these hyperparameters, to see which fits the best. A pipeline is when you chain two operations together, so that you don't need to keep running them individually over and over again. Using something like this can take some time and processing power on the computer's end, but will save you the trouble of having to tune everything manually, one at a time, which would take forever!\n\n```scala\nimport org.apache.spark.ml.Pipeline\nval inputCols = trainData.columns.filter(_ != \"Type\")\nval assembler = new VectorAssembler().\nsetInputCols(inputCols).\nsetOutputCol(\"featureVector\")\nval classifier = new DecisionTreeClassifier().\nsetSeed(Random.nextLong()).\nsetLabelCol(\"Type\").\nsetFeaturesCol(\"featureVector\").\nsetPredictionCol(\"prediction\")\nval pipeline = new Pipeline().setStages(Array(assembler, classifier))\n```\n\n---\n\n## Set the Hyperparameter Boundaries and How to Determine Which is Best\n\nNext, you will set the hyperparameter boundaries for impurity, maximum depth, maximum bins, and minimum information gain. For `impurity`, you will try two different versions of impurity: `gini` and `entropy`. For `maxDepth`, you will try the values of 1 and 20. For `maxBins`, you will try all the values of 40 and 300, and for `minInfoGain`, you will try all the values of 0 and .05. All in all, you will be testing 16 models, since you have two values for each hyperparameter. Then, you'll get the accuracy for each of them!\n\n```scala\nimport org.apache.spark.ml.tuning.ParamGridBuilder\nval paramGrid = new ParamGridBuilder().\naddGrid(classifier.impurity, Seq(\"gini\", \"entropy\")).\naddGrid(classifier.maxDepth, Seq(1, 20)).\naddGrid(classifier.maxBins, Seq(40, 300)).\naddGrid(classifier.minInfoGain, Seq(0.0, 0.05)).\nbuild()\nval multiclassEval = new MulticlassClassificationEvaluator().\nsetLabelCol(\"Type\").\nsetPredictionCol(\"prediction\").\nsetMetricName(\"accuracy\")\n```\n\nThe output you will receive back just basically acknowledges your model creation. \n\n---\n\n## Train Test Split for Hyperparameter Tuning\n\nNow that you know what all you want to run, and have it saved as `multiclassEval`, you can run train test split again, so that you have a little bit of data in reserve to test the hyperparameter tuning. This ensures that you don't accidentally overfit your hyperparameters as well.\n\n```scala\nimport org.apache.spark.ml.tuning.TrainValidationSplit\nval validator = new TrainValidationSplit().\nsetSeed(Random.nextLong()).\nsetEstimator(pipeline).\nsetEvaluator(multiclassEval).\nsetEstimatorParamMaps(paramGrid).\nsetTrainRatio(0.9)\nval validatorModel = validator.fit(trainData)\n```\n\n<div class=\"panel panel-info\">\n <div class=\"panel-heading\">\n <h3 class=\"panel-title\">Tip!</h3>\n </div>\n <div class=\"panel-body\">\n <p>Running this may take a while, depending on your computing power, and you may get many warnings about \"1 block locks were not released by TID =\". Just keep waiting, and know that you'll still get results, even though all those scary warnings show. Remember that you're checking 16 different models for accuracy!</p>\n </div>\n</div>\n\nThe `validatorModel` contains the best fit model, but you'll have to wait to see what it is. The suspense builds...\n\n---", "_____no_output_____" ], [ "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n\n# Page 12 - Best Fit Model<a class=\"anchor\" id=\"DS107L5_page_12\"></a>\n\n[Back to Top](#DS107L5_toc)\n\n<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">", "_____no_output_____" ], [ "# Best Fit Model\n\nThe result of your hyperparameter tuning is the best-fit model for your data. This page will show you what that model is and the accuracy of said model.\n\n---\n\n## Determine the Best Fit Model\n\nNow you can actually extract the best fit model and find out what it is:\n\n```scala\nimport org.apache.spark.ml.PipelineModel\nval bestModel = validatorModel.bestModel\nbestModel.asInstanceOf[PipelineModel].stages.last.extractParamMap\n```\n\nAnd here is the output:\n\n```text\nres34: org.apache.spark.ml.param.ParamMap =\n{\n dtc_0e1e4da37cb7-cacheNodeIds: false,\n dtc_0e1e4da37cb7-checkpointInterval: 10,\n dtc_0e1e4da37cb7-featuresCol: featureVector,\n dtc_0e1e4da37cb7-impurity: gini,\n dtc_0e1e4da37cb7-labelCol: Type,\n dtc_0e1e4da37cb7-maxBins: 300,\n dtc_0e1e4da37cb7-maxDepth: 20,\n dtc_0e1e4da37cb7-maxMemoryInMB: 256,\n dtc_0e1e4da37cb7-minInfoGain: 0.0,\n dtc_0e1e4da37cb7-minInstancesPerNode: 1,\n dtc_0e1e4da37cb7-predictionCol: prediction,\n dtc_0e1e4da37cb7-probabilityCol: probability,\n dtc_0e1e4da37cb7-rawPredictionCol: rawPrediction,\n dtc_0e1e4da37cb7-seed: 8849016365946518463\n}\n```\n\nLooks like you want to use the `gini` method of calculating impurity, want a `maxBins` of 300, a `maxDepth` of 20, and want to use zero `minInfoGain`.\n\n---\n\n## Determine the Accuracy of the Models\n\nBut you want to know what the accuracy is for your best fit model? Too crazy; best go back to bed. Or maybe just run the code below:\n\n```scala\nval validatorModel = validator.fit(trainData)\nval paramsAndMetrics = validatorModel.validationMetrics.\nzip(validatorModel.getEstimatorParamMaps).sortBy(-_._1)\nparamsAndMetrics.foreach { case (metric, params) =>\nprintln(metric)\nprintln(params)\nprintln()\n}\n```\n\n<div class=\"panel panel-info\">\n <div class=\"panel-heading\">\n <h3 class=\"panel-title\">Tip!</h3>\n </div>\n <div class=\"panel-body\">\n <p>This may also take a minute, and you may see some of the same warnings up above. But as the Brits say, keep calm and carry on!</p>\n </div>\n</div>\n\nThe output of the code above gives you the accuracy of the models in descending order, followed by the hyperparameters for that model: \n\n```text\n0.8571428571428571\n{\n dtc_0e1e4da37cb7-impurity: gini,\n dtc_0e1e4da37cb7-maxBins: 300,\n dtc_0e1e4da37cb7-maxDepth: 20,\n dtc_0e1e4da37cb7-minInfoGain: 0.0\n}\n\n0.8571428571428571\n{\n dtc_0e1e4da37cb7-impurity: gini,\n dtc_0e1e4da37cb7-maxBins: 300,\n dtc_0e1e4da37cb7-maxDepth: 20,\n dtc_0e1e4da37cb7-minInfoGain: 0.05\n}\n\n0.7857142857142857\n{\n dtc_0e1e4da37cb7-impurity: entropy,\n dtc_0e1e4da37cb7-maxBins: 40,\n dtc_0e1e4da37cb7-maxDepth: 20,\n dtc_0e1e4da37cb7-minInfoGain: 0.0\n}\n\n0.7857142857142857\n{\n dtc_0e1e4da37cb7-impurity: entropy,\n dtc_0e1e4da37cb7-maxBins: 40,\n dtc_0e1e4da37cb7-maxDepth: 20,\n dtc_0e1e4da37cb7-minInfoGain: 0.05\n}\n\n0.7142857142857143\n{\n dtc_0e1e4da37cb7-impurity: gini,\n dtc_0e1e4da37cb7-maxBins: 40,\n dtc_0e1e4da37cb7-maxDepth: 1,\n dtc_0e1e4da37cb7-minInfoGain: 0.0\n}\n\n0.7142857142857143\n{\n dtc_0e1e4da37cb7-impurity: gini,\n dtc_0e1e4da37cb7-maxBins: 40,\n dtc_0e1e4da37cb7-maxDepth: 1,\n dtc_0e1e4da37cb7-minInfoGain: 0.05\n}\n\n0.7142857142857143\n{\n dtc_0e1e4da37cb7-impurity: gini,\n dtc_0e1e4da37cb7-maxBins: 300,\n dtc_0e1e4da37cb7-maxDepth: 1,\n dtc_0e1e4da37cb7-minInfoGain: 0.0\n}\n\n0.7142857142857143\n{\n dtc_0e1e4da37cb7-impurity: gini,\n dtc_0e1e4da37cb7-maxBins: 300,\n dtc_0e1e4da37cb7-maxDepth: 1,\n dtc_0e1e4da37cb7-minInfoGain: 0.05\n}\n\n0.7142857142857143\n{\n dtc_0e1e4da37cb7-impurity: gini,\n dtc_0e1e4da37cb7-maxBins: 40,\n dtc_0e1e4da37cb7-maxDepth: 20,\n dtc_0e1e4da37cb7-minInfoGain: 0.05\n}\n\n0.7142857142857143\n{\n dtc_0e1e4da37cb7-impurity: entropy,\n dtc_0e1e4da37cb7-maxBins: 300,\n dtc_0e1e4da37cb7-maxDepth: 20,\n dtc_0e1e4da37cb7-minInfoGain: 0.0\n}\n\n0.7142857142857143\n{\n dtc_0e1e4da37cb7-impurity: entropy,\n dtc_0e1e4da37cb7-maxBins: 300,\n dtc_0e1e4da37cb7-maxDepth: 20,\n dtc_0e1e4da37cb7-minInfoGain: 0.05\n}\n\n0.6428571428571429\n{\n dtc_0e1e4da37cb7-impurity: gini,\n dtc_0e1e4da37cb7-maxBins: 40,\n dtc_0e1e4da37cb7-maxDepth: 20,\n dtc_0e1e4da37cb7-minInfoGain: 0.0\n}\n\n0.35714285714285715\n{\n dtc_0e1e4da37cb7-impurity: entropy,\n dtc_0e1e4da37cb7-maxBins: 40,\n dtc_0e1e4da37cb7-maxDepth: 1,\n dtc_0e1e4da37cb7-minInfoGain: 0.0\n}\n\n0.35714285714285715\n{\n dtc_0e1e4da37cb7-impurity: entropy,\n dtc_0e1e4da37cb7-maxBins: 40,\n dtc_0e1e4da37cb7-maxDepth: 1,\n dtc_0e1e4da37cb7-minInfoGain: 0.05\n}\n\n0.35714285714285715\n{\n dtc_0e1e4da37cb7-impurity: entropy,\n dtc_0e1e4da37cb7-maxBins: 300,\n dtc_0e1e4da37cb7-maxDepth: 1,\n dtc_0e1e4da37cb7-minInfoGain: 0.0\n}\n\n0.35714285714285715\n{\n dtc_0e1e4da37cb7-impurity: entropy,\n dtc_0e1e4da37cb7-maxBins: 300,\n dtc_0e1e4da37cb7-maxDepth: 1,\n dtc_0e1e4da37cb7-minInfoGain: 0.05\n}\n```\n\nAs noted the first time, the best model is gini/300/20/0, and it yields an accuracy of 87%, which is an improvement upon the original accuracy of 82%. You gained an extra 5% accuracy utilizing your hyperparameters! High five!\n\n---\n\n## Use Testing Data to Evaluate the Model\n\nNow that you've split the data, and trained with it, it's time to test that bad boy out! You know that you're 87% accurate when training, but does that hold up in testing? The first line below is for evaluating the 10% for hyperparameter testing, and the second line below is for evaluating the 10% for testing as a whole.\n\n```scala\nvalidatorModel.validationMetrics.max\nmulticlassEval.evaluate(bestModel.transform(testData))\n```\n\nHere are the hyperparameter tuning results:\n\n```text\nres52: Double = 0.8571428571428571\n```\n\nAnd here are the overall testing results:\n\n```text\nres53: Double = 0.76\n```\n\nSo it looks like tuning those hyperparameters was a good call! A 9% increase in accuracy is good to have! \n\n---", "_____no_output_____" ], [ "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n\n# Page 13 - Key Terms<a class=\"anchor\" id=\"DS107L5_page_13\"></a>\n\n[Back to Top](#DS107L5_toc)\n\n<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">", "_____no_output_____" ], [ "# Key Terms\n\nBelow is a list and short description of the important keywords learned in this lesson. Please read through and go back and review any concepts you do not fully understand. Great Work!\n\n<table class=\"table table-striped\">\n <tr>\n <th>Keyword</th>\n <th>Description</th>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>Spark</td>\n <td>Data processing program built on top of MapReduce.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>Spark Core</td>\n <td>Spark base; also known as Spark 1.0.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>Spark Streaming</td>\n <td>Program to feed in real-time data and receive real-time output.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>Spark SQL</td>\n <td>Use SQL within Spark for a speed boost.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>MLLib</td>\n <td>Machine learning library for Spark.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>GraphX</td>\n <td>Social networking graphs in Spark.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>Apache Zeppelin</td>\n <td>Notebook interface for your Hadoop cluster.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>Resilient Distributed Datasets (RDDs)</td>\n <td>Data stored across your Hadoop cluster.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>DataSets</td>\n <td>Spark 2.0 data storage that allows for efficiency.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>DataFrames</td>\n <td>Spark 2.0 data storage that maintains data structure. For relational data.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>Scala</td>\n <td>Programming language that Spark was built in.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>Hyperparameter</td>\n <td>Components to the way you create your machine learning model.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>Maximum Depth</td>\n <td>The number of decisions you allow your decision tree to make.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>Maximum Bins</td>\n <td>The number of decision rules you allow your decision tree to have.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>Impurity Measure</td>\n <td>When you sort your outcomes with some mix-up.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>Purity</td>\n <td>Having separate groups that only contain the specified category.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>Minimum Information Gain</td>\n <td>Don't include a decision rule that won't make the data more pure.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>Pipeline</td>\n <td>Automatically chaining operations together.</td>\n </tr>\n</table>\n\n---\n\n## Key Scala Code\n\n<table class=\"table table-striped\">\n <tr>\n <th>Keyword</th>\n <th>Description</th>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>val</td>\n <td>A value that cannot be changed once it has been assigned.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>var</td>\n <td>A variable that can be changed after it has been assigned.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>sc</td>\n <td>Spark Context; environment in which you can use Spark.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>.map()</td>\n <td>Provides structure for text files in Spark.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>.toDF()</td>\n <td>Changes data from an RDD to a DataFrame.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>printSchema()</td>\n <td>Prints the structure of your DataFrame.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>.cache()</td>\n <td>Keeps your data in memory so you can access it faster.</td>\n </tr>\n <tr>\n <td style=\"font-weight: bold;\" nowrap>registerTempTable()</td>\n <td>Creates a temporary table that you can use with Spark SQL.</td>\n </tr>\n</table>", "_____no_output_____" ], [ "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n\n# Page 14 - Lesson 5 Practice Hands-On<a class=\"anchor\" id=\"DS107L5_page_14\"></a>\n\n[Back to Top](#DS107L5_toc)\n\n<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">", "_____no_output_____" ], [ "This Hands-On will **not** be graded, but you are encouraged to complete it. The best way to become a great data scientist is to practice. Once you have submitted your project, you will be able to access the solution on the next page. Note that the solution will be slightly different from yours, but should look similar.\n\n<div class=\"panel panel-danger\">\n <div class=\"panel-heading\">\n <h3 class=\"panel-title\">Caution!</h3>\n </div>\n <div class=\"panel-body\">\n <p>Do not submit your project until you have completed all requirements, as you will not be able to resubmit.</p>\n </div>\n</div>\n\n---\n\n## Description\n\nUsing **[this data on boardgame ratings](https://repo.exeterlms.com/documents/V2/DataScience/Big-Data/boardgames3.zip)**, perform a decision tree to predict the average rating of boardgames (`average_rating`). You will need to upload this data file to your HDFS.\n\nPlease copy your Scala code into a text file, and include at the bottom the answer to the following questions:\n\n* What was the best model after hyperparameter tuning? \n* What is the overall accuracy?\n\n---\n\n## Alternative Assignment if You Can't Run Hadoop and/or Ambari\n\nIf your computer refuses to run Hadoop and/or Ambari, **[here](https://repo.exeterlms.com/documents/V2/DataScience/Big-Data/L5exam.zip)** is an alternative exam to test your understanding of the material. Please attach it instead.\n\n<div class=\"panel panel-danger\">\n <div class=\"panel-heading\">\n <h3 class=\"panel-title\">Caution!</h3>\n </div>\n <div class=\"panel-body\">\n <p>Be sure to zip and submit your entire directory when finished!</p>\n </div>\n</div>\n\n\n", "_____no_output_____" ], [ "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n\n# Page 15 - Lesson 5 Practice Hands-On Solution<a class=\"anchor\" id=\"DS107L5_page_15\"></a>\n\n[Back to Top](#DS107L5_toc)\n\n<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">", "_____no_output_____" ], [ "# Lesson 5 Practice Hands-On Solution\n\n---\n\n## Best Model After Hyperparameter Tuning\n\nThe best model after hyperparamter tuning was the one that used entropy, a max of 300 bins, a depth of 20, and .05 of minimum information gain.\n\n---\n\n## Overall Accuracy\n\nThe overall accuracy was 62% with the best hyperparamter model.\n\n---\n\n## Code\n\nBelow you will find all the code to provide the answers above.\n\n---\n\n### Done in the Command Prompt\n\n```bash\nexport SPARK_MAJOR_VERSION=2\n\nspark-shell --master local[*]\n```\n\n---\n\n### Done in Spark Shell\n\n```scala\nval data = spark.read.\noption(\"inferSchema\", true).\noption(\"header\", true).\ncsv(\"hdfs:///user/maria_dev/boardgames3.csv\")\n\ndata.printSchema()\n\nval Array(trainData, testData) = data.randomSplit(Array(0.9, 0.1))\ntrainData.cache()\ntestData.cache()\n\nimport org.apache.spark.ml.feature.VectorAssembler\nval inputCols = trainData.columns.filter(_ != \"average_rating\")\nval assembler = new VectorAssembler().\nsetInputCols(inputCols).\nsetOutputCol(\"featureVector\")\nval assembledTrainData = assembler.transform(trainData)\nassembledTrainData.select(\"featureVector\").show(truncate = false)\n\nimport org.apache.spark.ml.classification.DecisionTreeClassifier\nimport scala.util.Random\nval classifier = new DecisionTreeClassifier().\nsetSeed(Random.nextLong()).\nsetLabelCol(\"average_rating\").\nsetFeaturesCol(\"featureVector\").\nsetPredictionCol(\"prediction\")\nval model = classifier.fit(assembledTrainData)\nprintln(model.toDebugString)\n\nmodel.featureImportances.toArray.zip(inputCols).\nsorted.reverse.foreach(println)\n\n//The best feature for prediction is users_rated.\n\nval predictions = model.transform(assembledTrainData)\npredictions.select(\"average_rating\", \"prediction\", \"probability\").\nshow(truncate = false)\n\n//Eyeball analysis shows that right now it is not predicting very well.\n\nimport org.apache.spark.ml.evaluation.MulticlassClassificationEvaluator\nval evaluator = new MulticlassClassificationEvaluator().\nsetLabelCol(\"average_rating\").\nsetPredictionCol(\"prediction\")\nevaluator.setMetricName(\"accuracy\").evaluate(predictions)\n\n//Right now the model has 57% accuracy.\n\nval confusionMatrix = predictions.\ngroupBy(\"average_rating\").\npivot(\"prediction\", (0 to 10)).\ncount().\nna.fill(0.0).\norderBy(\"average_rating\")\nconfusionMatrix.show()\n\n//Looks like most ratings, both higher and lower, are getting misclassified as 5s, 6s, and 7s. There were no accurate predictions of 1-4 or 8-10.\n\nimport org.apache.spark.sql.DataFrame\ndef classProbabilities(data: DataFrame): Array[Double] = {\nval total = data.count()\ndata.groupBy(\"average_rating\").count().\norderBy(\"average_rating\").\nselect(\"count\").as[Double].\nmap(_ / total).\ncollect()\n}\n\nval trainPriorProbabilities = classProbabilities(trainData)\nval testPriorProbabilities = classProbabilities(testData)\ntrainPriorProbabilities.zip(testPriorProbabilities).map {\ncase (trainProb, cvProb) => trainProb * cvProb\n}.sum\n\n//Random guessing accuracy is 18%, so the current model is better than just guessing. Yay!\n\nimport org.apache.spark.ml.Pipeline\nval inputCols = trainData.columns.filter(_ != \"average_rating\")\nval assembler = new VectorAssembler().\nsetInputCols(inputCols).\nsetOutputCol(\"featureVector\")\nval classifier = new DecisionTreeClassifier().\nsetSeed(Random.nextLong()).\nsetLabelCol(\"average_rating\").\nsetFeaturesCol(\"featureVector\").\nsetPredictionCol(\"prediction\")\nval pipeline = new Pipeline().setStages(Array(assembler, classifier))\n\nimport org.apache.spark.ml.tuning.ParamGridBuilder\nval paramGrid = new ParamGridBuilder().\naddGrid(classifier.impurity, Seq(\"gini\", \"entropy\")).\naddGrid(classifier.maxDepth, Seq(1, 20)).\naddGrid(classifier.maxBins, Seq(40, 300)).\naddGrid(classifier.minInfoGain, Seq(0.0, 0.05)).\nbuild()\nval multiclassEval = new MulticlassClassificationEvaluator().\nsetLabelCol(\"average_rating\").\nsetPredictionCol(\"prediction\").\nsetMetricName(\"accuracy\")\n\nimport org.apache.spark.ml.tuning.TrainValidationSplit\nval validator = new TrainValidationSplit().\nsetSeed(Random.nextLong()).\nsetEstimator(pipeline).\nsetEvaluator(multiclassEval).\nsetEstimatorParamMaps(paramGrid).\nsetTrainRatio(0.9)\nval validatorModel = validator.fit(trainData)\n\nimport org.apache.spark.ml.PipelineModel\nval bestModel = validatorModel.bestModel\nbestModel.asInstanceOf[PipelineModel].stages.last.extractParamMap\n\n//The best model uses entropy, a max of 300 bins, a depth of 20, and .05 of minimum information gain.\n\nval validatorModel = validator.fit(trainData)\nval paramsAndMetrics = validatorModel.validationMetrics.\nzip(validatorModel.getEstimatorParamMaps).sortBy(-_._1)\nparamsAndMetrics.foreach { case (metric, params) =>\nprintln(metric)\nprintln(params)\nprintln()\n}\n\nvalidatorModel.validationMetrics.max\nmulticlassEval.evaluate(bestModel.transform(testData))\n```", "_____no_output_____" ], [ "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n\n# Page 16 - Lesson 5 Practice Hands-On Solution - Alternative Assignment<a class=\"anchor\" id=\"DS107L5_page_16\"></a>\n\n[Back to Top](#DS107L5_toc)\n\n<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">", "_____no_output_____" ], [ "# Lesson 5 Practice Hands-On Solution - Alternative Assignment\n\nThis exam serves as the assessment for those students who cannot utilize the Hadoop system and/or Ambari GUI. Correct answers are show in bold.\n\n1.\tWhich of the Spark components most interests you and why?\n\n **Spark ML seems so powerful! It also seems the most like \"regular\" programming that isn't done with big data, which makes it a little easier.**\n\n2.\tTrue or False? \"Zeppelin is very similar in structure and function to Jupyter Notebook.\"\n **a.\tTrue**\n b.\tFalse\n\n3.\tHow do the three types of Spark data storage differ from each other?\n\n **RDDs are the original way to store data, but they are slow. DataSets are more efficient. DataFrames are meant specially for relational data and hold row and column data.**\n\n4.\tHow do you denote comments in Scala?\n a.\t# \n b.\tChange it to markdown\n **c.\t//**\n d.\t/#\n\n5.\tWhat are the four hyperparameters for decision trees? Give both names and descriptions.\n\n **Maximum Depth: The number of decisions you can make in a tree.**\n\n **Maximum Bins: The number of decision rules you can use in a tree.**\n\n **Impurity Measure: How much mix-up you allow between categories.**\n\n **MInimum Information Gain: Keep only things that add to the accuracy of your data.**", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown" ]

[ [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# 6. Similarity Functions", "_____no_output_____" ], [ "- **Created by Andrés Segura Tinoco**\n- **Created on May 20, 2019**\n- **Updated on Mar 19, 2021**", "_____no_output_____" ], [ "In statistics and related fields, a **similarity measure** or similarity function is a real-valued function that quantifies the similarity between two objects. In short, a similarity function quantifies how much alike two data objects are <a href=\"#link_one\">[1]</a>.", "_____no_output_____" ], [ "## 6.1. Common similarity functions", "_____no_output_____" ] ], [ [ "# Load the Python libraries\nfrom math import *\nfrom decimal import Decimal\nfrom scipy import stats as ss\nimport sklearn.metrics.pairwise as sm\nimport math", "_____no_output_____" ] ], [ [ "\\begin{align}\n similarity(X, Y) = d(X, Y) = \\sqrt{\\sum_{i=1}^n (X_i - Y_i)^2} \\tag{1}\n\\end{align}", "_____no_output_____" ] ], [ [ "# (1) Euclidean distance function\ndef euclidean_distance(x, y):\n return sqrt(sum(pow(a-b,2) for a, b in zip(x, y)))", "_____no_output_____" ] ], [ [ "\\begin{align}\n similarity(X, Y) = d(X, Y) = \\sum_{i=1}^n |X_i - Y_i| \\tag{2}\n\\end{align}", "_____no_output_____" ] ], [ [ "# (2) manhattan distance function\ndef manhattan_distance(x, y):\n return sum(abs(a-b) for a,b in zip(x,y))", "_____no_output_____" ] ], [ [ "\\begin{align}\n similarity(X, Y) = d(X, Y) = (\\sum_{i=1}^n |X_i - Y_i|^p)^\\frac{1}{p} \\tag{3}\n\\end{align}", "_____no_output_____" ] ], [ [ "# (3) Minkowski distance function\ndef _nth_root(value, n_root):\n root_value = 1/float(n_root)\n return round(Decimal(value) ** Decimal(root_value),3)\n\ndef minkowski_distance(x, y, p = 3):\n return float(_nth_root(sum(pow(abs(a-b), p) for a,b in zip(x, y)), p))", "_____no_output_____" ] ], [ [ "\\begin{align}\n similarity(X, Y) = cos(\\theta) = \\frac{\\vec{X}.\\vec{Y}}{\\|\\vec{X}\\|.\\|\\vec{Y}\\|} = \\frac{\\sum_{i=1}^n X_i.Y_i}{\\sqrt{\\sum_{i=1}^n X_i^2}.\\sqrt{\\sum_{i=1}^n Y_i^2}} \\tag{4}\n\\end{align}", "_____no_output_____" ] ], [ [ "# (4) Cosine similarity function\ndef _square_rooted(x):\n return round(sqrt(sum([a*a for a in x])),3)\n\ndef cosine_similarity(x, y):\n numerator = sum(a*b for a,b in zip(x,y))\n denominator = _square_rooted(x) * _square_rooted(y)\n return round(numerator/float(denominator),3)", "_____no_output_____" ] ], [ [ "\\begin{align}\n similarity(X, Y) = \\frac{cov(X, Y)}{\\sigma_X . \\sigma_Y} = \\frac{\\sum_{i=1}^n (X_i - \\bar{X}).(Y_i - \\bar{Y})}{\\sqrt{\\sum_{i=1}^n (X_i - \\bar{X})^2 . (Y_i - \\bar{Y})^2}} \\tag{5}\n\\end{align}", "_____no_output_____" ] ], [ [ "# (5) Pearson similarity function\ndef _avg(x):\n assert len(x) > 0\n return float(sum(x)) / len(x)\n\ndef pearson_similarity(x, y):\n assert len(x) == len(y)\n n = len(x)\n assert n > 0\n avg_x = _avg(x)\n avg_y = _avg(y)\n diffprod = 0\n xdiff2 = 0\n ydiff2 = 0\n for idx in range(n):\n xdiff = x[idx] - avg_x\n ydiff = y[idx] - avg_y\n diffprod += xdiff * ydiff\n xdiff2 += xdiff * xdiff\n ydiff2 += ydiff * ydiff\n\n return diffprod / math.sqrt(xdiff2 * ydiff2)", "_____no_output_____" ] ], [ [ "\\begin{align}\n similarity(X, Y) = J(X, Y) = \\frac{|X \\cap Y|}{|X \\cup Y|} = \\frac{|X \\cap Y|}{|X| + |Y| - |X \\cap Y|} \\tag{6}\n\\end{align}", "_____no_output_____" ] ], [ [ "# (6) Jaccard similarity function\ndef jaccard_similarity(x, y):\n intersection_cardinality = len(set.intersection(*[set(x), set(y)]))\n union_cardinality = len(set.union(*[set(x), set(y)]))\n return intersection_cardinality / float(union_cardinality)", "_____no_output_____" ] ], [ [ "## 6.2. Manual examples", "_____no_output_____" ] ], [ [ "# Vectors\nx = [-4.593481, -5.478033, 1.127111, 1.252885, -2.286953] # Messi\ny = [-4.080334, -3.406618, 4.334073, -0.485612, -2.817897] # CR\nz = [-4.048185, -5.546171, 0.505673, 0.616553, -1.730906] # Neymar", "_____no_output_____" ] ], [ [ "### Euclidean distance", "_____no_output_____" ] ], [ [ "euclidean_distance(x, y)", "_____no_output_____" ], [ "euclidean_distance(x, z)", "_____no_output_____" ] ], [ [ "### Manhattan distance", "_____no_output_____" ] ], [ [ "manhattan_distance(x, y)", "_____no_output_____" ], [ "manhattan_distance(x, z)", "_____no_output_____" ] ], [ [ "### Minkowski distance", "_____no_output_____" ] ], [ [ "minkowski_distance(x, y)", "_____no_output_____" ], [ "minkowski_distance(x, z)", "_____no_output_____" ] ], [ [ "### Cosine similarity", "_____no_output_____" ] ], [ [ "cosine_similarity(x, y)", "_____no_output_____" ], [ "cosine_similarity(x, z)", "_____no_output_____" ] ], [ [ "### Pearson similarity", "_____no_output_____" ] ], [ [ "pearson_similarity(x, y)", "_____no_output_____" ], [ "pearson_similarity(x, z)", "_____no_output_____" ] ], [ [ "### Jaccard similarity", "_____no_output_____" ] ], [ [ "a = [0, 1, 2, 3, 4, 5]\nb = [-1, 1, 2, 0, 3, 5]", "_____no_output_____" ], [ "jaccard_similarity(a, b)", "_____no_output_____" ] ], [ [ "## 6.3. Sklearn examples", "_____no_output_____" ] ], [ [ "corr = sm.euclidean_distances([x], [y])\nfloat(corr[0])", "_____no_output_____" ], [ "corr = sm.manhattan_distances([x], [y])\nfloat(corr[0])", "_____no_output_____" ], [ "corr = sm.cosine_similarity([x], [y])\nfloat(corr[0])", "_____no_output_____" ], [ "corr, p_value = ss.pearsonr(x, y)\ncorr", "_____no_output_____" ] ], [ [ "## Reference", "_____no_output_____" ], [ "<a name='link_one' href='https://en.wikipedia.org/wiki/Similarity_measure' target='_blank' >[1]</a> Wikipedia - Similarity measure. ", "_____no_output_____" ], [ "---\n<a href=\"https://ansegura7.github.io/Algorithms/\">« Home</a>", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown", "markdown", "markdown" ] ]

[ "BSD-2-Clause" ]

[ "BSD-2-Clause" ]

[ "BSD-2-Clause" ]

[ [ [ "import requests, sys, time, os, argparse\n\n# List of simple to collect features\nsnippet_features = [\"title\",\n \"publishedAt\",\n \"channelId\",\n \"channelTitle\",\n \"categoryId\"]\n\n# Any characters to exclude, generally these are things that become problematic in CSV files\nunsafe_characters = ['\\n', '\"']\n\n# Used to identify columns, currently hardcoded order\nheader = [\"video_id\"] + snippet_features + [\"trending_date\", \"tags\", \"view_count\", \"likes\", \"dislikes\",\n \"comment_count\", \"thumbnail_link\", \"comments_disabled\",\n \"ratings_disabled\", \"description\"]\n\n\ndef setup(api_path, code_path):\n with open(api_path, 'r') as file:\n api_key = file.readline()\n\n\n with open(code_path) as file:\n country_codes = [x.rstrip() for x in file]\n\n return api_key, country_codes\n\n\ndef prepare_feature(feature):\n # Removes any character from the unsafe characters list and surrounds the whole item in quotes\n for ch in unsafe_characters:\n feature = str(feature).replace(ch, \"\")\n return f'\"{feature}\"'\n\n\ndef api_request(page_token, country_code):\n # Builds the URL and requests the JSON from it\n request_url = f\"https://www.googleapis.com/youtube/v3/videos?part=id,statistics,snippet{page_token}chart=mostPopular&regionCode={country_code}&maxResults=50&key={api_key}\"\n request = requests.get(request_url)\n if request.status_code == 429:\n print(\"Temp-Banned due to excess requests, please wait and continue later\")\n sys.exit()\n return request.json()\n\n\ndef get_tags(tags_list):\n # Takes a list of tags, prepares each tag and joins them into a string by the pipe character\n return prepare_feature(\"|\".join(tags_list))\n\n\ndef get_videos(items):\n lines = []\n for video in items:\n comments_disabled = False\n ratings_disabled = False\n\n # We can assume something is wrong with the video if it has no statistics, often this means it has been deleted\n # so we can just skip it\n if \"statistics\" not in video:\n continue\n\n # A full explanation of all of these features can be found on the GitHub page for this project\n video_id = prepare_feature(video['id'])\n\n # Snippet and statistics are sub-dicts of video, containing the most useful info\n snippet = video['snippet']\n statistics = video['statistics']\n\n # This list contains all of the features in snippet that are 1 deep and require no special processing\n features = [prepare_feature(snippet.get(feature, \"\")) for feature in snippet_features]\n\n # The following are special case features which require unique processing, or are not within the snippet dict\n description = snippet.get(\"description\", \"\")\n thumbnail_link = snippet.get(\"thumbnails\", dict()).get(\"default\", dict()).get(\"url\", \"\")\n trending_date = time.strftime(\"%y.%d.%m\")\n tags = get_tags(snippet.get(\"tags\", [\"[none]\"]))\n view_count = statistics.get(\"viewCount\", 0)\n\n # This may be unclear, essentially the way the API works is that if a video has comments or ratings disabled\n # then it has no feature for it, thus if they don't exist in the statistics dict we know they are disabled\n if 'likeCount' in statistics and 'dislikeCount' in statistics:\n likes = statistics['likeCount']\n dislikes = statistics['dislikeCount']\n else:\n ratings_disabled = True\n likes = 0\n dislikes = 0\n\n if 'commentCount' in statistics:\n comment_count = statistics['commentCount']\n else:\n comments_disabled = True\n comment_count = 0\n\n # Compiles all of the various bits of info into one consistently formatted line\n line = [video_id] + features + [prepare_feature(x) for x in [trending_date, tags, view_count, likes, dislikes,\n comment_count, thumbnail_link, comments_disabled,\n ratings_disabled, description]]\n lines.append(\",\".join(line))\n return lines\n\n\ndef get_pages(country_code, next_page_token=\"&\"):\n country_data = []\n\n # Because the API uses page tokens (which are literally just the same function of numbers everywhere) it is much\n # more inconvenient to iterate over pages, but that is what is done here.\n while next_page_token is not None:\n # A page of data i.e. a list of videos and all needed data\n video_data_page = api_request(next_page_token, country_code)\n\n # Get the next page token and build a string which can be injected into the request with it, unless it's None,\n # then let the whole thing be None so that the loop ends after this cycle\n next_page_token = video_data_page.get(\"nextPageToken\", None)\n next_page_token = f\"&pageToken={next_page_token}&\" if next_page_token is not None else next_page_token\n\n # Get all of the items as a list and let get_videos return the needed features\n items = video_data_page.get('items', [])\n country_data += get_videos(items)\n\n return country_data\n\n\ndef write_to_file(country_code, country_data):\n\n print(f\"Writing {country_code} data to file...\")\n\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n\n with open(f\"{output_dir}/{time.strftime('%y.%m.%d')}_{country_code}_videos.csv\", \"w+\", encoding='utf-8') as file:\n for row in country_data:\n file.write(f\"{row}\\n\")\n\n\ndef get_data():\n for country_code in country_codes:\n country_data = [\",\".join(header)] + get_pages(country_code)\n write_to_file(country_code, country_data)\n\n\nif __name__ == \"__main__\":\n\n parser = argparse.ArgumentParser()\n parser.add_argument('--key_path', help='Path to the file containing the api key, by default will use api_key.txt in the same directory', default='api_key.txt')\n parser.add_argument('--country_code_path', help='Path to the file containing the list of country codes to scrape, by default will use country_codes.txt in the same directory', default='country_codes.txt')\n parser.add_argument('--output_dir', help='Path to save the outputted files in', default='output/')\n\n args = parser.parse_args()\n\n output_dir = args.output_dir\n api_key, country_codes = setup(args.key_path, args.country_code_path)\n\n get_data()", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "This notebook is part of the `nbsphinx` documentation: https://nbsphinx.readthedocs.io/.", "_____no_output_____" ], [ "# Pre-Executing Notebooks\n\nAutomatically executing notebooks during the Sphinx build process is an important feature of `nbsphinx`.\nHowever, there are a few use cases where pre-executing a notebook and storing the outputs might be preferable.\nStoring any output will, by default, stop ``nbsphinx`` from executing the notebook.", "_____no_output_____" ], [ "## Long-Running Cells\n\nIf you are doing some very time-consuming computations, it might not be feasible to re-execute the notebook every time you build your Sphinx documentation.\n\nSo just do it once -- when you happen to have the time -- and then just keep the output.", "_____no_output_____" ] ], [ [ "import time", "_____no_output_____" ], [ "%time time.sleep(60 * 60)\n6 * 7", "CPU times: user 160 ms, sys: 56 ms, total: 216 ms\nWall time: 1h 1s\n" ] ], [ [ "If you *do* want to execute your notebooks, but some cells run for a long time, you can change the timeout, see [Cell Execution Timeout](timeout.ipynb).", "_____no_output_____" ], [ "## Rare Libraries\n\nYou might have created results with a library that's hard to install and therefore you have only managed to install it on one very old computer in the basement, so you probably cannot run this whenever you build your Sphinx docs.", "_____no_output_____" ] ], [ [ "from a_very_rare_library import calculate_the_answer", "_____no_output_____" ], [ "calculate_the_answer()", "_____no_output_____" ] ], [ [ "## Exceptions\n\nIf an exception is raised during the Sphinx build process, it is stopped (the build process, not the exception!).\nIf you want to show to your audience how an exception looks like, you have two choices:\n\n1. Allow errors -- either generally or on a per-notebook or per-cell basis -- see [Ignoring Errors](allow-errors.ipynb) ([per cell](allow-errors-per-cell.ipynb)).\n\n1. Execute the notebook beforehand and save the results, like it's done in this example notebook:", "_____no_output_____" ] ], [ [ "1 / 0", "_____no_output_____" ] ], [ [ "## Client-specific Outputs\n\nWhen `nbsphinx` executes notebooks,\nit uses the `nbconvert` module to do so.\nCertain Jupyter clients might produce output\nthat differs from what `nbconvert` would produce.\nTo preserve those original outputs,\nthe notebook has to be executed and saved\nbefore running Sphinx.\n\nFor example,\nthe JupyterLab help system shows the help text as cell outputs,\nwhile executing with `nbconvert` doesn't produce any output.", "_____no_output_____" ] ], [ [ "sorted?", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Understanding ROS node APIs in Arduino", "_____no_output_____" ], [ "Following is a basic structure ROS Arduino node. We can see the function of each line of code:", "_____no_output_____" ] ], [ [ "#include <ros.h>\n\nros::NodeHandle nh;\n \nvoid setup()\n{\n nh.initNode();\n}\n\nvoid loop()\n{\n nh.spinOnce();\n}", "_____no_output_____" ] ] ]

[ "markdown", "code" ]

[ [ "markdown", "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import shutil\nimport os", "_____no_output_____" ], [ "FOLDER_1 = \"C:/Users/akash/Desktop/Akash/MSOEML/CheXpert/NIH/Abnormal/AP\"\nFOLDER_2 = \"C:/Users/akash/Desktop/Akash/MSOEML/NIH_data/AP/abnormal\"", "_____no_output_____" ], [ "# move files from folder 1 to folder 2\nfor file in os.listdir(FOLDER_1):\n _ = shutil.move(os.path.join(FOLDER_1, file), FOLDER_2)", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import numpy as np \r\nfrom sklearn.model_selection import train_test_split\r\nfrom tensorflow import keras\r\nfrom keras.models import Sequential\r\nfrom keras.layers import Dense, Embedding, GlobalAveragePooling1D, Dropout\r\nimport matplotlib.pyplot as plt\r\n%matplotlib inline", "_____no_output_____" ], [ "from keras.datasets import imdb\r\n(train_data, train_label), (test_data, test_label) = imdb.load_data(num_words= 10000)", "_____no_output_____" ], [ "train_data.shape, train_label.shape, test_data.shape, test_label.shape", "_____no_output_____" ], [ "list_len = [len(i) for i in train_data]\r\nmax(list_len)", "_____no_output_____" ], [ "from keras.preprocessing.sequence import pad_sequences\r\ntrain_data = pad_sequences(train_data,\r\n value = 0,\r\n padding ='post',\r\n maxlen = 2494)", "_____no_output_____" ], [ "test_data = pad_sequences(test_data,\r\n value = 0,\r\n padding = 'post',\r\n maxlen = 2494)", "_____no_output_____" ], [ "x_train, x_val, y_train, y_val = train_test_split(train_data, train_label, test_size= 0.2, random_state = 4, stratify = train_label )", "_____no_output_____" ], [ "def build_model(units= 64):\r\n model = Sequential()\r\n model.add(Embedding(10000, 16))\r\n model.add(GlobalAveragePooling1D())\r\n model.add(Dense(units, activation = 'relu'))\r\n model.add(Dense(units, activation = 'relu'))\r\n model.add(Dense(1, activation = 'sigmoid'))\r\n return model", "_____no_output_____" ], [ "model = build_model()\r\nmodel.compile(loss = 'binary_crossentropy',\r\n optimizer = 'rmsprop',\r\n metrics = ['accuracy'])\r\nmodel.summary()\r\nhistory = model.fit(x_train, y_train, validation_data = (x_val, y_val), epochs = 50, batch_size = 512)\r\nmodel.evaluate(test_data, test_label)", "_____no_output_____" ], [ "initial_val_loss = history.history['val_loss']\r\nepochs =range(1, len(initial_val_loss)+1)", "_____no_output_____" ], [ "plt.plot(epochs, initial_val_loss, 'bo')\r\nplt.title('validation loss')\r\nplt.xlabel('Epochs')\r\nplt.ylabel('Loss')\r\n\r\nplt.show", "_____no_output_____" ], [ "model = build_model(units = 4)\r\nmodel.compile(loss = 'binary_crossentropy',\r\n optimizer = 'rmsprop',\r\n metrics = ['accuracy'])\r\nmodel.summary()\r\nhistory = model.fit(x_train, y_train, validation_data = (x_val, y_val), epochs = 21, batch_size = 512)\r\nmodel.evaluate(test_data, test_label)", "_____no_output_____" ], [ "val_loss = history.history['val_loss']\r\nepochs =range(1, len(val_loss)+1)", "_____no_output_____" ], [ "plt.plot(epochs, val_loss, 'b')\r\nplt.title('validation loss')\r\nplt.xlabel('Epochs')\r\nplt.ylabel('Loss')\r\nplt.legend()\r\n\r\nplt.show", "No handles with labels found to put in legend.\n" ], [ "from keras.regularizers import l2", "_____no_output_____" ], [ "model = Sequential()\r\nmodel.add(Embedding(10000, 16))\r\nmodel.add(GlobalAveragePooling1D())\r\nmodel.add(Dense(64, kernel_regularizer = l2(0.001), activation = 'relu'))\r\nmodel.add(Dense(64, kernel_regularizer = l2(0.001), activation = 'relu'))\r\nmodel.add(Dense(1, activation = 'sigmoid'))\r\n\r\nmodel.compile(loss = 'binary_crossentropy',\r\n optimizer = 'rmsprop',\r\n metrics = ['accuracy'])\r\n\r\nhistory = model.fit(x_train, y_train, validation_data = (x_val, y_val), epochs = 50, batch_size = 512)\r\nmodel.evaluate(test_data, test_label)", "_____no_output_____" ], [ "val_loss = history.history['val_loss']\r\nepochs =range(1, len(val_loss)+1)\r\n\r\nplt.plot(epochs, val_loss, 'b')\r\nplt.plot(epochs, initial_val_loss, 'b-')\r\nplt.title('validation loss')\r\nplt.xlabel('Epochs')\r\nplt.ylabel('Loss')\r\n\r\n\r\nplt.show", "_____no_output_____" ], [ " model = Sequential()\r\nmodel.add(Embedding(10000, 16))\r\nmodel.add(GlobalAveragePooling1D())\r\nmodel.add(Dense(units, activation = 'relu'))\r\nmodel.add(Dropou(0.5))\r\nmodel.add(Dense(units, activation = 'relu'))\r\nmodel.add(Dropou(0.5))\r\nmodel.add(Dense(1, activation = 'sigmoid'))", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "#Visualization data in a list.", "_____no_output_____" ], [ "import matplotlib.pyplot as plt\nplt.plot([1,2,3,4], [1,4,9,16], 'ro')\nplt.show()", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code" ] ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ [ [ "import torch\nimport torch.optim as optim\nimport torchvision.transforms as transforms\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nimport numpy as np\nimport time\nimport matplotlib\nimport matplotlib.pyplot as plt\n\nimport dataset.dataset as dataset\nimport datasplit.datasplit as datasplit\nimport model.models as models\nimport trainer.trainer as trainer\nimport utils.utils as utils\n\ntorch.cuda.device_count()\n\ncuda0 = torch.device('cuda:0')\ncuda1 = torch.device('cuda:1')\ncuda2 = torch.device('cuda:2')\ncuda3 = torch.device('cuda:3')\n\ndevice = torch.device(cuda0 if torch.cuda.is_available() else \"cpu\")", "_____no_output_____" ] ], [ [ "# INIT", "_____no_output_____" ] ], [ [ "# transforms\ntransform = transforms.Compose([\n transforms.ToTensor(),\n ])\n\n# dataset\nroot = '/Users/Marco/Documents/DATASETS/GUITAR-FX-DIST/Mono_Discrete/Features'\nexcl_folders = ['MT2']\nspectra_folder= 'mel_22050_1024_512'\nproc_settings_csv = 'proc_settings.csv'\nmax_num_settings=3\n\ndataset = dataset.FxDataset(root=root,\n excl_folders=excl_folders, \n spectra_folder=spectra_folder, \n processed_settings_csv=proc_settings_csv,\n max_num_settings=max_num_settings,\n transform=transform)\ndataset.init_dataset()\n# dataset.generate_mel()\n\n# split\nsplit = datasplit.DataSplit(dataset, shuffle=True)\n\n# loaders\ntrain_loader, val_loader, test_loader = split.get_split(batch_size=100)\n\nprint('dataset size: ', len(dataset))\nprint('train set size: ', len(split.train_sampler))\nprint('val set size: ', len(split.val_sampler))\nprint('test set size: ', len(split.test_sampler))\ndataset.fx_to_label", "dataset size: 123552\ntrain set size: 88956\nval set size: 9885\ntest set size: 24711\n" ] ], [ [ "# TRAIN SetNetCond", "_____no_output_____" ] ], [ [ "# model\nsetnetcond = models.SettingsNetCond(n_settings= dataset.max_num_settings,\n mel_shape=dataset.mel_shape, \n num_embeddings=dataset.num_fx, \n embedding_dim=50)\n# optimizer\noptimizer = optim.Adam(setnetcond.parameters(), lr=0.001)\n# loss function\nloss_func = nn.MSELoss(reduction='mean')\n\nprint(setnetcond)", "SettingsNetCond(\n (emb): Embedding(13, 50)\n (fc0): Linear(in_features=50, out_features=11136, bias=True)\n (conv1): Conv2d(2, 6, kernel_size=(5, 5), stride=(1, 1))\n (batchNorm1): BatchNorm2d(6, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n (conv2): Conv2d(6, 12, kernel_size=(5, 5), stride=(1, 1))\n (batchNorm2): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n (fc1): Linear(in_features=6264, out_features=120, bias=True)\n (batchNorm3): BatchNorm1d(120, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n (fc2): Linear(in_features=120, out_features=60, bias=True)\n (batchNorm4): BatchNorm1d(60, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n (out): Linear(in_features=60, out_features=3, bias=True)\n)\n" ], [ "# SAVE\nmodels_folder = '../../models_and_results/models'\nmodel_name = '20210409_setnetcond_mono_disc_best'\nresults_folder = '../../models_and_results/results'\nresults_subfolder = '20210409_setnetcond_mono_disc'", "_____no_output_____" ], [ "# TRAIN and TEST SettingsNetCond OVER MULTIPLE EPOCHS\ntrain_set_size = len(split.train_sampler)\nval_set_size = len(split.val_sampler)\ntest_set_size = len(split.test_sampler)\n\nall_train_losses, all_val_losses, all_test_losses = [],[],[]\nall_train_correct, all_val_correct, all_test_correct = [],[],[]\nall_train_results, all_val_results, all_test_results = [],[],[]\n\nbest_val_correct = 0\nearly_stop_counter = 0\n\nstart = time.time()\n\nfor epoch in range(100):\n train_loss, train_correct, train_results = trainer.train_settings_cond_net(\n model=setnetcond,\n optimizer=optimizer, \n train_loader=train_loader, \n train_sampler=split.train_sampler, \n epoch=epoch,\n loss_function=loss_func, \n device=device\n )\n \n val_loss, val_correct, val_results = trainer.val_settings_cond_net(\n model=setnetcond, \n val_loader=val_loader, \n val_sampler=split.val_sampler,\n loss_function=loss_func, \n device='cpu'\n )\n \n test_loss, test_correct, test_results = trainer.test_settings_cond_net(\n model=setnetcond, \n test_loader=test_loader, \n test_sampler=split.test_sampler,\n loss_function=loss_func, \n device='cpu'\n )\n # save model\n if val_correct > best_val_correct:\n best_val_correct = val_correct\n torch.save(setnetcond, '%s/%s' % (models_folder, model_name))\n early_stop_counter = 0\n print('\\n=== saved best model ===\\n')\n else:\n early_stop_counter += 1\n \n # append results\n all_train_losses.append(train_loss)\n all_val_losses.append(val_loss)\n all_test_losses.append(test_loss)\n \n all_train_correct.append(train_correct)\n all_val_correct.append(val_correct)\n all_test_correct.append(test_correct)\n \n all_train_results.append(train_results)\n all_val_results.append(val_results)\n all_test_results.append(test_results)\n\n if early_stop_counter == 15:\n print('\\n--- early stop ---\\n')\n break\n\nstop = time.time()\nprint(f\"Training time: {stop - start}s\")", "/Users/Marco/Documents/OneDrive - Queen Mary, University of London/PHD/REPOS/venv_repos/lib/python3.8/site-packages/torch/nn/functional.py:1698: UserWarning: nn.functional.tanh is deprecated. Use torch.tanh instead.\n warnings.warn(\"nn.functional.tanh is deprecated. Use torch.tanh instead.\")\nTrain Epoch: 0\t[5000/88956 (6%)]\tTotal Loss: 6.1375\tAvg Loss: 0.0012\nTrain Epoch: 0\t[10000/88956 (11%)]\tTotal Loss: 9.8844\tAvg Loss: 0.0010\nTrain Epoch: 0\t[15000/88956 (17%)]\tTotal Loss: 13.4050\tAvg Loss: 0.0009\nTrain Epoch: 0\t[20000/88956 (22%)]\tTotal Loss: 16.8900\tAvg Loss: 0.0008\nTrain Epoch: 0\t[25000/88956 (28%)]\tTotal Loss: 20.2709\tAvg Loss: 0.0008\nTrain Epoch: 0\t[30000/88956 (34%)]\tTotal Loss: 23.6125\tAvg Loss: 0.0008\nTrain Epoch: 0\t[35000/88956 (39%)]\tTotal Loss: 26.7927\tAvg Loss: 0.0008\nTrain Epoch: 0\t[40000/88956 (45%)]\tTotal Loss: 29.9134\tAvg Loss: 0.0007\nTrain Epoch: 0\t[45000/88956 (51%)]\tTotal Loss: 32.8748\tAvg Loss: 0.0007\nTrain Epoch: 0\t[50000/88956 (56%)]\tTotal Loss: 35.6804\tAvg Loss: 0.0007\nTrain Epoch: 0\t[55000/88956 (62%)]\tTotal Loss: 38.3389\tAvg Loss: 0.0007\nTrain Epoch: 0\t[60000/88956 (67%)]\tTotal Loss: 40.8897\tAvg Loss: 0.0007\nTrain Epoch: 0\t[65000/88956 (73%)]\tTotal Loss: 43.2377\tAvg Loss: 0.0007\nTrain Epoch: 0\t[70000/88956 (79%)]\tTotal Loss: 45.5952\tAvg Loss: 0.0007\nTrain Epoch: 0\t[75000/88956 (84%)]\tTotal Loss: 47.7889\tAvg Loss: 0.0006\nTrain Epoch: 0\t[80000/88956 (90%)]\tTotal Loss: 49.9903\tAvg Loss: 0.0006\nTrain Epoch: 0\t[85000/88956 (96%)]\tTotal Loss: 52.0634\tAvg Loss: 0.0006\n====> Epoch: 0\tTotal Loss: 53.6313\t Avg Loss: 0.0006\tCorrect: 5097/88956\tPercentage Correct: 5.73\n====> Val Loss: 4.4819\t Avg Loss: 0.0005\tCorrect: 1015/9885\tPercentage Correct: 10.27\n====> Test Loss: 11.0885\t Avg Loss: 0.0004\tCorrect: 2741/24711\tPercentage Correct: 11.09\n\n=== saved best model ===\n\nTrain Epoch: 1\t[5000/88956 (6%)]\tTotal Loss: 1.9776\tAvg Loss: 0.0004\nTrain Epoch: 1\t[10000/88956 (11%)]\tTotal Loss: 3.8780\tAvg Loss: 0.0004\nTrain Epoch: 1\t[15000/88956 (17%)]\tTotal Loss: 5.8699\tAvg Loss: 0.0004\nTrain Epoch: 1\t[20000/88956 (22%)]\tTotal Loss: 7.7793\tAvg Loss: 0.0004\nTrain Epoch: 1\t[25000/88956 (28%)]\tTotal Loss: 9.6628\tAvg Loss: 0.0004\nTrain Epoch: 1\t[30000/88956 (34%)]\tTotal Loss: 11.4394\tAvg Loss: 0.0004\nTrain Epoch: 1\t[35000/88956 (39%)]\tTotal Loss: 13.1000\tAvg Loss: 0.0004\nTrain Epoch: 1\t[40000/88956 (45%)]\tTotal Loss: 14.8210\tAvg Loss: 0.0004\nTrain Epoch: 1\t[45000/88956 (51%)]\tTotal Loss: 16.4479\tAvg Loss: 0.0004\nTrain Epoch: 1\t[50000/88956 (56%)]\tTotal Loss: 18.0647\tAvg Loss: 0.0004\nTrain Epoch: 1\t[55000/88956 (62%)]\tTotal Loss: 19.6713\tAvg Loss: 0.0004\nTrain Epoch: 1\t[60000/88956 (67%)]\tTotal Loss: 21.2287\tAvg Loss: 0.0004\nTrain Epoch: 1\t[65000/88956 (73%)]\tTotal Loss: 22.8143\tAvg Loss: 0.0004\nTrain Epoch: 1\t[70000/88956 (79%)]\tTotal Loss: 24.3103\tAvg Loss: 0.0003\nTrain Epoch: 1\t[75000/88956 (84%)]\tTotal Loss: 25.8164\tAvg Loss: 0.0003\nTrain Epoch: 1\t[80000/88956 (90%)]\tTotal Loss: 27.2200\tAvg Loss: 0.0003\nTrain Epoch: 1\t[85000/88956 (96%)]\tTotal Loss: 28.6676\tAvg Loss: 0.0003\n====> Epoch: 1\tTotal Loss: 29.8095\t Avg Loss: 0.0003\tCorrect: 14041/88956\tPercentage Correct: 15.78\n====> Val Loss: 2.7384\t Avg Loss: 0.0003\tCorrect: 1847/9885\tPercentage Correct: 18.68\n====> Test Loss: 6.7626\t Avg Loss: 0.0003\tCorrect: 4788/24711\tPercentage Correct: 19.38\n\n=== saved best model ===\n\nTrain Epoch: 2\t[5000/88956 (6%)]\tTotal Loss: 1.3968\tAvg Loss: 0.0003\nTrain Epoch: 2\t[10000/88956 (11%)]\tTotal Loss: 2.7492\tAvg Loss: 0.0003\nTrain Epoch: 2\t[15000/88956 (17%)]\tTotal Loss: 4.1301\tAvg Loss: 0.0003\nTrain Epoch: 2\t[20000/88956 (22%)]\tTotal Loss: 5.4359\tAvg Loss: 0.0003\nTrain Epoch: 2\t[25000/88956 (28%)]\tTotal Loss: 6.8046\tAvg Loss: 0.0003\nTrain Epoch: 2\t[30000/88956 (34%)]\tTotal Loss: 8.1012\tAvg Loss: 0.0003\nTrain Epoch: 2\t[35000/88956 (39%)]\tTotal Loss: 9.4020\tAvg Loss: 0.0003\nTrain Epoch: 2\t[40000/88956 (45%)]\tTotal Loss: 10.6716\tAvg Loss: 0.0003\nTrain Epoch: 2\t[45000/88956 (51%)]\tTotal Loss: 12.0141\tAvg Loss: 0.0003\nTrain Epoch: 2\t[50000/88956 (56%)]\tTotal Loss: 13.2262\tAvg Loss: 0.0003\nTrain Epoch: 2\t[55000/88956 (62%)]\tTotal Loss: 14.4014\tAvg Loss: 0.0003\nTrain Epoch: 2\t[60000/88956 (67%)]\tTotal Loss: 15.6034\tAvg Loss: 0.0003\nTrain Epoch: 2\t[65000/88956 (73%)]\tTotal Loss: 16.7968\tAvg Loss: 0.0003\nTrain Epoch: 2\t[70000/88956 (79%)]\tTotal Loss: 17.9803\tAvg Loss: 0.0003\nTrain Epoch: 2\t[75000/88956 (84%)]\tTotal Loss: 19.1101\tAvg Loss: 0.0003\nTrain Epoch: 2\t[80000/88956 (90%)]\tTotal Loss: 20.2609\tAvg Loss: 0.0003\nTrain Epoch: 2\t[85000/88956 (96%)]\tTotal Loss: 21.3568\tAvg Loss: 0.0003\n====> Epoch: 2\tTotal Loss: 22.2575\t Avg Loss: 0.0003\tCorrect: 19408/88956\tPercentage Correct: 21.82\n====> Val Loss: 2.1658\t Avg Loss: 0.0002\tCorrect: 2455/9885\tPercentage Correct: 24.84\n====> Test Loss: 5.3747\t Avg Loss: 0.0002\tCorrect: 6091/24711\tPercentage Correct: 24.65\n\n=== saved best model ===\n\nTrain Epoch: 3\t[5000/88956 (6%)]\tTotal Loss: 1.0867\tAvg Loss: 0.0002\nTrain Epoch: 3\t[10000/88956 (11%)]\tTotal Loss: 2.1829\tAvg Loss: 0.0002\nTrain Epoch: 3\t[15000/88956 (17%)]\tTotal Loss: 3.2782\tAvg Loss: 0.0002\nTrain Epoch: 3\t[20000/88956 (22%)]\tTotal Loss: 4.3122\tAvg Loss: 0.0002\nTrain Epoch: 3\t[25000/88956 (28%)]\tTotal Loss: 5.3561\tAvg Loss: 0.0002\nTrain Epoch: 3\t[30000/88956 (34%)]\tTotal Loss: 6.3691\tAvg Loss: 0.0002\nTrain Epoch: 3\t[35000/88956 (39%)]\tTotal Loss: 7.3799\tAvg Loss: 0.0002\nTrain Epoch: 3\t[40000/88956 (45%)]\tTotal Loss: 8.4150\tAvg Loss: 0.0002\nTrain Epoch: 3\t[45000/88956 (51%)]\tTotal Loss: 9.4368\tAvg Loss: 0.0002\nTrain Epoch: 3\t[50000/88956 (56%)]\tTotal Loss: 10.4496\tAvg Loss: 0.0002\nTrain Epoch: 3\t[55000/88956 (62%)]\tTotal Loss: 11.4615\tAvg Loss: 0.0002\nTrain Epoch: 3\t[60000/88956 (67%)]\tTotal Loss: 12.4327\tAvg Loss: 0.0002\nTrain Epoch: 3\t[65000/88956 (73%)]\tTotal Loss: 13.3920\tAvg Loss: 0.0002\nTrain Epoch: 3\t[70000/88956 (79%)]\tTotal Loss: 14.3419\tAvg Loss: 0.0002\nTrain Epoch: 3\t[75000/88956 (84%)]\tTotal Loss: 15.3015\tAvg Loss: 0.0002\nTrain Epoch: 3\t[80000/88956 (90%)]\tTotal Loss: 16.2466\tAvg Loss: 0.0002\nTrain Epoch: 3\t[85000/88956 (96%)]\tTotal Loss: 17.2058\tAvg Loss: 0.0002\n====> Epoch: 3\tTotal Loss: 17.9554\t Avg Loss: 0.0002\tCorrect: 24034/88956\tPercentage Correct: 27.02\n====> Val Loss: 1.8258\t Avg Loss: 0.0002\tCorrect: 2659/9885\tPercentage Correct: 26.90\n====> Test Loss: 4.5769\t Avg Loss: 0.0002\tCorrect: 6656/24711\tPercentage Correct: 26.94\n\n=== saved best model ===\n\nTrain Epoch: 4\t[5000/88956 (6%)]\tTotal Loss: 0.8722\tAvg Loss: 0.0002\nTrain Epoch: 4\t[10000/88956 (11%)]\tTotal Loss: 1.7825\tAvg Loss: 0.0002\nTrain Epoch: 4\t[15000/88956 (17%)]\tTotal Loss: 2.6655\tAvg Loss: 0.0002\nTrain Epoch: 4\t[20000/88956 (22%)]\tTotal Loss: 3.5432\tAvg Loss: 0.0002\nTrain Epoch: 4\t[25000/88956 (28%)]\tTotal Loss: 4.4424\tAvg Loss: 0.0002\nTrain Epoch: 4\t[30000/88956 (34%)]\tTotal Loss: 5.2878\tAvg Loss: 0.0002\nTrain Epoch: 4\t[35000/88956 (39%)]\tTotal Loss: 6.1413\tAvg Loss: 0.0002\nTrain Epoch: 4\t[40000/88956 (45%)]\tTotal Loss: 6.9908\tAvg Loss: 0.0002\nTrain Epoch: 4\t[45000/88956 (51%)]\tTotal Loss: 7.9296\tAvg Loss: 0.0002\nTrain Epoch: 4\t[50000/88956 (56%)]\tTotal Loss: 8.8092\tAvg Loss: 0.0002\nTrain Epoch: 4\t[55000/88956 (62%)]\tTotal Loss: 9.6564\tAvg Loss: 0.0002\nTrain Epoch: 4\t[60000/88956 (67%)]\tTotal Loss: 10.4852\tAvg Loss: 0.0002\nTrain Epoch: 4\t[65000/88956 (73%)]\tTotal Loss: 11.3305\tAvg Loss: 0.0002\nTrain Epoch: 4\t[70000/88956 (79%)]\tTotal Loss: 12.1401\tAvg Loss: 0.0002\nTrain Epoch: 4\t[75000/88956 (84%)]\tTotal Loss: 12.9724\tAvg Loss: 0.0002\nTrain Epoch: 4\t[80000/88956 (90%)]\tTotal Loss: 13.8192\tAvg Loss: 0.0002\nTrain Epoch: 4\t[85000/88956 (96%)]\tTotal Loss: 14.6315\tAvg Loss: 0.0002\n====> Epoch: 4\tTotal Loss: 15.2525\t Avg Loss: 0.0002\tCorrect: 27883/88956\tPercentage Correct: 31.34\n====> Val Loss: 1.5898\t Avg Loss: 0.0002\tCorrect: 3156/9885\tPercentage Correct: 31.93\n====> Test Loss: 3.9769\t Avg Loss: 0.0002\tCorrect: 7842/24711\tPercentage Correct: 31.73\n\n=== saved best model ===\n\nTrain Epoch: 5\t[5000/88956 (6%)]\tTotal Loss: 0.7676\tAvg Loss: 0.0002\nTrain Epoch: 5\t[10000/88956 (11%)]\tTotal Loss: 1.5563\tAvg Loss: 0.0002\nTrain Epoch: 5\t[15000/88956 (17%)]\tTotal Loss: 2.3460\tAvg Loss: 0.0002\nTrain Epoch: 5\t[20000/88956 (22%)]\tTotal Loss: 3.1102\tAvg Loss: 0.0002\nTrain Epoch: 5\t[25000/88956 (28%)]\tTotal Loss: 3.8788\tAvg Loss: 0.0002\nTrain Epoch: 5\t[30000/88956 (34%)]\tTotal Loss: 4.6131\tAvg Loss: 0.0002\nTrain Epoch: 5\t[35000/88956 (39%)]\tTotal Loss: 5.3539\tAvg Loss: 0.0002\nTrain Epoch: 5\t[40000/88956 (45%)]\tTotal Loss: 6.0962\tAvg Loss: 0.0002\nTrain Epoch: 5\t[45000/88956 (51%)]\tTotal Loss: 6.8327\tAvg Loss: 0.0002\nTrain Epoch: 5\t[50000/88956 (56%)]\tTotal Loss: 7.5881\tAvg Loss: 0.0002\nTrain Epoch: 5\t[55000/88956 (62%)]\tTotal Loss: 8.3215\tAvg Loss: 0.0002\nTrain Epoch: 5\t[60000/88956 (67%)]\tTotal Loss: 9.0697\tAvg Loss: 0.0002\nTrain Epoch: 5\t[65000/88956 (73%)]\tTotal Loss: 9.7713\tAvg Loss: 0.0002\nTrain Epoch: 5\t[70000/88956 (79%)]\tTotal Loss: 10.4986\tAvg Loss: 0.0001\nTrain Epoch: 5\t[75000/88956 (84%)]\tTotal Loss: 11.2276\tAvg Loss: 0.0001\nTrain Epoch: 5\t[80000/88956 (90%)]\tTotal Loss: 11.9699\tAvg Loss: 0.0001\nTrain Epoch: 5\t[85000/88956 (96%)]\tTotal Loss: 12.7535\tAvg Loss: 0.0002\n====> Epoch: 5\tTotal Loss: 13.3569\t Avg Loss: 0.0002\tCorrect: 31237/88956\tPercentage Correct: 35.12\n====> Val Loss: 1.4198\t Avg Loss: 0.0001\tCorrect: 3554/9885\tPercentage Correct: 35.95\n====> Test Loss: 3.5379\t Avg Loss: 0.0001\tCorrect: 8611/24711\tPercentage Correct: 34.85\n\n=== saved best model ===\n\nTrain Epoch: 6\t[5000/88956 (6%)]\tTotal Loss: 0.7317\tAvg Loss: 0.0001\nTrain Epoch: 6\t[10000/88956 (11%)]\tTotal Loss: 1.3953\tAvg Loss: 0.0001\nTrain Epoch: 6\t[15000/88956 (17%)]\tTotal Loss: 2.0883\tAvg Loss: 0.0001\nTrain Epoch: 6\t[20000/88956 (22%)]\tTotal Loss: 2.7592\tAvg Loss: 0.0001\nTrain Epoch: 6\t[25000/88956 (28%)]\tTotal Loss: 3.5022\tAvg Loss: 0.0001\nTrain Epoch: 6\t[30000/88956 (34%)]\tTotal Loss: 4.2041\tAvg Loss: 0.0001\nTrain Epoch: 6\t[35000/88956 (39%)]\tTotal Loss: 4.8542\tAvg Loss: 0.0001\nTrain Epoch: 6\t[40000/88956 (45%)]\tTotal Loss: 5.5028\tAvg Loss: 0.0001\nTrain Epoch: 6\t[45000/88956 (51%)]\tTotal Loss: 6.1751\tAvg Loss: 0.0001\nTrain Epoch: 6\t[50000/88956 (56%)]\tTotal Loss: 6.8542\tAvg Loss: 0.0001\nTrain Epoch: 6\t[55000/88956 (62%)]\tTotal Loss: 7.5185\tAvg Loss: 0.0001\nTrain Epoch: 6\t[60000/88956 (67%)]\tTotal Loss: 8.1715\tAvg Loss: 0.0001\nTrain Epoch: 6\t[65000/88956 (73%)]\tTotal Loss: 8.8069\tAvg Loss: 0.0001\nTrain Epoch: 6\t[70000/88956 (79%)]\tTotal Loss: 9.4547\tAvg Loss: 0.0001\nTrain Epoch: 6\t[75000/88956 (84%)]\tTotal Loss: 10.1022\tAvg Loss: 0.0001\nTrain Epoch: 6\t[80000/88956 (90%)]\tTotal Loss: 10.7471\tAvg Loss: 0.0001\nTrain Epoch: 6\t[85000/88956 (96%)]\tTotal Loss: 11.3885\tAvg Loss: 0.0001\n====> Epoch: 6\tTotal Loss: 11.9062\t Avg Loss: 0.0001\tCorrect: 34403/88956\tPercentage Correct: 38.67\n====> Val Loss: 1.2699\t Avg Loss: 0.0001\tCorrect: 3841/9885\tPercentage Correct: 38.86\n====> Test Loss: 3.1077\t Avg Loss: 0.0001\tCorrect: 9647/24711\tPercentage Correct: 39.04\n\n=== saved best model ===\n\nTrain Epoch: 7\t[5000/88956 (6%)]\tTotal Loss: 0.6402\tAvg Loss: 0.0001\nTrain Epoch: 7\t[10000/88956 (11%)]\tTotal Loss: 1.2666\tAvg Loss: 0.0001\nTrain Epoch: 7\t[15000/88956 (17%)]\tTotal Loss: 1.8738\tAvg Loss: 0.0001\nTrain Epoch: 7\t[20000/88956 (22%)]\tTotal Loss: 2.5410\tAvg Loss: 0.0001\nTrain Epoch: 7\t[25000/88956 (28%)]\tTotal Loss: 3.1713\tAvg Loss: 0.0001\nTrain Epoch: 7\t[30000/88956 (34%)]\tTotal Loss: 3.8084\tAvg Loss: 0.0001\nTrain Epoch: 7\t[35000/88956 (39%)]\tTotal Loss: 4.4107\tAvg Loss: 0.0001\nTrain Epoch: 7\t[40000/88956 (45%)]\tTotal Loss: 5.0511\tAvg Loss: 0.0001\nTrain Epoch: 7\t[45000/88956 (51%)]\tTotal Loss: 5.6628\tAvg Loss: 0.0001\nTrain Epoch: 7\t[50000/88956 (56%)]\tTotal Loss: 6.2486\tAvg Loss: 0.0001\nTrain Epoch: 7\t[55000/88956 (62%)]\tTotal Loss: 6.8582\tAvg Loss: 0.0001\nTrain Epoch: 7\t[60000/88956 (67%)]\tTotal Loss: 7.4545\tAvg Loss: 0.0001\nTrain Epoch: 7\t[65000/88956 (73%)]\tTotal Loss: 8.0619\tAvg Loss: 0.0001\nTrain Epoch: 7\t[70000/88956 (79%)]\tTotal Loss: 8.6483\tAvg Loss: 0.0001\nTrain Epoch: 7\t[75000/88956 (84%)]\tTotal Loss: 9.2695\tAvg Loss: 0.0001\nTrain Epoch: 7\t[80000/88956 (90%)]\tTotal Loss: 9.8805\tAvg Loss: 0.0001\nTrain Epoch: 7\t[85000/88956 (96%)]\tTotal Loss: 10.5084\tAvg Loss: 0.0001\n====> Epoch: 7\tTotal Loss: 10.9845\t Avg Loss: 0.0001\tCorrect: 36474/88956\tPercentage Correct: 41.00\n====> Val Loss: 1.3034\t Avg Loss: 0.0001\tCorrect: 3976/9885\tPercentage Correct: 40.22\n====> Test Loss: 3.2811\t Avg Loss: 0.0001\tCorrect: 9985/24711\tPercentage Correct: 40.41\n\n=== saved best model ===\n\nTrain Epoch: 8\t[5000/88956 (6%)]\tTotal Loss: 0.5984\tAvg Loss: 0.0001\nTrain Epoch: 8\t[10000/88956 (11%)]\tTotal Loss: 1.1801\tAvg Loss: 0.0001\nTrain Epoch: 8\t[15000/88956 (17%)]\tTotal Loss: 1.7651\tAvg Loss: 0.0001\nTrain Epoch: 8\t[20000/88956 (22%)]\tTotal Loss: 2.3255\tAvg Loss: 0.0001\nTrain Epoch: 8\t[25000/88956 (28%)]\tTotal Loss: 2.8950\tAvg Loss: 0.0001\nTrain Epoch: 8\t[30000/88956 (34%)]\tTotal Loss: 3.5203\tAvg Loss: 0.0001\nTrain Epoch: 8\t[35000/88956 (39%)]\tTotal Loss: 4.0717\tAvg Loss: 0.0001\nTrain Epoch: 8\t[40000/88956 (45%)]\tTotal Loss: 4.6241\tAvg Loss: 0.0001\nTrain Epoch: 8\t[45000/88956 (51%)]\tTotal Loss: 5.2163\tAvg Loss: 0.0001\nTrain Epoch: 8\t[50000/88956 (56%)]\tTotal Loss: 5.7571\tAvg Loss: 0.0001\nTrain Epoch: 8\t[55000/88956 (62%)]\tTotal Loss: 6.3202\tAvg Loss: 0.0001\nTrain Epoch: 8\t[60000/88956 (67%)]\tTotal Loss: 6.8837\tAvg Loss: 0.0001\nTrain Epoch: 8\t[65000/88956 (73%)]\tTotal Loss: 7.4566\tAvg Loss: 0.0001\nTrain Epoch: 8\t[70000/88956 (79%)]\tTotal Loss: 8.0217\tAvg Loss: 0.0001\nTrain Epoch: 8\t[75000/88956 (84%)]\tTotal Loss: 8.5845\tAvg Loss: 0.0001\nTrain Epoch: 8\t[80000/88956 (90%)]\tTotal Loss: 9.1474\tAvg Loss: 0.0001\nTrain Epoch: 8\t[85000/88956 (96%)]\tTotal Loss: 9.7318\tAvg Loss: 0.0001\n====> Epoch: 8\tTotal Loss: 10.1764\t Avg Loss: 0.0001\tCorrect: 38730/88956\tPercentage Correct: 43.54\n====> Val Loss: 1.1481\t Avg Loss: 0.0001\tCorrect: 4338/9885\tPercentage Correct: 43.88\n====> Test Loss: 2.8417\t Avg Loss: 0.0001\tCorrect: 10821/24711\tPercentage Correct: 43.79\n\n=== saved best model ===\n\nTrain Epoch: 9\t[5000/88956 (6%)]\tTotal Loss: 0.5408\tAvg Loss: 0.0001\nTrain Epoch: 9\t[10000/88956 (11%)]\tTotal Loss: 1.0671\tAvg Loss: 0.0001\nTrain Epoch: 9\t[15000/88956 (17%)]\tTotal Loss: 1.6250\tAvg Loss: 0.0001\nTrain Epoch: 9\t[20000/88956 (22%)]\tTotal Loss: 2.1611\tAvg Loss: 0.0001\nTrain Epoch: 9\t[25000/88956 (28%)]\tTotal Loss: 2.7056\tAvg Loss: 0.0001\nTrain Epoch: 9\t[30000/88956 (34%)]\tTotal Loss: 3.2230\tAvg Loss: 0.0001\nTrain Epoch: 9\t[35000/88956 (39%)]\tTotal Loss: 3.7777\tAvg Loss: 0.0001\nTrain Epoch: 9\t[40000/88956 (45%)]\tTotal Loss: 4.3258\tAvg Loss: 0.0001\nTrain Epoch: 9\t[45000/88956 (51%)]\tTotal Loss: 4.8621\tAvg Loss: 0.0001\nTrain Epoch: 9\t[50000/88956 (56%)]\tTotal Loss: 5.3797\tAvg Loss: 0.0001\nTrain Epoch: 9\t[55000/88956 (62%)]\tTotal Loss: 5.9372\tAvg Loss: 0.0001\nTrain Epoch: 9\t[60000/88956 (67%)]\tTotal Loss: 6.4886\tAvg Loss: 0.0001\nTrain Epoch: 9\t[65000/88956 (73%)]\tTotal Loss: 7.0183\tAvg Loss: 0.0001\nTrain Epoch: 9\t[70000/88956 (79%)]\tTotal Loss: 7.5451\tAvg Loss: 0.0001\nTrain Epoch: 9\t[75000/88956 (84%)]\tTotal Loss: 8.0993\tAvg Loss: 0.0001\nTrain Epoch: 9\t[80000/88956 (90%)]\tTotal Loss: 8.6668\tAvg Loss: 0.0001\nTrain Epoch: 9\t[85000/88956 (96%)]\tTotal Loss: 9.2081\tAvg Loss: 0.0001\n====> Epoch: 9\tTotal Loss: 9.6262\t Avg Loss: 0.0001\tCorrect: 40324/88956\tPercentage Correct: 45.33\n====> Val Loss: 1.1321\t Avg Loss: 0.0001\tCorrect: 4395/9885\tPercentage Correct: 44.46\n====> Test Loss: 2.7960\t Avg Loss: 0.0001\tCorrect: 11090/24711\tPercentage Correct: 44.88\n\n=== saved best model ===\n\nTrain Epoch: 10\t[5000/88956 (6%)]\tTotal Loss: 0.5213\tAvg Loss: 0.0001\nTrain Epoch: 10\t[10000/88956 (11%)]\tTotal Loss: 1.0344\tAvg Loss: 0.0001\nTrain Epoch: 10\t[15000/88956 (17%)]\tTotal Loss: 1.5557\tAvg Loss: 0.0001\nTrain Epoch: 10\t[20000/88956 (22%)]\tTotal Loss: 2.0602\tAvg Loss: 0.0001\nTrain Epoch: 10\t[25000/88956 (28%)]\tTotal Loss: 2.5849\tAvg Loss: 0.0001\nTrain Epoch: 10\t[30000/88956 (34%)]\tTotal Loss: 3.1137\tAvg Loss: 0.0001\nTrain Epoch: 10\t[35000/88956 (39%)]\tTotal Loss: 3.6090\tAvg Loss: 0.0001\nTrain Epoch: 10\t[40000/88956 (45%)]\tTotal Loss: 4.1093\tAvg Loss: 0.0001\nTrain Epoch: 10\t[45000/88956 (51%)]\tTotal Loss: 4.6069\tAvg Loss: 0.0001\nTrain Epoch: 10\t[50000/88956 (56%)]\tTotal Loss: 5.1041\tAvg Loss: 0.0001\nTrain Epoch: 10\t[55000/88956 (62%)]\tTotal Loss: 5.6027\tAvg Loss: 0.0001\nTrain Epoch: 10\t[60000/88956 (67%)]\tTotal Loss: 6.1281\tAvg Loss: 0.0001\nTrain Epoch: 10\t[65000/88956 (73%)]\tTotal Loss: 6.6708\tAvg Loss: 0.0001\nTrain Epoch: 10\t[70000/88956 (79%)]\tTotal Loss: 7.2366\tAvg Loss: 0.0001\nTrain Epoch: 10\t[75000/88956 (84%)]\tTotal Loss: 7.7518\tAvg Loss: 0.0001\nTrain Epoch: 10\t[80000/88956 (90%)]\tTotal Loss: 8.2607\tAvg Loss: 0.0001\nTrain Epoch: 10\t[85000/88956 (96%)]\tTotal Loss: 8.7811\tAvg Loss: 0.0001\n====> Epoch: 10\tTotal Loss: 9.1886\t Avg Loss: 0.0001\tCorrect: 41810/88956\tPercentage Correct: 47.00\n====> Val Loss: 1.0966\t Avg Loss: 0.0001\tCorrect: 4539/9885\tPercentage Correct: 45.92\n====> Test Loss: 2.6882\t Avg Loss: 0.0001\tCorrect: 11491/24711\tPercentage Correct: 46.50\n\n=== saved best model ===\n\nTrain Epoch: 11\t[5000/88956 (6%)]\tTotal Loss: 0.4782\tAvg Loss: 0.0001\nTrain Epoch: 11\t[10000/88956 (11%)]\tTotal Loss: 0.9729\tAvg Loss: 0.0001\nTrain Epoch: 11\t[15000/88956 (17%)]\tTotal Loss: 1.4493\tAvg Loss: 0.0001\nTrain Epoch: 11\t[20000/88956 (22%)]\tTotal Loss: 1.9835\tAvg Loss: 0.0001\nTrain Epoch: 11\t[25000/88956 (28%)]\tTotal Loss: 2.4994\tAvg Loss: 0.0001\nTrain Epoch: 11\t[30000/88956 (34%)]\tTotal Loss: 2.9829\tAvg Loss: 0.0001\nTrain Epoch: 11\t[35000/88956 (39%)]\tTotal Loss: 3.4429\tAvg Loss: 0.0001\nTrain Epoch: 11\t[40000/88956 (45%)]\tTotal Loss: 3.9539\tAvg Loss: 0.0001\nTrain Epoch: 11\t[45000/88956 (51%)]\tTotal Loss: 4.4668\tAvg Loss: 0.0001\nTrain Epoch: 11\t[50000/88956 (56%)]\tTotal Loss: 4.9771\tAvg Loss: 0.0001\nTrain Epoch: 11\t[55000/88956 (62%)]\tTotal Loss: 5.4401\tAvg Loss: 0.0001\nTrain Epoch: 11\t[60000/88956 (67%)]\tTotal Loss: 5.9218\tAvg Loss: 0.0001\nTrain Epoch: 11\t[65000/88956 (73%)]\tTotal Loss: 6.3999\tAvg Loss: 0.0001\nTrain Epoch: 11\t[70000/88956 (79%)]\tTotal Loss: 6.8985\tAvg Loss: 0.0001\nTrain Epoch: 11\t[75000/88956 (84%)]\tTotal Loss: 7.3888\tAvg Loss: 0.0001\nTrain Epoch: 11\t[80000/88956 (90%)]\tTotal Loss: 7.8632\tAvg Loss: 0.0001\nTrain Epoch: 11\t[85000/88956 (96%)]\tTotal Loss: 8.3524\tAvg Loss: 0.0001\n====> Epoch: 11\tTotal Loss: 8.7395\t Avg Loss: 0.0001\tCorrect: 43616/88956\tPercentage Correct: 49.03\n====> Val Loss: 1.0668\t Avg Loss: 0.0001\tCorrect: 4642/9885\tPercentage Correct: 46.96\n====> Test Loss: 2.6093\t Avg Loss: 0.0001\tCorrect: 11571/24711\tPercentage Correct: 46.83\n\n=== saved best model ===\n\nTrain Epoch: 12\t[5000/88956 (6%)]\tTotal Loss: 0.4672\tAvg Loss: 0.0001\nTrain Epoch: 12\t[10000/88956 (11%)]\tTotal Loss: 0.9101\tAvg Loss: 0.0001\nTrain Epoch: 12\t[15000/88956 (17%)]\tTotal Loss: 1.3653\tAvg Loss: 0.0001\nTrain Epoch: 12\t[20000/88956 (22%)]\tTotal Loss: 1.8379\tAvg Loss: 0.0001\nTrain Epoch: 12\t[25000/88956 (28%)]\tTotal Loss: 2.2886\tAvg Loss: 0.0001\nTrain Epoch: 12\t[30000/88956 (34%)]\tTotal Loss: 2.7221\tAvg Loss: 0.0001\nTrain Epoch: 12\t[35000/88956 (39%)]\tTotal Loss: 3.1756\tAvg Loss: 0.0001\nTrain Epoch: 12\t[40000/88956 (45%)]\tTotal Loss: 3.6333\tAvg Loss: 0.0001\nTrain Epoch: 12\t[45000/88956 (51%)]\tTotal Loss: 4.1147\tAvg Loss: 0.0001\nTrain Epoch: 12\t[50000/88956 (56%)]\tTotal Loss: 4.5791\tAvg Loss: 0.0001\nTrain Epoch: 12\t[55000/88956 (62%)]\tTotal Loss: 5.0502\tAvg Loss: 0.0001\nTrain Epoch: 12\t[60000/88956 (67%)]\tTotal Loss: 5.4980\tAvg Loss: 0.0001\nTrain Epoch: 12\t[65000/88956 (73%)]\tTotal Loss: 5.9607\tAvg Loss: 0.0001\nTrain Epoch: 12\t[70000/88956 (79%)]\tTotal Loss: 6.4468\tAvg Loss: 0.0001\nTrain Epoch: 12\t[75000/88956 (84%)]\tTotal Loss: 6.9110\tAvg Loss: 0.0001\nTrain Epoch: 12\t[80000/88956 (90%)]\tTotal Loss: 7.3582\tAvg Loss: 0.0001\nTrain Epoch: 12\t[85000/88956 (96%)]\tTotal Loss: 7.8495\tAvg Loss: 0.0001\n====> Epoch: 12\tTotal Loss: 8.2338\t Avg Loss: 0.0001\tCorrect: 45205/88956\tPercentage Correct: 50.82\n====> Val Loss: 1.0261\t Avg Loss: 0.0001\tCorrect: 4811/9885\tPercentage Correct: 48.67\n====> Test Loss: 2.4850\t Avg Loss: 0.0001\tCorrect: 12177/24711\tPercentage Correct: 49.28\n\n=== saved best model ===\n\nTrain Epoch: 13\t[5000/88956 (6%)]\tTotal Loss: 0.4528\tAvg Loss: 0.0001\nTrain Epoch: 13\t[10000/88956 (11%)]\tTotal Loss: 0.8972\tAvg Loss: 0.0001\nTrain Epoch: 13\t[15000/88956 (17%)]\tTotal Loss: 1.3625\tAvg Loss: 0.0001\nTrain Epoch: 13\t[20000/88956 (22%)]\tTotal Loss: 1.8081\tAvg Loss: 0.0001\nTrain Epoch: 13\t[25000/88956 (28%)]\tTotal Loss: 2.2551\tAvg Loss: 0.0001\nTrain Epoch: 13\t[30000/88956 (34%)]\tTotal Loss: 2.6895\tAvg Loss: 0.0001\nTrain Epoch: 13\t[35000/88956 (39%)]\tTotal Loss: 3.1535\tAvg Loss: 0.0001\nTrain Epoch: 13\t[40000/88956 (45%)]\tTotal Loss: 3.5944\tAvg Loss: 0.0001\nTrain Epoch: 13\t[45000/88956 (51%)]\tTotal Loss: 4.0354\tAvg Loss: 0.0001\nTrain Epoch: 13\t[50000/88956 (56%)]\tTotal Loss: 4.4670\tAvg Loss: 0.0001\nTrain Epoch: 13\t[55000/88956 (62%)]\tTotal Loss: 4.9296\tAvg Loss: 0.0001\nTrain Epoch: 13\t[60000/88956 (67%)]\tTotal Loss: 5.4050\tAvg Loss: 0.0001\nTrain Epoch: 13\t[65000/88956 (73%)]\tTotal Loss: 5.8736\tAvg Loss: 0.0001\nTrain Epoch: 13\t[70000/88956 (79%)]\tTotal Loss: 6.3439\tAvg Loss: 0.0001\nTrain Epoch: 13\t[75000/88956 (84%)]\tTotal Loss: 6.7933\tAvg Loss: 0.0001\nTrain Epoch: 13\t[80000/88956 (90%)]\tTotal Loss: 7.2431\tAvg Loss: 0.0001\nTrain Epoch: 13\t[85000/88956 (96%)]\tTotal Loss: 7.7342\tAvg Loss: 0.0001\n====> Epoch: 13\tTotal Loss: 8.0745\t Avg Loss: 0.0001\tCorrect: 45855/88956\tPercentage Correct: 51.55\n====> Val Loss: 0.9728\t Avg Loss: 0.0001\tCorrect: 5030/9885\tPercentage Correct: 50.89\n====> Test Loss: 2.3779\t Avg Loss: 0.0001\tCorrect: 12726/24711\tPercentage Correct: 51.50\n\n=== saved best model ===\n\nTrain Epoch: 14\t[5000/88956 (6%)]\tTotal Loss: 0.4295\tAvg Loss: 0.0001\nTrain Epoch: 14\t[10000/88956 (11%)]\tTotal Loss: 0.8894\tAvg Loss: 0.0001\nTrain Epoch: 14\t[15000/88956 (17%)]\tTotal Loss: 1.3302\tAvg Loss: 0.0001\nTrain Epoch: 14\t[20000/88956 (22%)]\tTotal Loss: 1.7415\tAvg Loss: 0.0001\nTrain Epoch: 14\t[25000/88956 (28%)]\tTotal Loss: 2.1652\tAvg Loss: 0.0001\nTrain Epoch: 14\t[30000/88956 (34%)]\tTotal Loss: 2.5884\tAvg Loss: 0.0001\nTrain Epoch: 14\t[35000/88956 (39%)]\tTotal Loss: 3.0227\tAvg Loss: 0.0001\nTrain Epoch: 14\t[40000/88956 (45%)]\tTotal Loss: 3.4478\tAvg Loss: 0.0001\nTrain Epoch: 14\t[45000/88956 (51%)]\tTotal Loss: 3.8529\tAvg Loss: 0.0001\nTrain Epoch: 14\t[50000/88956 (56%)]\tTotal Loss: 4.3061\tAvg Loss: 0.0001\nTrain Epoch: 14\t[55000/88956 (62%)]\tTotal Loss: 4.7464\tAvg Loss: 0.0001\nTrain Epoch: 14\t[60000/88956 (67%)]\tTotal Loss: 5.1684\tAvg Loss: 0.0001\nTrain Epoch: 14\t[65000/88956 (73%)]\tTotal Loss: 5.6223\tAvg Loss: 0.0001\nTrain Epoch: 14\t[70000/88956 (79%)]\tTotal Loss: 6.0678\tAvg Loss: 0.0001\nTrain Epoch: 14\t[75000/88956 (84%)]\tTotal Loss: 6.5001\tAvg Loss: 0.0001\nTrain Epoch: 14\t[80000/88956 (90%)]\tTotal Loss: 6.9355\tAvg Loss: 0.0001\nTrain Epoch: 14\t[85000/88956 (96%)]\tTotal Loss: 7.3532\tAvg Loss: 0.0001\n====> Epoch: 14\tTotal Loss: 7.6884\t Avg Loss: 0.0001\tCorrect: 47337/88956\tPercentage Correct: 53.21\n====> Val Loss: 0.9701\t Avg Loss: 0.0001\tCorrect: 4877/9885\tPercentage Correct: 49.34\n====> Test Loss: 2.4333\t Avg Loss: 0.0001\tCorrect: 12402/24711\tPercentage Correct: 50.19\nTrain Epoch: 15\t[5000/88956 (6%)]\tTotal Loss: 0.4267\tAvg Loss: 0.0001\nTrain Epoch: 15\t[10000/88956 (11%)]\tTotal Loss: 0.8457\tAvg Loss: 0.0001\nTrain Epoch: 15\t[15000/88956 (17%)]\tTotal Loss: 1.2614\tAvg Loss: 0.0001\nTrain Epoch: 15\t[20000/88956 (22%)]\tTotal Loss: 1.6857\tAvg Loss: 0.0001\nTrain Epoch: 15\t[25000/88956 (28%)]\tTotal Loss: 2.1049\tAvg Loss: 0.0001\nTrain Epoch: 15\t[30000/88956 (34%)]\tTotal Loss: 2.5143\tAvg Loss: 0.0001\nTrain Epoch: 15\t[35000/88956 (39%)]\tTotal Loss: 2.9451\tAvg Loss: 0.0001\nTrain Epoch: 15\t[40000/88956 (45%)]\tTotal Loss: 3.3672\tAvg Loss: 0.0001\nTrain Epoch: 15\t[45000/88956 (51%)]\tTotal Loss: 3.8128\tAvg Loss: 0.0001\nTrain Epoch: 15\t[50000/88956 (56%)]\tTotal Loss: 4.2301\tAvg Loss: 0.0001\nTrain Epoch: 15\t[55000/88956 (62%)]\tTotal Loss: 4.6467\tAvg Loss: 0.0001\nTrain Epoch: 15\t[60000/88956 (67%)]\tTotal Loss: 5.0583\tAvg Loss: 0.0001\nTrain Epoch: 15\t[65000/88956 (73%)]\tTotal Loss: 5.4747\tAvg Loss: 0.0001\nTrain Epoch: 15\t[70000/88956 (79%)]\tTotal Loss: 5.9109\tAvg Loss: 0.0001\nTrain Epoch: 15\t[75000/88956 (84%)]\tTotal Loss: 6.3437\tAvg Loss: 0.0001\nTrain Epoch: 15\t[80000/88956 (90%)]\tTotal Loss: 6.7620\tAvg Loss: 0.0001\nTrain Epoch: 15\t[85000/88956 (96%)]\tTotal Loss: 7.1799\tAvg Loss: 0.0001\n====> Epoch: 15\tTotal Loss: 7.5157\t Avg Loss: 0.0001\tCorrect: 48141/88956\tPercentage Correct: 54.12\n====> Val Loss: 0.9582\t Avg Loss: 0.0001\tCorrect: 5073/9885\tPercentage Correct: 51.32\n====> Test Loss: 2.3570\t Avg Loss: 0.0001\tCorrect: 12922/24711\tPercentage Correct: 52.29\n\n=== saved best model ===\n\nTrain Epoch: 16\t[5000/88956 (6%)]\tTotal Loss: 0.3983\tAvg Loss: 0.0001\nTrain Epoch: 16\t[10000/88956 (11%)]\tTotal Loss: 0.7862\tAvg Loss: 0.0001\nTrain Epoch: 16\t[15000/88956 (17%)]\tTotal Loss: 1.1910\tAvg Loss: 0.0001\nTrain Epoch: 16\t[20000/88956 (22%)]\tTotal Loss: 1.5944\tAvg Loss: 0.0001\nTrain Epoch: 16\t[25000/88956 (28%)]\tTotal Loss: 1.9827\tAvg Loss: 0.0001\nTrain Epoch: 16\t[30000/88956 (34%)]\tTotal Loss: 2.3778\tAvg Loss: 0.0001\nTrain Epoch: 16\t[35000/88956 (39%)]\tTotal Loss: 2.7851\tAvg Loss: 0.0001\nTrain Epoch: 16\t[40000/88956 (45%)]\tTotal Loss: 3.1733\tAvg Loss: 0.0001\nTrain Epoch: 16\t[45000/88956 (51%)]\tTotal Loss: 3.5664\tAvg Loss: 0.0001\nTrain Epoch: 16\t[50000/88956 (56%)]\tTotal Loss: 3.9614\tAvg Loss: 0.0001\nTrain Epoch: 16\t[55000/88956 (62%)]\tTotal Loss: 4.3554\tAvg Loss: 0.0001\nTrain Epoch: 16\t[60000/88956 (67%)]\tTotal Loss: 4.7612\tAvg Loss: 0.0001\nTrain Epoch: 16\t[65000/88956 (73%)]\tTotal Loss: 5.1656\tAvg Loss: 0.0001\nTrain Epoch: 16\t[70000/88956 (79%)]\tTotal Loss: 5.5505\tAvg Loss: 0.0001\nTrain Epoch: 16\t[75000/88956 (84%)]\tTotal Loss: 5.9476\tAvg Loss: 0.0001\nTrain Epoch: 16\t[80000/88956 (90%)]\tTotal Loss: 6.3594\tAvg Loss: 0.0001\nTrain Epoch: 16\t[85000/88956 (96%)]\tTotal Loss: 6.7885\tAvg Loss: 0.0001\n====> Epoch: 16\tTotal Loss: 7.1481\t Avg Loss: 0.0001\tCorrect: 49573/88956\tPercentage Correct: 55.73\n====> Val Loss: 0.9247\t Avg Loss: 0.0001\tCorrect: 4951/9885\tPercentage Correct: 50.09\n====> Test Loss: 2.3046\t Avg Loss: 0.0001\tCorrect: 12527/24711\tPercentage Correct: 50.69\nTrain Epoch: 17\t[5000/88956 (6%)]\tTotal Loss: 0.3963\tAvg Loss: 0.0001\nTrain Epoch: 17\t[10000/88956 (11%)]\tTotal Loss: 0.8107\tAvg Loss: 0.0001\nTrain Epoch: 17\t[15000/88956 (17%)]\tTotal Loss: 1.2190\tAvg Loss: 0.0001\nTrain Epoch: 17\t[20000/88956 (22%)]\tTotal Loss: 1.6042\tAvg Loss: 0.0001\nTrain Epoch: 17\t[25000/88956 (28%)]\tTotal Loss: 1.9929\tAvg Loss: 0.0001\nTrain Epoch: 17\t[30000/88956 (34%)]\tTotal Loss: 2.4081\tAvg Loss: 0.0001\nTrain Epoch: 17\t[35000/88956 (39%)]\tTotal Loss: 2.7734\tAvg Loss: 0.0001\nTrain Epoch: 17\t[40000/88956 (45%)]\tTotal Loss: 3.1698\tAvg Loss: 0.0001\nTrain Epoch: 17\t[45000/88956 (51%)]\tTotal Loss: 3.5681\tAvg Loss: 0.0001\nTrain Epoch: 17\t[50000/88956 (56%)]\tTotal Loss: 3.9387\tAvg Loss: 0.0001\nTrain Epoch: 17\t[55000/88956 (62%)]\tTotal Loss: 4.3207\tAvg Loss: 0.0001\nTrain Epoch: 17\t[60000/88956 (67%)]\tTotal Loss: 4.6952\tAvg Loss: 0.0001\nTrain Epoch: 17\t[65000/88956 (73%)]\tTotal Loss: 5.0685\tAvg Loss: 0.0001\nTrain Epoch: 17\t[70000/88956 (79%)]\tTotal Loss: 5.4773\tAvg Loss: 0.0001\nTrain Epoch: 17\t[75000/88956 (84%)]\tTotal Loss: 5.8766\tAvg Loss: 0.0001\nTrain Epoch: 17\t[80000/88956 (90%)]\tTotal Loss: 6.2653\tAvg Loss: 0.0001\nTrain Epoch: 17\t[85000/88956 (96%)]\tTotal Loss: 6.6541\tAvg Loss: 0.0001\n====> Epoch: 17\tTotal Loss: 6.9743\t Avg Loss: 0.0001\tCorrect: 50256/88956\tPercentage Correct: 56.50\n====> Val Loss: 0.8467\t Avg Loss: 0.0001\tCorrect: 5466/9885\tPercentage Correct: 55.30\n====> Test Loss: 2.0827\t Avg Loss: 0.0001\tCorrect: 13786/24711\tPercentage Correct: 55.79\n\n=== saved best model ===\n\nTrain Epoch: 18\t[5000/88956 (6%)]\tTotal Loss: 0.3815\tAvg Loss: 0.0001\nTrain Epoch: 18\t[10000/88956 (11%)]\tTotal Loss: 0.7472\tAvg Loss: 0.0001\nTrain Epoch: 18\t[15000/88956 (17%)]\tTotal Loss: 1.1246\tAvg Loss: 0.0001\nTrain Epoch: 18\t[20000/88956 (22%)]\tTotal Loss: 1.4924\tAvg Loss: 0.0001\nTrain Epoch: 18\t[25000/88956 (28%)]\tTotal Loss: 1.8886\tAvg Loss: 0.0001\nTrain Epoch: 18\t[30000/88956 (34%)]\tTotal Loss: 2.2631\tAvg Loss: 0.0001\nTrain Epoch: 18\t[35000/88956 (39%)]\tTotal Loss: 2.6374\tAvg Loss: 0.0001\nTrain Epoch: 18\t[40000/88956 (45%)]\tTotal Loss: 2.9955\tAvg Loss: 0.0001\nTrain Epoch: 18\t[45000/88956 (51%)]\tTotal Loss: 3.3736\tAvg Loss: 0.0001\nTrain Epoch: 18\t[50000/88956 (56%)]\tTotal Loss: 3.7698\tAvg Loss: 0.0001\nTrain Epoch: 18\t[55000/88956 (62%)]\tTotal Loss: 4.1585\tAvg Loss: 0.0001\nTrain Epoch: 18\t[60000/88956 (67%)]\tTotal Loss: 4.5411\tAvg Loss: 0.0001\nTrain Epoch: 18\t[65000/88956 (73%)]\tTotal Loss: 4.9313\tAvg Loss: 0.0001\nTrain Epoch: 18\t[70000/88956 (79%)]\tTotal Loss: 5.3037\tAvg Loss: 0.0001\nTrain Epoch: 18\t[75000/88956 (84%)]\tTotal Loss: 5.6688\tAvg Loss: 0.0001\nTrain Epoch: 18\t[80000/88956 (90%)]\tTotal Loss: 6.0630\tAvg Loss: 0.0001\nTrain Epoch: 18\t[85000/88956 (96%)]\tTotal Loss: 6.4342\tAvg Loss: 0.0001\n====> Epoch: 18\tTotal Loss: 6.7185\t Avg Loss: 0.0001\tCorrect: 51390/88956\tPercentage Correct: 57.77\n====> Val Loss: 0.8802\t Avg Loss: 0.0001\tCorrect: 5351/9885\tPercentage Correct: 54.13\n====> Test Loss: 2.1771\t Avg Loss: 0.0001\tCorrect: 13316/24711\tPercentage Correct: 53.89\nTrain Epoch: 19\t[5000/88956 (6%)]\tTotal Loss: 0.3710\tAvg Loss: 0.0001\nTrain Epoch: 19\t[10000/88956 (11%)]\tTotal Loss: 0.7405\tAvg Loss: 0.0001\nTrain Epoch: 19\t[15000/88956 (17%)]\tTotal Loss: 1.1105\tAvg Loss: 0.0001\nTrain Epoch: 19\t[20000/88956 (22%)]\tTotal Loss: 1.4663\tAvg Loss: 0.0001\nTrain Epoch: 19\t[25000/88956 (28%)]\tTotal Loss: 1.8271\tAvg Loss: 0.0001\nTrain Epoch: 19\t[30000/88956 (34%)]\tTotal Loss: 2.1883\tAvg Loss: 0.0001\nTrain Epoch: 19\t[35000/88956 (39%)]\tTotal Loss: 2.5518\tAvg Loss: 0.0001\nTrain Epoch: 19\t[40000/88956 (45%)]\tTotal Loss: 2.9218\tAvg Loss: 0.0001\nTrain Epoch: 19\t[45000/88956 (51%)]\tTotal Loss: 3.2880\tAvg Loss: 0.0001\nTrain Epoch: 19\t[50000/88956 (56%)]\tTotal Loss: 3.6487\tAvg Loss: 0.0001\nTrain Epoch: 19\t[55000/88956 (62%)]\tTotal Loss: 4.0259\tAvg Loss: 0.0001\nTrain Epoch: 19\t[60000/88956 (67%)]\tTotal Loss: 4.3879\tAvg Loss: 0.0001\nTrain Epoch: 19\t[65000/88956 (73%)]\tTotal Loss: 4.7490\tAvg Loss: 0.0001\nTrain Epoch: 19\t[70000/88956 (79%)]\tTotal Loss: 5.1095\tAvg Loss: 0.0001\nTrain Epoch: 19\t[75000/88956 (84%)]\tTotal Loss: 5.4809\tAvg Loss: 0.0001\nTrain Epoch: 19\t[80000/88956 (90%)]\tTotal Loss: 5.8428\tAvg Loss: 0.0001\nTrain Epoch: 19\t[85000/88956 (96%)]\tTotal Loss: 6.2150\tAvg Loss: 0.0001\n====> Epoch: 19\tTotal Loss: 6.5102\t Avg Loss: 0.0001\tCorrect: 52561/88956\tPercentage Correct: 59.09\n====> Val Loss: 0.8437\t Avg Loss: 0.0001\tCorrect: 5433/9885\tPercentage Correct: 54.96\n====> Test Loss: 2.1135\t Avg Loss: 0.0001\tCorrect: 13667/24711\tPercentage Correct: 55.31\nTrain Epoch: 20\t[5000/88956 (6%)]\tTotal Loss: 0.3545\tAvg Loss: 0.0001\nTrain Epoch: 20\t[10000/88956 (11%)]\tTotal Loss: 0.7078\tAvg Loss: 0.0001\nTrain Epoch: 20\t[15000/88956 (17%)]\tTotal Loss: 1.0710\tAvg Loss: 0.0001\nTrain Epoch: 20\t[20000/88956 (22%)]\tTotal Loss: 1.4022\tAvg Loss: 0.0001\nTrain Epoch: 20\t[25000/88956 (28%)]\tTotal Loss: 1.7508\tAvg Loss: 0.0001\nTrain Epoch: 20\t[30000/88956 (34%)]\tTotal Loss: 2.0913\tAvg Loss: 0.0001\nTrain Epoch: 20\t[35000/88956 (39%)]\tTotal Loss: 2.4301\tAvg Loss: 0.0001\nTrain Epoch: 20\t[40000/88956 (45%)]\tTotal Loss: 2.7660\tAvg Loss: 0.0001\nTrain Epoch: 20\t[45000/88956 (51%)]\tTotal Loss: 3.1256\tAvg Loss: 0.0001\nTrain Epoch: 20\t[50000/88956 (56%)]\tTotal Loss: 3.5102\tAvg Loss: 0.0001\nTrain Epoch: 20\t[55000/88956 (62%)]\tTotal Loss: 3.8704\tAvg Loss: 0.0001\nTrain Epoch: 20\t[60000/88956 (67%)]\tTotal Loss: 4.2402\tAvg Loss: 0.0001\nTrain Epoch: 20\t[65000/88956 (73%)]\tTotal Loss: 4.5959\tAvg Loss: 0.0001\nTrain Epoch: 20\t[70000/88956 (79%)]\tTotal Loss: 4.9956\tAvg Loss: 0.0001\nTrain Epoch: 20\t[75000/88956 (84%)]\tTotal Loss: 5.3660\tAvg Loss: 0.0001\nTrain Epoch: 20\t[80000/88956 (90%)]\tTotal Loss: 5.7465\tAvg Loss: 0.0001\nTrain Epoch: 20\t[85000/88956 (96%)]\tTotal Loss: 6.1265\tAvg Loss: 0.0001\n====> Epoch: 20\tTotal Loss: 6.4268\t Avg Loss: 0.0001\tCorrect: 53142/88956\tPercentage Correct: 59.74\n====> Val Loss: 0.8534\t Avg Loss: 0.0001\tCorrect: 5327/9885\tPercentage Correct: 53.89\n====> Test Loss: 2.1481\t Avg Loss: 0.0001\tCorrect: 13328/24711\tPercentage Correct: 53.94\nTrain Epoch: 21\t[5000/88956 (6%)]\tTotal Loss: 0.3417\tAvg Loss: 0.0001\nTrain Epoch: 21\t[10000/88956 (11%)]\tTotal Loss: 0.6552\tAvg Loss: 0.0001\nTrain Epoch: 21\t[15000/88956 (17%)]\tTotal Loss: 0.9893\tAvg Loss: 0.0001\nTrain Epoch: 21\t[20000/88956 (22%)]\tTotal Loss: 1.3172\tAvg Loss: 0.0001\nTrain Epoch: 21\t[25000/88956 (28%)]\tTotal Loss: 1.6725\tAvg Loss: 0.0001\nTrain Epoch: 21\t[30000/88956 (34%)]\tTotal Loss: 1.9993\tAvg Loss: 0.0001\nTrain Epoch: 21\t[35000/88956 (39%)]\tTotal Loss: 2.3530\tAvg Loss: 0.0001\nTrain Epoch: 21\t[40000/88956 (45%)]\tTotal Loss: 2.7163\tAvg Loss: 0.0001\nTrain Epoch: 21\t[45000/88956 (51%)]\tTotal Loss: 3.0764\tAvg Loss: 0.0001\nTrain Epoch: 21\t[50000/88956 (56%)]\tTotal Loss: 3.4260\tAvg Loss: 0.0001\nTrain Epoch: 21\t[55000/88956 (62%)]\tTotal Loss: 3.7616\tAvg Loss: 0.0001\nTrain Epoch: 21\t[60000/88956 (67%)]\tTotal Loss: 4.0975\tAvg Loss: 0.0001\nTrain Epoch: 21\t[65000/88956 (73%)]\tTotal Loss: 4.4253\tAvg Loss: 0.0001\nTrain Epoch: 21\t[70000/88956 (79%)]\tTotal Loss: 4.7615\tAvg Loss: 0.0001\nTrain Epoch: 21\t[75000/88956 (84%)]\tTotal Loss: 5.1332\tAvg Loss: 0.0001\nTrain Epoch: 21\t[80000/88956 (90%)]\tTotal Loss: 5.4836\tAvg Loss: 0.0001\nTrain Epoch: 21\t[85000/88956 (96%)]\tTotal Loss: 5.8399\tAvg Loss: 0.0001\n====> Epoch: 21\tTotal Loss: 6.1098\t Avg Loss: 0.0001\tCorrect: 54516/88956\tPercentage Correct: 61.28\n====> Val Loss: 0.8075\t Avg Loss: 0.0001\tCorrect: 5681/9885\tPercentage Correct: 57.47\n====> Test Loss: 1.9594\t Avg Loss: 0.0001\tCorrect: 14275/24711\tPercentage Correct: 57.77\n\n=== saved best model ===\n\nTrain Epoch: 22\t[5000/88956 (6%)]\tTotal Loss: 0.3325\tAvg Loss: 0.0001\nTrain Epoch: 22\t[10000/88956 (11%)]\tTotal Loss: 0.6515\tAvg Loss: 0.0001\nTrain Epoch: 22\t[15000/88956 (17%)]\tTotal Loss: 0.9724\tAvg Loss: 0.0001\nTrain Epoch: 22\t[20000/88956 (22%)]\tTotal Loss: 1.3025\tAvg Loss: 0.0001\nTrain Epoch: 22\t[25000/88956 (28%)]\tTotal Loss: 1.6293\tAvg Loss: 0.0001\nTrain Epoch: 22\t[30000/88956 (34%)]\tTotal Loss: 1.9471\tAvg Loss: 0.0001\nTrain Epoch: 22\t[35000/88956 (39%)]\tTotal Loss: 2.2914\tAvg Loss: 0.0001\nTrain Epoch: 22\t[40000/88956 (45%)]\tTotal Loss: 2.6252\tAvg Loss: 0.0001\nTrain Epoch: 22\t[45000/88956 (51%)]\tTotal Loss: 2.9539\tAvg Loss: 0.0001\nTrain Epoch: 22\t[50000/88956 (56%)]\tTotal Loss: 3.3032\tAvg Loss: 0.0001\nTrain Epoch: 22\t[55000/88956 (62%)]\tTotal Loss: 3.6547\tAvg Loss: 0.0001\nTrain Epoch: 22\t[60000/88956 (67%)]\tTotal Loss: 4.0030\tAvg Loss: 0.0001\nTrain Epoch: 22\t[65000/88956 (73%)]\tTotal Loss: 4.3340\tAvg Loss: 0.0001\nTrain Epoch: 22\t[70000/88956 (79%)]\tTotal Loss: 4.6677\tAvg Loss: 0.0001\nTrain Epoch: 22\t[75000/88956 (84%)]\tTotal Loss: 5.0141\tAvg Loss: 0.0001\nTrain Epoch: 22\t[80000/88956 (90%)]\tTotal Loss: 5.3584\tAvg Loss: 0.0001\nTrain Epoch: 22\t[85000/88956 (96%)]\tTotal Loss: 5.7014\tAvg Loss: 0.0001\n====> Epoch: 22\tTotal Loss: 5.9602\t Avg Loss: 0.0001\tCorrect: 55138/88956\tPercentage Correct: 61.98\n====> Val Loss: 0.7774\t Avg Loss: 0.0001\tCorrect: 5782/9885\tPercentage Correct: 58.49\n====> Test Loss: 1.9316\t Avg Loss: 0.0001\tCorrect: 14365/24711\tPercentage Correct: 58.13\n\n=== saved best model ===\n\nTrain Epoch: 23\t[5000/88956 (6%)]\tTotal Loss: 0.3410\tAvg Loss: 0.0001\nTrain Epoch: 23\t[10000/88956 (11%)]\tTotal Loss: 0.6558\tAvg Loss: 0.0001\nTrain Epoch: 23\t[15000/88956 (17%)]\tTotal Loss: 0.9771\tAvg Loss: 0.0001\nTrain Epoch: 23\t[20000/88956 (22%)]\tTotal Loss: 1.3058\tAvg Loss: 0.0001\nTrain Epoch: 23\t[25000/88956 (28%)]\tTotal Loss: 1.6294\tAvg Loss: 0.0001\nTrain Epoch: 23\t[30000/88956 (34%)]\tTotal Loss: 1.9792\tAvg Loss: 0.0001\nTrain Epoch: 23\t[35000/88956 (39%)]\tTotal Loss: 2.3028\tAvg Loss: 0.0001\nTrain Epoch: 23\t[40000/88956 (45%)]\tTotal Loss: 2.6156\tAvg Loss: 0.0001\nTrain Epoch: 23\t[45000/88956 (51%)]\tTotal Loss: 2.9409\tAvg Loss: 0.0001\nTrain Epoch: 23\t[50000/88956 (56%)]\tTotal Loss: 3.2530\tAvg Loss: 0.0001\nTrain Epoch: 23\t[55000/88956 (62%)]\tTotal Loss: 3.5714\tAvg Loss: 0.0001\nTrain Epoch: 23\t[60000/88956 (67%)]\tTotal Loss: 3.9028\tAvg Loss: 0.0001\nTrain Epoch: 23\t[65000/88956 (73%)]\tTotal Loss: 4.2155\tAvg Loss: 0.0001\nTrain Epoch: 23\t[70000/88956 (79%)]\tTotal Loss: 4.5547\tAvg Loss: 0.0001\nTrain Epoch: 23\t[75000/88956 (84%)]\tTotal Loss: 4.8651\tAvg Loss: 0.0001\nTrain Epoch: 23\t[80000/88956 (90%)]\tTotal Loss: 5.1978\tAvg Loss: 0.0001\nTrain Epoch: 23\t[85000/88956 (96%)]\tTotal Loss: 5.5196\tAvg Loss: 0.0001\n====> Epoch: 23\tTotal Loss: 5.7805\t Avg Loss: 0.0001\tCorrect: 56110/88956\tPercentage Correct: 63.08\n====> Val Loss: 0.7871\t Avg Loss: 0.0001\tCorrect: 5614/9885\tPercentage Correct: 56.79\n====> Test Loss: 1.9534\t Avg Loss: 0.0001\tCorrect: 14112/24711\tPercentage Correct: 57.11\nTrain Epoch: 24\t[5000/88956 (6%)]\tTotal Loss: 0.3119\tAvg Loss: 0.0001\nTrain Epoch: 24\t[10000/88956 (11%)]\tTotal Loss: 0.6254\tAvg Loss: 0.0001\nTrain Epoch: 24\t[15000/88956 (17%)]\tTotal Loss: 0.9469\tAvg Loss: 0.0001\nTrain Epoch: 24\t[20000/88956 (22%)]\tTotal Loss: 1.2570\tAvg Loss: 0.0001\nTrain Epoch: 24\t[25000/88956 (28%)]\tTotal Loss: 1.5647\tAvg Loss: 0.0001\nTrain Epoch: 24\t[30000/88956 (34%)]\tTotal Loss: 1.8798\tAvg Loss: 0.0001\nTrain Epoch: 24\t[35000/88956 (39%)]\tTotal Loss: 2.2102\tAvg Loss: 0.0001\nTrain Epoch: 24\t[40000/88956 (45%)]\tTotal Loss: 2.5297\tAvg Loss: 0.0001\nTrain Epoch: 24\t[45000/88956 (51%)]\tTotal Loss: 2.8648\tAvg Loss: 0.0001\nTrain Epoch: 24\t[50000/88956 (56%)]\tTotal Loss: 3.1795\tAvg Loss: 0.0001\nTrain Epoch: 24\t[55000/88956 (62%)]\tTotal Loss: 3.5076\tAvg Loss: 0.0001\nTrain Epoch: 24\t[60000/88956 (67%)]\tTotal Loss: 3.8329\tAvg Loss: 0.0001\nTrain Epoch: 24\t[65000/88956 (73%)]\tTotal Loss: 4.1703\tAvg Loss: 0.0001\nTrain Epoch: 24\t[70000/88956 (79%)]\tTotal Loss: 4.5024\tAvg Loss: 0.0001\nTrain Epoch: 24\t[75000/88956 (84%)]\tTotal Loss: 4.8421\tAvg Loss: 0.0001\nTrain Epoch: 24\t[80000/88956 (90%)]\tTotal Loss: 5.1586\tAvg Loss: 0.0001\nTrain Epoch: 24\t[85000/88956 (96%)]\tTotal Loss: 5.4659\tAvg Loss: 0.0001\n====> Epoch: 24\tTotal Loss: 5.7214\t Avg Loss: 0.0001\tCorrect: 56410/88956\tPercentage Correct: 63.41\n====> Val Loss: 0.7978\t Avg Loss: 0.0001\tCorrect: 5597/9885\tPercentage Correct: 56.62\n====> Test Loss: 2.0053\t Avg Loss: 0.0001\tCorrect: 14030/24711\tPercentage Correct: 56.78\nTrain Epoch: 25\t[5000/88956 (6%)]\tTotal Loss: 0.3075\tAvg Loss: 0.0001\nTrain Epoch: 25\t[10000/88956 (11%)]\tTotal Loss: 0.6178\tAvg Loss: 0.0001\nTrain Epoch: 25\t[15000/88956 (17%)]\tTotal Loss: 0.9193\tAvg Loss: 0.0001\nTrain Epoch: 25\t[20000/88956 (22%)]\tTotal Loss: 1.2238\tAvg Loss: 0.0001\nTrain Epoch: 25\t[25000/88956 (28%)]\tTotal Loss: 1.5298\tAvg Loss: 0.0001\nTrain Epoch: 25\t[30000/88956 (34%)]\tTotal Loss: 1.8138\tAvg Loss: 0.0001\nTrain Epoch: 25\t[35000/88956 (39%)]\tTotal Loss: 2.1382\tAvg Loss: 0.0001\nTrain Epoch: 25\t[40000/88956 (45%)]\tTotal Loss: 2.4682\tAvg Loss: 0.0001\nTrain Epoch: 25\t[45000/88956 (51%)]\tTotal Loss: 2.7873\tAvg Loss: 0.0001\nTrain Epoch: 25\t[50000/88956 (56%)]\tTotal Loss: 3.1122\tAvg Loss: 0.0001\nTrain Epoch: 25\t[55000/88956 (62%)]\tTotal Loss: 3.4236\tAvg Loss: 0.0001\nTrain Epoch: 25\t[60000/88956 (67%)]\tTotal Loss: 3.7401\tAvg Loss: 0.0001\nTrain Epoch: 25\t[65000/88956 (73%)]\tTotal Loss: 4.0755\tAvg Loss: 0.0001\nTrain Epoch: 25\t[70000/88956 (79%)]\tTotal Loss: 4.3982\tAvg Loss: 0.0001\nTrain Epoch: 25\t[75000/88956 (84%)]\tTotal Loss: 4.7106\tAvg Loss: 0.0001\nTrain Epoch: 25\t[80000/88956 (90%)]\tTotal Loss: 5.0386\tAvg Loss: 0.0001\nTrain Epoch: 25\t[85000/88956 (96%)]\tTotal Loss: 5.3567\tAvg Loss: 0.0001\n====> Epoch: 25\tTotal Loss: 5.5908\t Avg Loss: 0.0001\tCorrect: 57128/88956\tPercentage Correct: 64.22\n====> Val Loss: 0.7365\t Avg Loss: 0.0001\tCorrect: 5902/9885\tPercentage Correct: 59.71\n====> Test Loss: 1.8116\t Avg Loss: 0.0001\tCorrect: 14804/24711\tPercentage Correct: 59.91\n\n=== saved best model ===\n\nTrain Epoch: 26\t[5000/88956 (6%)]\tTotal Loss: 0.3021\tAvg Loss: 0.0001\nTrain Epoch: 26\t[10000/88956 (11%)]\tTotal Loss: 0.5855\tAvg Loss: 0.0001\nTrain Epoch: 26\t[15000/88956 (17%)]\tTotal Loss: 0.8829\tAvg Loss: 0.0001\nTrain Epoch: 26\t[20000/88956 (22%)]\tTotal Loss: 1.1727\tAvg Loss: 0.0001\nTrain Epoch: 26\t[25000/88956 (28%)]\tTotal Loss: 1.4682\tAvg Loss: 0.0001\nTrain Epoch: 26\t[30000/88956 (34%)]\tTotal Loss: 1.7610\tAvg Loss: 0.0001\nTrain Epoch: 26\t[35000/88956 (39%)]\tTotal Loss: 2.0505\tAvg Loss: 0.0001\nTrain Epoch: 26\t[40000/88956 (45%)]\tTotal Loss: 2.3525\tAvg Loss: 0.0001\nTrain Epoch: 26\t[45000/88956 (51%)]\tTotal Loss: 2.6643\tAvg Loss: 0.0001\nTrain Epoch: 26\t[50000/88956 (56%)]\tTotal Loss: 2.9743\tAvg Loss: 0.0001\nTrain Epoch: 26\t[55000/88956 (62%)]\tTotal Loss: 3.2939\tAvg Loss: 0.0001\nTrain Epoch: 26\t[60000/88956 (67%)]\tTotal Loss: 3.5952\tAvg Loss: 0.0001\nTrain Epoch: 26\t[65000/88956 (73%)]\tTotal Loss: 3.8924\tAvg Loss: 0.0001\nTrain Epoch: 26\t[70000/88956 (79%)]\tTotal Loss: 4.1868\tAvg Loss: 0.0001\nTrain Epoch: 26\t[75000/88956 (84%)]\tTotal Loss: 4.4879\tAvg Loss: 0.0001\nTrain Epoch: 26\t[80000/88956 (90%)]\tTotal Loss: 4.7898\tAvg Loss: 0.0001\nTrain Epoch: 26\t[85000/88956 (96%)]\tTotal Loss: 5.0808\tAvg Loss: 0.0001\n====> Epoch: 26\tTotal Loss: 5.3263\t Avg Loss: 0.0001\tCorrect: 58271/88956\tPercentage Correct: 65.51\n====> Val Loss: 0.7613\t Avg Loss: 0.0001\tCorrect: 5872/9885\tPercentage Correct: 59.40\n====> Test Loss: 1.8751\t Avg Loss: 0.0001\tCorrect: 14783/24711\tPercentage Correct: 59.82\nTrain Epoch: 27\t[5000/88956 (6%)]\tTotal Loss: 0.3083\tAvg Loss: 0.0001\nTrain Epoch: 27\t[10000/88956 (11%)]\tTotal Loss: 0.6042\tAvg Loss: 0.0001\nTrain Epoch: 27\t[15000/88956 (17%)]\tTotal Loss: 0.8920\tAvg Loss: 0.0001\nTrain Epoch: 27\t[20000/88956 (22%)]\tTotal Loss: 1.1892\tAvg Loss: 0.0001\nTrain Epoch: 27\t[25000/88956 (28%)]\tTotal Loss: 1.4853\tAvg Loss: 0.0001\nTrain Epoch: 27\t[30000/88956 (34%)]\tTotal Loss: 1.7653\tAvg Loss: 0.0001\nTrain Epoch: 27\t[35000/88956 (39%)]\tTotal Loss: 2.0422\tAvg Loss: 0.0001\nTrain Epoch: 27\t[40000/88956 (45%)]\tTotal Loss: 2.3441\tAvg Loss: 0.0001\nTrain Epoch: 27\t[45000/88956 (51%)]\tTotal Loss: 2.6455\tAvg Loss: 0.0001\nTrain Epoch: 27\t[50000/88956 (56%)]\tTotal Loss: 2.9536\tAvg Loss: 0.0001\nTrain Epoch: 27\t[55000/88956 (62%)]\tTotal Loss: 3.3474\tAvg Loss: 0.0001\nTrain Epoch: 27\t[60000/88956 (67%)]\tTotal Loss: 3.6827\tAvg Loss: 0.0001\nTrain Epoch: 27\t[65000/88956 (73%)]\tTotal Loss: 4.0153\tAvg Loss: 0.0001\nTrain Epoch: 27\t[70000/88956 (79%)]\tTotal Loss: 4.3201\tAvg Loss: 0.0001\nTrain Epoch: 27\t[75000/88956 (84%)]\tTotal Loss: 4.6208\tAvg Loss: 0.0001\nTrain Epoch: 27\t[80000/88956 (90%)]\tTotal Loss: 4.9349\tAvg Loss: 0.0001\nTrain Epoch: 27\t[85000/88956 (96%)]\tTotal Loss: 5.2372\tAvg Loss: 0.0001\n====> Epoch: 27\tTotal Loss: 5.4803\t Avg Loss: 0.0001\tCorrect: 57541/88956\tPercentage Correct: 64.68\n====> Val Loss: 0.6967\t Avg Loss: 0.0001\tCorrect: 6087/9885\tPercentage Correct: 61.58\n====> Test Loss: 1.7500\t Avg Loss: 0.0001\tCorrect: 15239/24711\tPercentage Correct: 61.67\n\n=== saved best model ===\n\nTrain Epoch: 28\t[5000/88956 (6%)]\tTotal Loss: 0.2944\tAvg Loss: 0.0001\nTrain Epoch: 28\t[10000/88956 (11%)]\tTotal Loss: 0.5649\tAvg Loss: 0.0001\nTrain Epoch: 28\t[15000/88956 (17%)]\tTotal Loss: 0.8530\tAvg Loss: 0.0001\nTrain Epoch: 28\t[20000/88956 (22%)]\tTotal Loss: 1.1277\tAvg Loss: 0.0001\nTrain Epoch: 28\t[25000/88956 (28%)]\tTotal Loss: 1.3948\tAvg Loss: 0.0001\nTrain Epoch: 28\t[30000/88956 (34%)]\tTotal Loss: 1.6858\tAvg Loss: 0.0001\nTrain Epoch: 28\t[35000/88956 (39%)]\tTotal Loss: 1.9791\tAvg Loss: 0.0001\nTrain Epoch: 28\t[40000/88956 (45%)]\tTotal Loss: 2.2861\tAvg Loss: 0.0001\nTrain Epoch: 28\t[45000/88956 (51%)]\tTotal Loss: 2.5761\tAvg Loss: 0.0001\nTrain Epoch: 28\t[50000/88956 (56%)]\tTotal Loss: 2.8774\tAvg Loss: 0.0001\nTrain Epoch: 28\t[55000/88956 (62%)]\tTotal Loss: 3.1554\tAvg Loss: 0.0001\nTrain Epoch: 28\t[60000/88956 (67%)]\tTotal Loss: 3.4332\tAvg Loss: 0.0001\nTrain Epoch: 28\t[65000/88956 (73%)]\tTotal Loss: 3.7392\tAvg Loss: 0.0001\nTrain Epoch: 28\t[70000/88956 (79%)]\tTotal Loss: 4.0581\tAvg Loss: 0.0001\nTrain Epoch: 28\t[75000/88956 (84%)]\tTotal Loss: 4.3580\tAvg Loss: 0.0001\nTrain Epoch: 28\t[80000/88956 (90%)]\tTotal Loss: 4.6507\tAvg Loss: 0.0001\nTrain Epoch: 28\t[85000/88956 (96%)]\tTotal Loss: 4.9437\tAvg Loss: 0.0001\n====> Epoch: 28\tTotal Loss: 5.1858\t Avg Loss: 0.0001\tCorrect: 58765/88956\tPercentage Correct: 66.06\n====> Val Loss: 0.7277\t Avg Loss: 0.0001\tCorrect: 6016/9885\tPercentage Correct: 60.86\n====> Test Loss: 1.7436\t Avg Loss: 0.0001\tCorrect: 15126/24711\tPercentage Correct: 61.21\nTrain Epoch: 29\t[5000/88956 (6%)]\tTotal Loss: 0.2878\tAvg Loss: 0.0001\nTrain Epoch: 29\t[10000/88956 (11%)]\tTotal Loss: 0.5686\tAvg Loss: 0.0001\nTrain Epoch: 29\t[15000/88956 (17%)]\tTotal Loss: 0.8364\tAvg Loss: 0.0001\nTrain Epoch: 29\t[20000/88956 (22%)]\tTotal Loss: 1.1345\tAvg Loss: 0.0001\nTrain Epoch: 29\t[25000/88956 (28%)]\tTotal Loss: 1.4444\tAvg Loss: 0.0001\nTrain Epoch: 29\t[30000/88956 (34%)]\tTotal Loss: 1.7165\tAvg Loss: 0.0001\nTrain Epoch: 29\t[35000/88956 (39%)]\tTotal Loss: 1.9990\tAvg Loss: 0.0001\nTrain Epoch: 29\t[40000/88956 (45%)]\tTotal Loss: 2.2759\tAvg Loss: 0.0001\nTrain Epoch: 29\t[45000/88956 (51%)]\tTotal Loss: 2.5559\tAvg Loss: 0.0001\nTrain Epoch: 29\t[50000/88956 (56%)]\tTotal Loss: 2.8402\tAvg Loss: 0.0001\nTrain Epoch: 29\t[55000/88956 (62%)]\tTotal Loss: 3.1267\tAvg Loss: 0.0001\nTrain Epoch: 29\t[60000/88956 (67%)]\tTotal Loss: 3.4120\tAvg Loss: 0.0001\nTrain Epoch: 29\t[65000/88956 (73%)]\tTotal Loss: 3.6835\tAvg Loss: 0.0001\nTrain Epoch: 29\t[70000/88956 (79%)]\tTotal Loss: 3.9660\tAvg Loss: 0.0001\nTrain Epoch: 29\t[75000/88956 (84%)]\tTotal Loss: 4.2491\tAvg Loss: 0.0001\nTrain Epoch: 29\t[80000/88956 (90%)]\tTotal Loss: 4.5245\tAvg Loss: 0.0001\nTrain Epoch: 29\t[85000/88956 (96%)]\tTotal Loss: 4.8162\tAvg Loss: 0.0001\n====> Epoch: 29\tTotal Loss: 5.0273\t Avg Loss: 0.0001\tCorrect: 59780/88956\tPercentage Correct: 67.20\n====> Val Loss: 0.7901\t Avg Loss: 0.0001\tCorrect: 5874/9885\tPercentage Correct: 59.42\n====> Test Loss: 1.9130\t Avg Loss: 0.0001\tCorrect: 14636/24711\tPercentage Correct: 59.23\nTrain Epoch: 30\t[5000/88956 (6%)]\tTotal Loss: 0.2768\tAvg Loss: 0.0001\nTrain Epoch: 30\t[10000/88956 (11%)]\tTotal Loss: 0.5494\tAvg Loss: 0.0001\nTrain Epoch: 30\t[15000/88956 (17%)]\tTotal Loss: 0.8213\tAvg Loss: 0.0001\nTrain Epoch: 30\t[20000/88956 (22%)]\tTotal Loss: 1.1055\tAvg Loss: 0.0001\nTrain Epoch: 30\t[25000/88956 (28%)]\tTotal Loss: 1.3879\tAvg Loss: 0.0001\nTrain Epoch: 30\t[30000/88956 (34%)]\tTotal Loss: 1.6689\tAvg Loss: 0.0001\nTrain Epoch: 30\t[35000/88956 (39%)]\tTotal Loss: 1.9593\tAvg Loss: 0.0001\nTrain Epoch: 30\t[40000/88956 (45%)]\tTotal Loss: 2.2352\tAvg Loss: 0.0001\nTrain Epoch: 30\t[45000/88956 (51%)]\tTotal Loss: 2.5072\tAvg Loss: 0.0001\nTrain Epoch: 30\t[50000/88956 (56%)]\tTotal Loss: 2.7891\tAvg Loss: 0.0001\nTrain Epoch: 30\t[55000/88956 (62%)]\tTotal Loss: 3.0781\tAvg Loss: 0.0001\nTrain Epoch: 30\t[60000/88956 (67%)]\tTotal Loss: 3.3509\tAvg Loss: 0.0001\nTrain Epoch: 30\t[65000/88956 (73%)]\tTotal Loss: 3.6519\tAvg Loss: 0.0001\nTrain Epoch: 30\t[70000/88956 (79%)]\tTotal Loss: 3.9386\tAvg Loss: 0.0001\nTrain Epoch: 30\t[75000/88956 (84%)]\tTotal Loss: 4.2081\tAvg Loss: 0.0001\nTrain Epoch: 30\t[80000/88956 (90%)]\tTotal Loss: 4.4986\tAvg Loss: 0.0001\nTrain Epoch: 30\t[85000/88956 (96%)]\tTotal Loss: 4.7903\tAvg Loss: 0.0001\n====> Epoch: 30\tTotal Loss: 5.0219\t Avg Loss: 0.0001\tCorrect: 59672/88956\tPercentage Correct: 67.08\n====> Val Loss: 0.6963\t Avg Loss: 0.0001\tCorrect: 6195/9885\tPercentage Correct: 62.67\n====> Test Loss: 1.6857\t Avg Loss: 0.0001\tCorrect: 15542/24711\tPercentage Correct: 62.90\n\n=== saved best model ===\n\nTrain Epoch: 31\t[5000/88956 (6%)]\tTotal Loss: 0.2597\tAvg Loss: 0.0001\nTrain Epoch: 31\t[10000/88956 (11%)]\tTotal Loss: 0.5186\tAvg Loss: 0.0001\nTrain Epoch: 31\t[15000/88956 (17%)]\tTotal Loss: 0.7914\tAvg Loss: 0.0001\nTrain Epoch: 31\t[20000/88956 (22%)]\tTotal Loss: 1.0620\tAvg Loss: 0.0001\nTrain Epoch: 31\t[25000/88956 (28%)]\tTotal Loss: 1.3261\tAvg Loss: 0.0001\nTrain Epoch: 31\t[30000/88956 (34%)]\tTotal Loss: 1.6061\tAvg Loss: 0.0001\nTrain Epoch: 31\t[35000/88956 (39%)]\tTotal Loss: 1.8880\tAvg Loss: 0.0001\nTrain Epoch: 31\t[40000/88956 (45%)]\tTotal Loss: 2.1926\tAvg Loss: 0.0001\nTrain Epoch: 31\t[45000/88956 (51%)]\tTotal Loss: 2.4544\tAvg Loss: 0.0001\nTrain Epoch: 31\t[50000/88956 (56%)]\tTotal Loss: 2.7433\tAvg Loss: 0.0001\nTrain Epoch: 31\t[55000/88956 (62%)]\tTotal Loss: 3.0156\tAvg Loss: 0.0001\nTrain Epoch: 31\t[60000/88956 (67%)]\tTotal Loss: 3.2994\tAvg Loss: 0.0001\nTrain Epoch: 31\t[65000/88956 (73%)]\tTotal Loss: 3.5678\tAvg Loss: 0.0001\nTrain Epoch: 31\t[70000/88956 (79%)]\tTotal Loss: 3.8561\tAvg Loss: 0.0001\nTrain Epoch: 31\t[75000/88956 (84%)]\tTotal Loss: 4.1230\tAvg Loss: 0.0001\nTrain Epoch: 31\t[80000/88956 (90%)]\tTotal Loss: 4.3989\tAvg Loss: 0.0001\nTrain Epoch: 31\t[85000/88956 (96%)]\tTotal Loss: 4.6775\tAvg Loss: 0.0001\n====> Epoch: 31\tTotal Loss: 4.9020\t Avg Loss: 0.0001\tCorrect: 60356/88956\tPercentage Correct: 67.85\n====> Val Loss: 0.6804\t Avg Loss: 0.0001\tCorrect: 6212/9885\tPercentage Correct: 62.84\n====> Test Loss: 1.6827\t Avg Loss: 0.0001\tCorrect: 15504/24711\tPercentage Correct: 62.74\n\n=== saved best model ===\n\nTrain Epoch: 32\t[5000/88956 (6%)]\tTotal Loss: 0.2772\tAvg Loss: 0.0001\nTrain Epoch: 32\t[10000/88956 (11%)]\tTotal Loss: 0.5173\tAvg Loss: 0.0001\nTrain Epoch: 32\t[15000/88956 (17%)]\tTotal Loss: 0.7991\tAvg Loss: 0.0001\nTrain Epoch: 32\t[20000/88956 (22%)]\tTotal Loss: 1.0786\tAvg Loss: 0.0001\nTrain Epoch: 32\t[25000/88956 (28%)]\tTotal Loss: 1.3394\tAvg Loss: 0.0001\nTrain Epoch: 32\t[30000/88956 (34%)]\tTotal Loss: 1.6063\tAvg Loss: 0.0001\nTrain Epoch: 32\t[35000/88956 (39%)]\tTotal Loss: 1.8738\tAvg Loss: 0.0001\nTrain Epoch: 32\t[40000/88956 (45%)]\tTotal Loss: 2.1441\tAvg Loss: 0.0001\nTrain Epoch: 32\t[45000/88956 (51%)]\tTotal Loss: 2.4215\tAvg Loss: 0.0001\nTrain Epoch: 32\t[50000/88956 (56%)]\tTotal Loss: 2.6920\tAvg Loss: 0.0001\nTrain Epoch: 32\t[55000/88956 (62%)]\tTotal Loss: 3.0641\tAvg Loss: 0.0001\nTrain Epoch: 32\t[60000/88956 (67%)]\tTotal Loss: 3.3769\tAvg Loss: 0.0001\nTrain Epoch: 32\t[65000/88956 (73%)]\tTotal Loss: 3.6471\tAvg Loss: 0.0001\nTrain Epoch: 32\t[70000/88956 (79%)]\tTotal Loss: 3.9082\tAvg Loss: 0.0001\nTrain Epoch: 32\t[75000/88956 (84%)]\tTotal Loss: 4.1866\tAvg Loss: 0.0001\nTrain Epoch: 32\t[80000/88956 (90%)]\tTotal Loss: 4.4743\tAvg Loss: 0.0001\nTrain Epoch: 32\t[85000/88956 (96%)]\tTotal Loss: 4.7424\tAvg Loss: 0.0001\n====> Epoch: 32\tTotal Loss: 4.9524\t Avg Loss: 0.0001\tCorrect: 59861/88956\tPercentage Correct: 67.29\n====> Val Loss: 0.6906\t Avg Loss: 0.0001\tCorrect: 6177/9885\tPercentage Correct: 62.49\n====> Test Loss: 1.6714\t Avg Loss: 0.0001\tCorrect: 15612/24711\tPercentage Correct: 63.18\nTrain Epoch: 33\t[5000/88956 (6%)]\tTotal Loss: 0.2645\tAvg Loss: 0.0001\nTrain Epoch: 33\t[10000/88956 (11%)]\tTotal Loss: 0.5288\tAvg Loss: 0.0001\nTrain Epoch: 33\t[15000/88956 (17%)]\tTotal Loss: 0.7883\tAvg Loss: 0.0001\nTrain Epoch: 33\t[20000/88956 (22%)]\tTotal Loss: 1.0529\tAvg Loss: 0.0001\nTrain Epoch: 33\t[25000/88956 (28%)]\tTotal Loss: 1.3005\tAvg Loss: 0.0001\nTrain Epoch: 33\t[30000/88956 (34%)]\tTotal Loss: 1.5470\tAvg Loss: 0.0001\nTrain Epoch: 33\t[35000/88956 (39%)]\tTotal Loss: 1.8205\tAvg Loss: 0.0001\nTrain Epoch: 33\t[40000/88956 (45%)]\tTotal Loss: 2.1005\tAvg Loss: 0.0001\nTrain Epoch: 33\t[45000/88956 (51%)]\tTotal Loss: 2.3774\tAvg Loss: 0.0001\nTrain Epoch: 33\t[50000/88956 (56%)]\tTotal Loss: 2.6509\tAvg Loss: 0.0001\nTrain Epoch: 33\t[55000/88956 (62%)]\tTotal Loss: 2.9235\tAvg Loss: 0.0001\nTrain Epoch: 33\t[60000/88956 (67%)]\tTotal Loss: 3.2000\tAvg Loss: 0.0001\nTrain Epoch: 33\t[65000/88956 (73%)]\tTotal Loss: 3.4738\tAvg Loss: 0.0001\nTrain Epoch: 33\t[70000/88956 (79%)]\tTotal Loss: 3.7448\tAvg Loss: 0.0001\nTrain Epoch: 33\t[75000/88956 (84%)]\tTotal Loss: 4.0023\tAvg Loss: 0.0001\nTrain Epoch: 33\t[80000/88956 (90%)]\tTotal Loss: 4.2624\tAvg Loss: 0.0001\nTrain Epoch: 33\t[85000/88956 (96%)]\tTotal Loss: 4.5277\tAvg Loss: 0.0001\n====> Epoch: 33\tTotal Loss: 4.7325\t Avg Loss: 0.0001\tCorrect: 60996/88956\tPercentage Correct: 68.57\n====> Val Loss: 0.6645\t Avg Loss: 0.0001\tCorrect: 6164/9885\tPercentage Correct: 62.36\n====> Test Loss: 1.6093\t Avg Loss: 0.0001\tCorrect: 15535/24711\tPercentage Correct: 62.87\nTrain Epoch: 34\t[5000/88956 (6%)]\tTotal Loss: 0.2501\tAvg Loss: 0.0001\nTrain Epoch: 34\t[10000/88956 (11%)]\tTotal Loss: 0.5145\tAvg Loss: 0.0001\nTrain Epoch: 34\t[15000/88956 (17%)]\tTotal Loss: 0.7569\tAvg Loss: 0.0001\nTrain Epoch: 34\t[20000/88956 (22%)]\tTotal Loss: 0.9966\tAvg Loss: 0.0000\nTrain Epoch: 34\t[25000/88956 (28%)]\tTotal Loss: 1.2505\tAvg Loss: 0.0001\nTrain Epoch: 34\t[30000/88956 (34%)]\tTotal Loss: 1.4956\tAvg Loss: 0.0000\nTrain Epoch: 34\t[35000/88956 (39%)]\tTotal Loss: 1.7564\tAvg Loss: 0.0001\nTrain Epoch: 34\t[40000/88956 (45%)]\tTotal Loss: 2.0303\tAvg Loss: 0.0001\nTrain Epoch: 34\t[45000/88956 (51%)]\tTotal Loss: 2.2865\tAvg Loss: 0.0001\nTrain Epoch: 34\t[50000/88956 (56%)]\tTotal Loss: 2.5623\tAvg Loss: 0.0001\nTrain Epoch: 34\t[55000/88956 (62%)]\tTotal Loss: 2.8231\tAvg Loss: 0.0001\nTrain Epoch: 34\t[60000/88956 (67%)]\tTotal Loss: 3.0774\tAvg Loss: 0.0001\nTrain Epoch: 34\t[65000/88956 (73%)]\tTotal Loss: 3.3181\tAvg Loss: 0.0001\nTrain Epoch: 34\t[70000/88956 (79%)]\tTotal Loss: 3.5727\tAvg Loss: 0.0001\nTrain Epoch: 34\t[75000/88956 (84%)]\tTotal Loss: 3.8401\tAvg Loss: 0.0001\nTrain Epoch: 34\t[80000/88956 (90%)]\tTotal Loss: 4.1015\tAvg Loss: 0.0001\nTrain Epoch: 34\t[85000/88956 (96%)]\tTotal Loss: 4.3543\tAvg Loss: 0.0001\n====> Epoch: 34\tTotal Loss: 4.5646\t Avg Loss: 0.0001\tCorrect: 61818/88956\tPercentage Correct: 69.49\n====> Val Loss: 0.7065\t Avg Loss: 0.0001\tCorrect: 6221/9885\tPercentage Correct: 62.93\n====> Test Loss: 1.7242\t Avg Loss: 0.0001\tCorrect: 15654/24711\tPercentage Correct: 63.35\n\n=== saved best model ===\n\nTrain Epoch: 35\t[5000/88956 (6%)]\tTotal Loss: 0.2607\tAvg Loss: 0.0001\nTrain Epoch: 35\t[10000/88956 (11%)]\tTotal Loss: 0.5104\tAvg Loss: 0.0001\nTrain Epoch: 35\t[15000/88956 (17%)]\tTotal Loss: 0.7587\tAvg Loss: 0.0001\nTrain Epoch: 35\t[20000/88956 (22%)]\tTotal Loss: 1.0187\tAvg Loss: 0.0001\nTrain Epoch: 35\t[25000/88956 (28%)]\tTotal Loss: 1.2670\tAvg Loss: 0.0001\nTrain Epoch: 35\t[30000/88956 (34%)]\tTotal Loss: 1.5270\tAvg Loss: 0.0001\nTrain Epoch: 35\t[35000/88956 (39%)]\tTotal Loss: 1.7809\tAvg Loss: 0.0001\nTrain Epoch: 35\t[40000/88956 (45%)]\tTotal Loss: 2.0329\tAvg Loss: 0.0001\nTrain Epoch: 35\t[45000/88956 (51%)]\tTotal Loss: 2.2978\tAvg Loss: 0.0001\nTrain Epoch: 35\t[50000/88956 (56%)]\tTotal Loss: 2.5598\tAvg Loss: 0.0001\nTrain Epoch: 35\t[55000/88956 (62%)]\tTotal Loss: 2.8226\tAvg Loss: 0.0001\nTrain Epoch: 35\t[60000/88956 (67%)]\tTotal Loss: 3.0993\tAvg Loss: 0.0001\nTrain Epoch: 35\t[65000/88956 (73%)]\tTotal Loss: 3.3533\tAvg Loss: 0.0001\nTrain Epoch: 35\t[70000/88956 (79%)]\tTotal Loss: 3.6044\tAvg Loss: 0.0001\nTrain Epoch: 35\t[75000/88956 (84%)]\tTotal Loss: 3.8522\tAvg Loss: 0.0001\nTrain Epoch: 35\t[80000/88956 (90%)]\tTotal Loss: 4.1110\tAvg Loss: 0.0001\nTrain Epoch: 35\t[85000/88956 (96%)]\tTotal Loss: 4.4206\tAvg Loss: 0.0001\n====> Epoch: 35\tTotal Loss: 4.6429\t Avg Loss: 0.0001\tCorrect: 61651/88956\tPercentage Correct: 69.31\n====> Val Loss: 0.7070\t Avg Loss: 0.0001\tCorrect: 6054/9885\tPercentage Correct: 61.24\n====> Test Loss: 1.7595\t Avg Loss: 0.0001\tCorrect: 15077/24711\tPercentage Correct: 61.01\nTrain Epoch: 36\t[5000/88956 (6%)]\tTotal Loss: 0.2465\tAvg Loss: 0.0000\nTrain Epoch: 36\t[10000/88956 (11%)]\tTotal Loss: 0.4869\tAvg Loss: 0.0000\nTrain Epoch: 36\t[15000/88956 (17%)]\tTotal Loss: 0.7437\tAvg Loss: 0.0000\nTrain Epoch: 36\t[20000/88956 (22%)]\tTotal Loss: 0.9927\tAvg Loss: 0.0000\nTrain Epoch: 36\t[25000/88956 (28%)]\tTotal Loss: 1.2478\tAvg Loss: 0.0000\nTrain Epoch: 36\t[30000/88956 (34%)]\tTotal Loss: 1.4768\tAvg Loss: 0.0000\nTrain Epoch: 36\t[35000/88956 (39%)]\tTotal Loss: 1.7228\tAvg Loss: 0.0000\nTrain Epoch: 36\t[40000/88956 (45%)]\tTotal Loss: 1.9902\tAvg Loss: 0.0000\nTrain Epoch: 36\t[45000/88956 (51%)]\tTotal Loss: 2.2449\tAvg Loss: 0.0000\nTrain Epoch: 36\t[50000/88956 (56%)]\tTotal Loss: 2.4886\tAvg Loss: 0.0000\nTrain Epoch: 36\t[55000/88956 (62%)]\tTotal Loss: 2.7476\tAvg Loss: 0.0000\nTrain Epoch: 36\t[60000/88956 (67%)]\tTotal Loss: 2.9981\tAvg Loss: 0.0000\nTrain Epoch: 36\t[65000/88956 (73%)]\tTotal Loss: 3.2530\tAvg Loss: 0.0001\nTrain Epoch: 36\t[70000/88956 (79%)]\tTotal Loss: 3.5209\tAvg Loss: 0.0001\nTrain Epoch: 36\t[75000/88956 (84%)]\tTotal Loss: 3.7773\tAvg Loss: 0.0001\nTrain Epoch: 36\t[80000/88956 (90%)]\tTotal Loss: 4.0338\tAvg Loss: 0.0001\nTrain Epoch: 36\t[85000/88956 (96%)]\tTotal Loss: 4.2764\tAvg Loss: 0.0001\n====> Epoch: 36\tTotal Loss: 4.4848\t Avg Loss: 0.0001\tCorrect: 62260/88956\tPercentage Correct: 69.99\n====> Val Loss: 0.6664\t Avg Loss: 0.0001\tCorrect: 6325/9885\tPercentage Correct: 63.99\n====> Test Loss: 1.6711\t Avg Loss: 0.0001\tCorrect: 15829/24711\tPercentage Correct: 64.06\n\n=== saved best model ===\n\nTrain Epoch: 37\t[5000/88956 (6%)]\tTotal Loss: 0.2458\tAvg Loss: 0.0000\nTrain Epoch: 37\t[10000/88956 (11%)]\tTotal Loss: 0.4980\tAvg Loss: 0.0000\nTrain Epoch: 37\t[15000/88956 (17%)]\tTotal Loss: 0.7194\tAvg Loss: 0.0000\nTrain Epoch: 37\t[20000/88956 (22%)]\tTotal Loss: 0.9638\tAvg Loss: 0.0000\nTrain Epoch: 37\t[25000/88956 (28%)]\tTotal Loss: 1.1971\tAvg Loss: 0.0000\nTrain Epoch: 37\t[30000/88956 (34%)]\tTotal Loss: 1.4413\tAvg Loss: 0.0000\nTrain Epoch: 37\t[35000/88956 (39%)]\tTotal Loss: 1.6799\tAvg Loss: 0.0000\nTrain Epoch: 37\t[40000/88956 (45%)]\tTotal Loss: 1.9211\tAvg Loss: 0.0000\nTrain Epoch: 37\t[45000/88956 (51%)]\tTotal Loss: 2.1835\tAvg Loss: 0.0000\nTrain Epoch: 37\t[50000/88956 (56%)]\tTotal Loss: 2.4332\tAvg Loss: 0.0000\nTrain Epoch: 37\t[55000/88956 (62%)]\tTotal Loss: 2.6999\tAvg Loss: 0.0000\nTrain Epoch: 37\t[60000/88956 (67%)]\tTotal Loss: 2.9804\tAvg Loss: 0.0000\nTrain Epoch: 37\t[65000/88956 (73%)]\tTotal Loss: 3.2409\tAvg Loss: 0.0000\nTrain Epoch: 37\t[70000/88956 (79%)]\tTotal Loss: 3.4839\tAvg Loss: 0.0000\nTrain Epoch: 37\t[75000/88956 (84%)]\tTotal Loss: 3.7267\tAvg Loss: 0.0000\nTrain Epoch: 37\t[80000/88956 (90%)]\tTotal Loss: 3.9699\tAvg Loss: 0.0000\nTrain Epoch: 37\t[85000/88956 (96%)]\tTotal Loss: 4.2283\tAvg Loss: 0.0000\n====> Epoch: 37\tTotal Loss: 4.4379\t Avg Loss: 0.0000\tCorrect: 62365/88956\tPercentage Correct: 70.11\n====> Val Loss: 0.6322\t Avg Loss: 0.0001\tCorrect: 6380/9885\tPercentage Correct: 64.54\n====> Test Loss: 1.5677\t Avg Loss: 0.0001\tCorrect: 15949/24711\tPercentage Correct: 64.54\n\n=== saved best model ===\n\nTrain Epoch: 38\t[5000/88956 (6%)]\tTotal Loss: 0.2254\tAvg Loss: 0.0000\nTrain Epoch: 38\t[10000/88956 (11%)]\tTotal Loss: 0.4597\tAvg Loss: 0.0000\nTrain Epoch: 38\t[15000/88956 (17%)]\tTotal Loss: 0.7045\tAvg Loss: 0.0000\nTrain Epoch: 38\t[20000/88956 (22%)]\tTotal Loss: 0.9450\tAvg Loss: 0.0000\nTrain Epoch: 38\t[25000/88956 (28%)]\tTotal Loss: 1.1926\tAvg Loss: 0.0000\nTrain Epoch: 38\t[30000/88956 (34%)]\tTotal Loss: 1.4425\tAvg Loss: 0.0000\nTrain Epoch: 38\t[35000/88956 (39%)]\tTotal Loss: 1.6929\tAvg Loss: 0.0000\nTrain Epoch: 38\t[40000/88956 (45%)]\tTotal Loss: 1.9403\tAvg Loss: 0.0000\nTrain Epoch: 38\t[45000/88956 (51%)]\tTotal Loss: 2.1877\tAvg Loss: 0.0000\nTrain Epoch: 38\t[50000/88956 (56%)]\tTotal Loss: 2.4372\tAvg Loss: 0.0000\nTrain Epoch: 38\t[55000/88956 (62%)]\tTotal Loss: 2.6868\tAvg Loss: 0.0000\nTrain Epoch: 38\t[60000/88956 (67%)]\tTotal Loss: 2.9373\tAvg Loss: 0.0000\nTrain Epoch: 38\t[65000/88956 (73%)]\tTotal Loss: 3.1765\tAvg Loss: 0.0000\nTrain Epoch: 38\t[70000/88956 (79%)]\tTotal Loss: 3.4184\tAvg Loss: 0.0000\nTrain Epoch: 38\t[75000/88956 (84%)]\tTotal Loss: 3.6689\tAvg Loss: 0.0000\nTrain Epoch: 38\t[80000/88956 (90%)]\tTotal Loss: 3.9216\tAvg Loss: 0.0000\nTrain Epoch: 38\t[85000/88956 (96%)]\tTotal Loss: 4.1663\tAvg Loss: 0.0000\n====> Epoch: 38\tTotal Loss: 4.3583\t Avg Loss: 0.0000\tCorrect: 62843/88956\tPercentage Correct: 70.65\n====> Val Loss: 0.6734\t Avg Loss: 0.0001\tCorrect: 6248/9885\tPercentage Correct: 63.21\n====> Test Loss: 1.6548\t Avg Loss: 0.0001\tCorrect: 15755/24711\tPercentage Correct: 63.76\nTrain Epoch: 39\t[5000/88956 (6%)]\tTotal Loss: 0.2411\tAvg Loss: 0.0000\nTrain Epoch: 39\t[10000/88956 (11%)]\tTotal Loss: 0.4730\tAvg Loss: 0.0000\nTrain Epoch: 39\t[15000/88956 (17%)]\tTotal Loss: 0.6981\tAvg Loss: 0.0000\nTrain Epoch: 39\t[20000/88956 (22%)]\tTotal Loss: 0.9238\tAvg Loss: 0.0000\nTrain Epoch: 39\t[25000/88956 (28%)]\tTotal Loss: 1.1602\tAvg Loss: 0.0000\nTrain Epoch: 39\t[30000/88956 (34%)]\tTotal Loss: 1.4723\tAvg Loss: 0.0000\nTrain Epoch: 39\t[35000/88956 (39%)]\tTotal Loss: 1.7496\tAvg Loss: 0.0000\nTrain Epoch: 39\t[40000/88956 (45%)]\tTotal Loss: 2.0096\tAvg Loss: 0.0001\nTrain Epoch: 39\t[45000/88956 (51%)]\tTotal Loss: 2.2569\tAvg Loss: 0.0001\nTrain Epoch: 39\t[50000/88956 (56%)]\tTotal Loss: 2.4949\tAvg Loss: 0.0000\nTrain Epoch: 39\t[55000/88956 (62%)]\tTotal Loss: 2.7197\tAvg Loss: 0.0000\nTrain Epoch: 39\t[60000/88956 (67%)]\tTotal Loss: 2.9630\tAvg Loss: 0.0000\nTrain Epoch: 39\t[65000/88956 (73%)]\tTotal Loss: 3.1959\tAvg Loss: 0.0000\nTrain Epoch: 39\t[70000/88956 (79%)]\tTotal Loss: 3.4379\tAvg Loss: 0.0000\nTrain Epoch: 39\t[75000/88956 (84%)]\tTotal Loss: 3.6793\tAvg Loss: 0.0000\nTrain Epoch: 39\t[80000/88956 (90%)]\tTotal Loss: 3.9233\tAvg Loss: 0.0000\nTrain Epoch: 39\t[85000/88956 (96%)]\tTotal Loss: 4.1751\tAvg Loss: 0.0000\n====> Epoch: 39\tTotal Loss: 4.3669\t Avg Loss: 0.0000\tCorrect: 62824/88956\tPercentage Correct: 70.62\n====> Val Loss: 0.6597\t Avg Loss: 0.0001\tCorrect: 6301/9885\tPercentage Correct: 63.74\n====> Test Loss: 1.5935\t Avg Loss: 0.0001\tCorrect: 15850/24711\tPercentage Correct: 64.14\nTrain Epoch: 40\t[5000/88956 (6%)]\tTotal Loss: 0.2302\tAvg Loss: 0.0000\nTrain Epoch: 40\t[10000/88956 (11%)]\tTotal Loss: 0.4587\tAvg Loss: 0.0000\nTrain Epoch: 40\t[15000/88956 (17%)]\tTotal Loss: 0.6836\tAvg Loss: 0.0000\nTrain Epoch: 40\t[20000/88956 (22%)]\tTotal Loss: 0.9244\tAvg Loss: 0.0000\nTrain Epoch: 40\t[25000/88956 (28%)]\tTotal Loss: 1.1631\tAvg Loss: 0.0000\nTrain Epoch: 40\t[30000/88956 (34%)]\tTotal Loss: 1.3889\tAvg Loss: 0.0000\nTrain Epoch: 40\t[35000/88956 (39%)]\tTotal Loss: 1.6191\tAvg Loss: 0.0000\nTrain Epoch: 40\t[40000/88956 (45%)]\tTotal Loss: 1.8594\tAvg Loss: 0.0000\nTrain Epoch: 40\t[45000/88956 (51%)]\tTotal Loss: 2.0846\tAvg Loss: 0.0000\nTrain Epoch: 40\t[50000/88956 (56%)]\tTotal Loss: 2.3329\tAvg Loss: 0.0000\nTrain Epoch: 40\t[55000/88956 (62%)]\tTotal Loss: 2.5796\tAvg Loss: 0.0000\nTrain Epoch: 40\t[60000/88956 (67%)]\tTotal Loss: 2.8138\tAvg Loss: 0.0000\nTrain Epoch: 40\t[65000/88956 (73%)]\tTotal Loss: 3.0363\tAvg Loss: 0.0000\nTrain Epoch: 40\t[70000/88956 (79%)]\tTotal Loss: 3.2768\tAvg Loss: 0.0000\nTrain Epoch: 40\t[75000/88956 (84%)]\tTotal Loss: 3.5059\tAvg Loss: 0.0000\nTrain Epoch: 40\t[80000/88956 (90%)]\tTotal Loss: 3.7270\tAvg Loss: 0.0000\nTrain Epoch: 40\t[85000/88956 (96%)]\tTotal Loss: 3.9666\tAvg Loss: 0.0000\n====> Epoch: 40\tTotal Loss: 4.1468\t Avg Loss: 0.0000\tCorrect: 63985/88956\tPercentage Correct: 71.93\n====> Val Loss: 0.6079\t Avg Loss: 0.0001\tCorrect: 6543/9885\tPercentage Correct: 66.19\n====> Test Loss: 1.4701\t Avg Loss: 0.0001\tCorrect: 16365/24711\tPercentage Correct: 66.23\n\n=== saved best model ===\n\nTrain Epoch: 41\t[5000/88956 (6%)]\tTotal Loss: 0.2189\tAvg Loss: 0.0000\nTrain Epoch: 41\t[10000/88956 (11%)]\tTotal Loss: 0.4267\tAvg Loss: 0.0000\nTrain Epoch: 41\t[15000/88956 (17%)]\tTotal Loss: 0.6431\tAvg Loss: 0.0000\nTrain Epoch: 41\t[20000/88956 (22%)]\tTotal Loss: 0.8664\tAvg Loss: 0.0000\nTrain Epoch: 41\t[25000/88956 (28%)]\tTotal Loss: 1.0943\tAvg Loss: 0.0000\nTrain Epoch: 41\t[30000/88956 (34%)]\tTotal Loss: 1.3299\tAvg Loss: 0.0000\nTrain Epoch: 41\t[35000/88956 (39%)]\tTotal Loss: 1.5626\tAvg Loss: 0.0000\nTrain Epoch: 41\t[40000/88956 (45%)]\tTotal Loss: 1.7802\tAvg Loss: 0.0000\nTrain Epoch: 41\t[45000/88956 (51%)]\tTotal Loss: 2.0378\tAvg Loss: 0.0000\nTrain Epoch: 41\t[50000/88956 (56%)]\tTotal Loss: 2.2790\tAvg Loss: 0.0000\nTrain Epoch: 41\t[55000/88956 (62%)]\tTotal Loss: 2.5157\tAvg Loss: 0.0000\nTrain Epoch: 41\t[60000/88956 (67%)]\tTotal Loss: 2.7317\tAvg Loss: 0.0000\nTrain Epoch: 41\t[65000/88956 (73%)]\tTotal Loss: 2.9459\tAvg Loss: 0.0000\nTrain Epoch: 41\t[70000/88956 (79%)]\tTotal Loss: 3.1912\tAvg Loss: 0.0000\nTrain Epoch: 41\t[75000/88956 (84%)]\tTotal Loss: 3.4379\tAvg Loss: 0.0000\nTrain Epoch: 41\t[80000/88956 (90%)]\tTotal Loss: 3.6719\tAvg Loss: 0.0000\nTrain Epoch: 41\t[85000/88956 (96%)]\tTotal Loss: 3.9084\tAvg Loss: 0.0000\n====> Epoch: 41\tTotal Loss: 4.0977\t Avg Loss: 0.0000\tCorrect: 64213/88956\tPercentage Correct: 72.19\n====> Val Loss: 0.6462\t Avg Loss: 0.0001\tCorrect: 6273/9885\tPercentage Correct: 63.46\n====> Test Loss: 1.5748\t Avg Loss: 0.0001\tCorrect: 15810/24711\tPercentage Correct: 63.98\nTrain Epoch: 42\t[5000/88956 (6%)]\tTotal Loss: 0.2317\tAvg Loss: 0.0000\nTrain Epoch: 42\t[10000/88956 (11%)]\tTotal Loss: 0.4689\tAvg Loss: 0.0000\nTrain Epoch: 42\t[15000/88956 (17%)]\tTotal Loss: 0.6852\tAvg Loss: 0.0000\nTrain Epoch: 42\t[20000/88956 (22%)]\tTotal Loss: 0.8994\tAvg Loss: 0.0000\nTrain Epoch: 42\t[25000/88956 (28%)]\tTotal Loss: 1.1316\tAvg Loss: 0.0000\nTrain Epoch: 42\t[30000/88956 (34%)]\tTotal Loss: 1.3537\tAvg Loss: 0.0000\nTrain Epoch: 42\t[35000/88956 (39%)]\tTotal Loss: 1.5847\tAvg Loss: 0.0000\nTrain Epoch: 42\t[40000/88956 (45%)]\tTotal Loss: 1.8063\tAvg Loss: 0.0000\nTrain Epoch: 42\t[45000/88956 (51%)]\tTotal Loss: 2.0403\tAvg Loss: 0.0000\nTrain Epoch: 42\t[50000/88956 (56%)]\tTotal Loss: 2.2704\tAvg Loss: 0.0000\nTrain Epoch: 42\t[55000/88956 (62%)]\tTotal Loss: 2.5164\tAvg Loss: 0.0000\nTrain Epoch: 42\t[60000/88956 (67%)]\tTotal Loss: 2.7415\tAvg Loss: 0.0000\nTrain Epoch: 42\t[65000/88956 (73%)]\tTotal Loss: 2.9628\tAvg Loss: 0.0000\nTrain Epoch: 42\t[70000/88956 (79%)]\tTotal Loss: 3.2077\tAvg Loss: 0.0000\nTrain Epoch: 42\t[75000/88956 (84%)]\tTotal Loss: 3.4480\tAvg Loss: 0.0000\nTrain Epoch: 42\t[80000/88956 (90%)]\tTotal Loss: 3.6803\tAvg Loss: 0.0000\nTrain Epoch: 42\t[85000/88956 (96%)]\tTotal Loss: 3.9081\tAvg Loss: 0.0000\n====> Epoch: 42\tTotal Loss: 4.0915\t Avg Loss: 0.0000\tCorrect: 64348/88956\tPercentage Correct: 72.34\n====> Val Loss: 0.6336\t Avg Loss: 0.0001\tCorrect: 6537/9885\tPercentage Correct: 66.13\n====> Test Loss: 1.5483\t Avg Loss: 0.0001\tCorrect: 16292/24711\tPercentage Correct: 65.93\nTrain Epoch: 43\t[5000/88956 (6%)]\tTotal Loss: 0.2278\tAvg Loss: 0.0000\nTrain Epoch: 43\t[10000/88956 (11%)]\tTotal Loss: 0.4582\tAvg Loss: 0.0000\nTrain Epoch: 43\t[15000/88956 (17%)]\tTotal Loss: 0.6779\tAvg Loss: 0.0000\nTrain Epoch: 43\t[20000/88956 (22%)]\tTotal Loss: 0.8915\tAvg Loss: 0.0000\nTrain Epoch: 43\t[25000/88956 (28%)]\tTotal Loss: 1.1040\tAvg Loss: 0.0000\nTrain Epoch: 43\t[30000/88956 (34%)]\tTotal Loss: 1.3233\tAvg Loss: 0.0000\nTrain Epoch: 43\t[35000/88956 (39%)]\tTotal Loss: 1.5352\tAvg Loss: 0.0000\nTrain Epoch: 43\t[40000/88956 (45%)]\tTotal Loss: 1.7643\tAvg Loss: 0.0000\nTrain Epoch: 43\t[45000/88956 (51%)]\tTotal Loss: 1.9874\tAvg Loss: 0.0000\nTrain Epoch: 43\t[50000/88956 (56%)]\tTotal Loss: 2.2219\tAvg Loss: 0.0000\nTrain Epoch: 43\t[55000/88956 (62%)]\tTotal Loss: 2.4760\tAvg Loss: 0.0000\nTrain Epoch: 43\t[60000/88956 (67%)]\tTotal Loss: 2.7210\tAvg Loss: 0.0000\nTrain Epoch: 43\t[65000/88956 (73%)]\tTotal Loss: 2.9479\tAvg Loss: 0.0000\nTrain Epoch: 43\t[70000/88956 (79%)]\tTotal Loss: 3.1778\tAvg Loss: 0.0000\nTrain Epoch: 43\t[75000/88956 (84%)]\tTotal Loss: 3.4166\tAvg Loss: 0.0000\nTrain Epoch: 43\t[80000/88956 (90%)]\tTotal Loss: 3.6569\tAvg Loss: 0.0000\nTrain Epoch: 43\t[85000/88956 (96%)]\tTotal Loss: 3.8856\tAvg Loss: 0.0000\n====> Epoch: 43\tTotal Loss: 4.0613\t Avg Loss: 0.0000\tCorrect: 64286/88956\tPercentage Correct: 72.27\n====> Val Loss: 0.6107\t Avg Loss: 0.0001\tCorrect: 6447/9885\tPercentage Correct: 65.22\n====> Test Loss: 1.4657\t Avg Loss: 0.0001\tCorrect: 16316/24711\tPercentage Correct: 66.03\nTrain Epoch: 44\t[5000/88956 (6%)]\tTotal Loss: 0.2244\tAvg Loss: 0.0000\nTrain Epoch: 44\t[10000/88956 (11%)]\tTotal Loss: 0.4462\tAvg Loss: 0.0000\nTrain Epoch: 44\t[15000/88956 (17%)]\tTotal Loss: 0.6585\tAvg Loss: 0.0000\nTrain Epoch: 44\t[20000/88956 (22%)]\tTotal Loss: 0.8857\tAvg Loss: 0.0000\nTrain Epoch: 44\t[25000/88956 (28%)]\tTotal Loss: 1.0989\tAvg Loss: 0.0000\nTrain Epoch: 44\t[30000/88956 (34%)]\tTotal Loss: 1.3109\tAvg Loss: 0.0000\nTrain Epoch: 44\t[35000/88956 (39%)]\tTotal Loss: 1.5231\tAvg Loss: 0.0000\nTrain Epoch: 44\t[40000/88956 (45%)]\tTotal Loss: 1.7573\tAvg Loss: 0.0000\nTrain Epoch: 44\t[45000/88956 (51%)]\tTotal Loss: 1.9841\tAvg Loss: 0.0000\nTrain Epoch: 44\t[50000/88956 (56%)]\tTotal Loss: 2.2031\tAvg Loss: 0.0000\nTrain Epoch: 44\t[55000/88956 (62%)]\tTotal Loss: 2.4173\tAvg Loss: 0.0000\nTrain Epoch: 44\t[60000/88956 (67%)]\tTotal Loss: 2.6512\tAvg Loss: 0.0000\nTrain Epoch: 44\t[65000/88956 (73%)]\tTotal Loss: 2.8748\tAvg Loss: 0.0000\nTrain Epoch: 44\t[70000/88956 (79%)]\tTotal Loss: 3.0924\tAvg Loss: 0.0000\nTrain Epoch: 44\t[75000/88956 (84%)]\tTotal Loss: 3.3178\tAvg Loss: 0.0000\nTrain Epoch: 44\t[80000/88956 (90%)]\tTotal Loss: 3.5487\tAvg Loss: 0.0000\nTrain Epoch: 44\t[85000/88956 (96%)]\tTotal Loss: 3.7845\tAvg Loss: 0.0000\n====> Epoch: 44\tTotal Loss: 3.9721\t Avg Loss: 0.0000\tCorrect: 64834/88956\tPercentage Correct: 72.88\n====> Val Loss: 0.6023\t Avg Loss: 0.0001\tCorrect: 6534/9885\tPercentage Correct: 66.10\n====> Test Loss: 1.4468\t Avg Loss: 0.0001\tCorrect: 16347/24711\tPercentage Correct: 66.15\nTrain Epoch: 45\t[5000/88956 (6%)]\tTotal Loss: 0.2164\tAvg Loss: 0.0000\nTrain Epoch: 45\t[10000/88956 (11%)]\tTotal Loss: 0.4357\tAvg Loss: 0.0000\nTrain Epoch: 45\t[15000/88956 (17%)]\tTotal Loss: 0.6536\tAvg Loss: 0.0000\nTrain Epoch: 45\t[20000/88956 (22%)]\tTotal Loss: 0.8644\tAvg Loss: 0.0000\nTrain Epoch: 45\t[25000/88956 (28%)]\tTotal Loss: 1.0881\tAvg Loss: 0.0000\nTrain Epoch: 45\t[30000/88956 (34%)]\tTotal Loss: 1.3337\tAvg Loss: 0.0000\nTrain Epoch: 45\t[35000/88956 (39%)]\tTotal Loss: 1.5538\tAvg Loss: 0.0000\nTrain Epoch: 45\t[40000/88956 (45%)]\tTotal Loss: 1.7643\tAvg Loss: 0.0000\nTrain Epoch: 45\t[45000/88956 (51%)]\tTotal Loss: 1.9828\tAvg Loss: 0.0000\nTrain Epoch: 45\t[50000/88956 (56%)]\tTotal Loss: 2.2185\tAvg Loss: 0.0000\nTrain Epoch: 45\t[55000/88956 (62%)]\tTotal Loss: 2.4409\tAvg Loss: 0.0000\nTrain Epoch: 45\t[60000/88956 (67%)]\tTotal Loss: 2.6634\tAvg Loss: 0.0000\nTrain Epoch: 45\t[65000/88956 (73%)]\tTotal Loss: 2.8906\tAvg Loss: 0.0000\nTrain Epoch: 45\t[70000/88956 (79%)]\tTotal Loss: 3.1230\tAvg Loss: 0.0000\nTrain Epoch: 45\t[75000/88956 (84%)]\tTotal Loss: 3.3335\tAvg Loss: 0.0000\nTrain Epoch: 45\t[80000/88956 (90%)]\tTotal Loss: 3.5465\tAvg Loss: 0.0000\nTrain Epoch: 45\t[85000/88956 (96%)]\tTotal Loss: 3.7635\tAvg Loss: 0.0000\n====> Epoch: 45\tTotal Loss: 3.9342\t Avg Loss: 0.0000\tCorrect: 64978/88956\tPercentage Correct: 73.05\n====> Val Loss: 0.5804\t Avg Loss: 0.0001\tCorrect: 6592/9885\tPercentage Correct: 66.69\n====> Test Loss: 1.4051\t Avg Loss: 0.0001\tCorrect: 16597/24711\tPercentage Correct: 67.16\n\n=== saved best model ===\n\nTrain Epoch: 46\t[5000/88956 (6%)]\tTotal Loss: 0.2118\tAvg Loss: 0.0000\nTrain Epoch: 46\t[10000/88956 (11%)]\tTotal Loss: 0.4254\tAvg Loss: 0.0000\nTrain Epoch: 46\t[15000/88956 (17%)]\tTotal Loss: 0.6372\tAvg Loss: 0.0000\nTrain Epoch: 46\t[20000/88956 (22%)]\tTotal Loss: 0.8358\tAvg Loss: 0.0000\nTrain Epoch: 46\t[25000/88956 (28%)]\tTotal Loss: 1.0705\tAvg Loss: 0.0000\nTrain Epoch: 46\t[30000/88956 (34%)]\tTotal Loss: 1.2681\tAvg Loss: 0.0000\nTrain Epoch: 46\t[35000/88956 (39%)]\tTotal Loss: 1.4672\tAvg Loss: 0.0000\nTrain Epoch: 46\t[40000/88956 (45%)]\tTotal Loss: 1.6709\tAvg Loss: 0.0000\nTrain Epoch: 46\t[45000/88956 (51%)]\tTotal Loss: 1.8897\tAvg Loss: 0.0000\nTrain Epoch: 46\t[50000/88956 (56%)]\tTotal Loss: 2.1086\tAvg Loss: 0.0000\nTrain Epoch: 46\t[55000/88956 (62%)]\tTotal Loss: 2.3359\tAvg Loss: 0.0000\nTrain Epoch: 46\t[60000/88956 (67%)]\tTotal Loss: 2.5561\tAvg Loss: 0.0000\nTrain Epoch: 46\t[65000/88956 (73%)]\tTotal Loss: 2.7785\tAvg Loss: 0.0000\nTrain Epoch: 46\t[70000/88956 (79%)]\tTotal Loss: 3.0050\tAvg Loss: 0.0000\nTrain Epoch: 46\t[75000/88956 (84%)]\tTotal Loss: 3.2257\tAvg Loss: 0.0000\nTrain Epoch: 46\t[80000/88956 (90%)]\tTotal Loss: 3.4466\tAvg Loss: 0.0000\nTrain Epoch: 46\t[85000/88956 (96%)]\tTotal Loss: 3.6624\tAvg Loss: 0.0000\n====> Epoch: 46\tTotal Loss: 3.8376\t Avg Loss: 0.0000\tCorrect: 65288/88956\tPercentage Correct: 73.39\n====> Val Loss: 0.6389\t Avg Loss: 0.0001\tCorrect: 6460/9885\tPercentage Correct: 65.35\n====> Test Loss: 1.5784\t Avg Loss: 0.0001\tCorrect: 16101/24711\tPercentage Correct: 65.16\nTrain Epoch: 47\t[5000/88956 (6%)]\tTotal Loss: 0.2392\tAvg Loss: 0.0000\nTrain Epoch: 47\t[10000/88956 (11%)]\tTotal Loss: 0.4474\tAvg Loss: 0.0000\nTrain Epoch: 47\t[15000/88956 (17%)]\tTotal Loss: 0.6627\tAvg Loss: 0.0000\nTrain Epoch: 47\t[20000/88956 (22%)]\tTotal Loss: 0.8881\tAvg Loss: 0.0000\nTrain Epoch: 47\t[25000/88956 (28%)]\tTotal Loss: 1.0779\tAvg Loss: 0.0000\nTrain Epoch: 47\t[30000/88956 (34%)]\tTotal Loss: 1.2888\tAvg Loss: 0.0000\nTrain Epoch: 47\t[35000/88956 (39%)]\tTotal Loss: 1.4925\tAvg Loss: 0.0000\nTrain Epoch: 47\t[40000/88956 (45%)]\tTotal Loss: 1.6880\tAvg Loss: 0.0000\nTrain Epoch: 47\t[45000/88956 (51%)]\tTotal Loss: 1.8931\tAvg Loss: 0.0000\nTrain Epoch: 47\t[50000/88956 (56%)]\tTotal Loss: 2.1088\tAvg Loss: 0.0000\nTrain Epoch: 47\t[55000/88956 (62%)]\tTotal Loss: 2.3279\tAvg Loss: 0.0000\nTrain Epoch: 47\t[60000/88956 (67%)]\tTotal Loss: 2.5436\tAvg Loss: 0.0000\nTrain Epoch: 47\t[65000/88956 (73%)]\tTotal Loss: 2.7568\tAvg Loss: 0.0000\nTrain Epoch: 47\t[70000/88956 (79%)]\tTotal Loss: 2.9793\tAvg Loss: 0.0000\nTrain Epoch: 47\t[75000/88956 (84%)]\tTotal Loss: 3.2070\tAvg Loss: 0.0000\nTrain Epoch: 47\t[80000/88956 (90%)]\tTotal Loss: 3.4361\tAvg Loss: 0.0000\nTrain Epoch: 47\t[85000/88956 (96%)]\tTotal Loss: 3.6642\tAvg Loss: 0.0000\n====> Epoch: 47\tTotal Loss: 3.8295\t Avg Loss: 0.0000\tCorrect: 65103/88956\tPercentage Correct: 73.19\n====> Val Loss: 0.6225\t Avg Loss: 0.0001\tCorrect: 6513/9885\tPercentage Correct: 65.89\n====> Test Loss: 1.4947\t Avg Loss: 0.0001\tCorrect: 16344/24711\tPercentage Correct: 66.14\nTrain Epoch: 48\t[5000/88956 (6%)]\tTotal Loss: 0.2064\tAvg Loss: 0.0000\nTrain Epoch: 48\t[10000/88956 (11%)]\tTotal Loss: 0.4103\tAvg Loss: 0.0000\nTrain Epoch: 48\t[15000/88956 (17%)]\tTotal Loss: 0.6141\tAvg Loss: 0.0000\nTrain Epoch: 48\t[20000/88956 (22%)]\tTotal Loss: 0.8301\tAvg Loss: 0.0000\nTrain Epoch: 48\t[25000/88956 (28%)]\tTotal Loss: 1.0400\tAvg Loss: 0.0000\nTrain Epoch: 48\t[30000/88956 (34%)]\tTotal Loss: 1.2428\tAvg Loss: 0.0000\nTrain Epoch: 48\t[35000/88956 (39%)]\tTotal Loss: 1.4770\tAvg Loss: 0.0000\nTrain Epoch: 48\t[40000/88956 (45%)]\tTotal Loss: 1.6843\tAvg Loss: 0.0000\nTrain Epoch: 48\t[45000/88956 (51%)]\tTotal Loss: 1.8703\tAvg Loss: 0.0000\nTrain Epoch: 48\t[50000/88956 (56%)]\tTotal Loss: 2.0753\tAvg Loss: 0.0000\nTrain Epoch: 48\t[55000/88956 (62%)]\tTotal Loss: 2.2935\tAvg Loss: 0.0000\nTrain Epoch: 48\t[60000/88956 (67%)]\tTotal Loss: 2.5099\tAvg Loss: 0.0000\nTrain Epoch: 48\t[65000/88956 (73%)]\tTotal Loss: 2.7381\tAvg Loss: 0.0000\nTrain Epoch: 48\t[70000/88956 (79%)]\tTotal Loss: 2.9560\tAvg Loss: 0.0000\nTrain Epoch: 48\t[75000/88956 (84%)]\tTotal Loss: 3.1613\tAvg Loss: 0.0000\nTrain Epoch: 48\t[80000/88956 (90%)]\tTotal Loss: 3.3660\tAvg Loss: 0.0000\nTrain Epoch: 48\t[85000/88956 (96%)]\tTotal Loss: 3.6086\tAvg Loss: 0.0000\n====> Epoch: 48\tTotal Loss: 3.7756\t Avg Loss: 0.0000\tCorrect: 65512/88956\tPercentage Correct: 73.65\n====> Val Loss: 0.5973\t Avg Loss: 0.0001\tCorrect: 6550/9885\tPercentage Correct: 66.26\n====> Test Loss: 1.4591\t Avg Loss: 0.0001\tCorrect: 16445/24711\tPercentage Correct: 66.55\nTrain Epoch: 49\t[5000/88956 (6%)]\tTotal Loss: 0.2013\tAvg Loss: 0.0000\nTrain Epoch: 49\t[10000/88956 (11%)]\tTotal Loss: 0.4017\tAvg Loss: 0.0000\nTrain Epoch: 49\t[15000/88956 (17%)]\tTotal Loss: 0.6200\tAvg Loss: 0.0000\nTrain Epoch: 49\t[20000/88956 (22%)]\tTotal Loss: 0.8291\tAvg Loss: 0.0000\nTrain Epoch: 49\t[25000/88956 (28%)]\tTotal Loss: 1.0224\tAvg Loss: 0.0000\nTrain Epoch: 49\t[30000/88956 (34%)]\tTotal Loss: 1.2123\tAvg Loss: 0.0000\nTrain Epoch: 49\t[35000/88956 (39%)]\tTotal Loss: 1.4260\tAvg Loss: 0.0000\nTrain Epoch: 49\t[40000/88956 (45%)]\tTotal Loss: 1.6338\tAvg Loss: 0.0000\nTrain Epoch: 49\t[45000/88956 (51%)]\tTotal Loss: 1.8434\tAvg Loss: 0.0000\nTrain Epoch: 49\t[50000/88956 (56%)]\tTotal Loss: 2.0697\tAvg Loss: 0.0000\nTrain Epoch: 49\t[55000/88956 (62%)]\tTotal Loss: 2.2769\tAvg Loss: 0.0000\nTrain Epoch: 49\t[60000/88956 (67%)]\tTotal Loss: 2.4917\tAvg Loss: 0.0000\nTrain Epoch: 49\t[65000/88956 (73%)]\tTotal Loss: 2.7015\tAvg Loss: 0.0000\nTrain Epoch: 49\t[70000/88956 (79%)]\tTotal Loss: 2.8975\tAvg Loss: 0.0000\nTrain Epoch: 49\t[75000/88956 (84%)]\tTotal Loss: 3.0933\tAvg Loss: 0.0000\nTrain Epoch: 49\t[80000/88956 (90%)]\tTotal Loss: 3.3067\tAvg Loss: 0.0000\nTrain Epoch: 49\t[85000/88956 (96%)]\tTotal Loss: 3.5233\tAvg Loss: 0.0000\n====> Epoch: 49\tTotal Loss: 3.6998\t Avg Loss: 0.0000\tCorrect: 66066/88956\tPercentage Correct: 74.27\n====> Val Loss: 0.5792\t Avg Loss: 0.0001\tCorrect: 6669/9885\tPercentage Correct: 67.47\n====> Test Loss: 1.4253\t Avg Loss: 0.0001\tCorrect: 16716/24711\tPercentage Correct: 67.65\n\n=== saved best model ===\n\nTrain Epoch: 50\t[5000/88956 (6%)]\tTotal Loss: 0.2106\tAvg Loss: 0.0000\nTrain Epoch: 50\t[10000/88956 (11%)]\tTotal Loss: 0.4014\tAvg Loss: 0.0000\nTrain Epoch: 50\t[15000/88956 (17%)]\tTotal Loss: 0.6024\tAvg Loss: 0.0000\nTrain Epoch: 50\t[20000/88956 (22%)]\tTotal Loss: 0.7838\tAvg Loss: 0.0000\nTrain Epoch: 50\t[25000/88956 (28%)]\tTotal Loss: 0.9706\tAvg Loss: 0.0000\nTrain Epoch: 50\t[30000/88956 (34%)]\tTotal Loss: 1.1766\tAvg Loss: 0.0000\nTrain Epoch: 50\t[35000/88956 (39%)]\tTotal Loss: 1.3785\tAvg Loss: 0.0000\nTrain Epoch: 50\t[40000/88956 (45%)]\tTotal Loss: 1.5801\tAvg Loss: 0.0000\nTrain Epoch: 50\t[45000/88956 (51%)]\tTotal Loss: 1.8011\tAvg Loss: 0.0000\nTrain Epoch: 50\t[50000/88956 (56%)]\tTotal Loss: 2.0003\tAvg Loss: 0.0000\nTrain Epoch: 50\t[55000/88956 (62%)]\tTotal Loss: 2.2144\tAvg Loss: 0.0000\nTrain Epoch: 50\t[60000/88956 (67%)]\tTotal Loss: 2.4274\tAvg Loss: 0.0000\nTrain Epoch: 50\t[65000/88956 (73%)]\tTotal Loss: 2.6406\tAvg Loss: 0.0000\nTrain Epoch: 50\t[70000/88956 (79%)]\tTotal Loss: 2.8536\tAvg Loss: 0.0000\nTrain Epoch: 50\t[75000/88956 (84%)]\tTotal Loss: 3.0650\tAvg Loss: 0.0000\nTrain Epoch: 50\t[80000/88956 (90%)]\tTotal Loss: 3.2711\tAvg Loss: 0.0000\nTrain Epoch: 50\t[85000/88956 (96%)]\tTotal Loss: 3.4768\tAvg Loss: 0.0000\n====> Epoch: 50\tTotal Loss: 3.6304\t Avg Loss: 0.0000\tCorrect: 66440/88956\tPercentage Correct: 74.69\n====> Val Loss: 0.5813\t Avg Loss: 0.0001\tCorrect: 6567/9885\tPercentage Correct: 66.43\n====> Test Loss: 1.4502\t Avg Loss: 0.0001\tCorrect: 16382/24711\tPercentage Correct: 66.29\nTrain Epoch: 51\t[5000/88956 (6%)]\tTotal Loss: 0.2027\tAvg Loss: 0.0000\nTrain Epoch: 51\t[10000/88956 (11%)]\tTotal Loss: 0.3963\tAvg Loss: 0.0000\nTrain Epoch: 51\t[15000/88956 (17%)]\tTotal Loss: 0.5839\tAvg Loss: 0.0000\nTrain Epoch: 51\t[20000/88956 (22%)]\tTotal Loss: 0.7643\tAvg Loss: 0.0000\nTrain Epoch: 51\t[25000/88956 (28%)]\tTotal Loss: 0.9588\tAvg Loss: 0.0000\nTrain Epoch: 51\t[30000/88956 (34%)]\tTotal Loss: 1.1440\tAvg Loss: 0.0000\nTrain Epoch: 51\t[35000/88956 (39%)]\tTotal Loss: 1.3550\tAvg Loss: 0.0000\nTrain Epoch: 51\t[40000/88956 (45%)]\tTotal Loss: 1.5403\tAvg Loss: 0.0000\nTrain Epoch: 51\t[45000/88956 (51%)]\tTotal Loss: 1.7457\tAvg Loss: 0.0000\nTrain Epoch: 51\t[50000/88956 (56%)]\tTotal Loss: 1.9489\tAvg Loss: 0.0000\nTrain Epoch: 51\t[55000/88956 (62%)]\tTotal Loss: 2.1560\tAvg Loss: 0.0000\nTrain Epoch: 51\t[60000/88956 (67%)]\tTotal Loss: 2.3545\tAvg Loss: 0.0000\nTrain Epoch: 51\t[65000/88956 (73%)]\tTotal Loss: 2.5642\tAvg Loss: 0.0000\nTrain Epoch: 51\t[70000/88956 (79%)]\tTotal Loss: 2.7809\tAvg Loss: 0.0000\nTrain Epoch: 51\t[75000/88956 (84%)]\tTotal Loss: 2.9880\tAvg Loss: 0.0000\nTrain Epoch: 51\t[80000/88956 (90%)]\tTotal Loss: 3.2054\tAvg Loss: 0.0000\nTrain Epoch: 51\t[85000/88956 (96%)]\tTotal Loss: 3.4181\tAvg Loss: 0.0000\n====> Epoch: 51\tTotal Loss: 3.5815\t Avg Loss: 0.0000\tCorrect: 66574/88956\tPercentage Correct: 74.84\n====> Val Loss: 0.6213\t Avg Loss: 0.0001\tCorrect: 6553/9885\tPercentage Correct: 66.29\n====> Test Loss: 1.4904\t Avg Loss: 0.0001\tCorrect: 16478/24711\tPercentage Correct: 66.68\nTrain Epoch: 52\t[5000/88956 (6%)]\tTotal Loss: 0.1987\tAvg Loss: 0.0000\nTrain Epoch: 52\t[10000/88956 (11%)]\tTotal Loss: 0.3982\tAvg Loss: 0.0000\nTrain Epoch: 52\t[15000/88956 (17%)]\tTotal Loss: 0.5808\tAvg Loss: 0.0000\nTrain Epoch: 52\t[20000/88956 (22%)]\tTotal Loss: 0.7875\tAvg Loss: 0.0000\nTrain Epoch: 52\t[25000/88956 (28%)]\tTotal Loss: 0.9820\tAvg Loss: 0.0000\nTrain Epoch: 52\t[30000/88956 (34%)]\tTotal Loss: 1.1651\tAvg Loss: 0.0000\nTrain Epoch: 52\t[35000/88956 (39%)]\tTotal Loss: 1.3550\tAvg Loss: 0.0000\nTrain Epoch: 52\t[40000/88956 (45%)]\tTotal Loss: 1.5526\tAvg Loss: 0.0000\nTrain Epoch: 52\t[45000/88956 (51%)]\tTotal Loss: 1.7469\tAvg Loss: 0.0000\nTrain Epoch: 52\t[50000/88956 (56%)]\tTotal Loss: 1.9491\tAvg Loss: 0.0000\nTrain Epoch: 52\t[55000/88956 (62%)]\tTotal Loss: 2.1412\tAvg Loss: 0.0000\nTrain Epoch: 52\t[60000/88956 (67%)]\tTotal Loss: 2.3432\tAvg Loss: 0.0000\nTrain Epoch: 52\t[65000/88956 (73%)]\tTotal Loss: 2.5388\tAvg Loss: 0.0000\nTrain Epoch: 52\t[70000/88956 (79%)]\tTotal Loss: 2.7443\tAvg Loss: 0.0000\nTrain Epoch: 52\t[75000/88956 (84%)]\tTotal Loss: 2.9598\tAvg Loss: 0.0000\nTrain Epoch: 52\t[80000/88956 (90%)]\tTotal Loss: 3.1692\tAvg Loss: 0.0000\nTrain Epoch: 52\t[85000/88956 (96%)]\tTotal Loss: 3.3717\tAvg Loss: 0.0000\n====> Epoch: 52\tTotal Loss: 3.5253\t Avg Loss: 0.0000\tCorrect: 66885/88956\tPercentage Correct: 75.19\n====> Val Loss: 0.5978\t Avg Loss: 0.0001\tCorrect: 6557/9885\tPercentage Correct: 66.33\n====> Test Loss: 1.5083\t Avg Loss: 0.0001\tCorrect: 16417/24711\tPercentage Correct: 66.44\nTrain Epoch: 53\t[5000/88956 (6%)]\tTotal Loss: 0.1977\tAvg Loss: 0.0000\nTrain Epoch: 53\t[10000/88956 (11%)]\tTotal Loss: 0.3857\tAvg Loss: 0.0000\nTrain Epoch: 53\t[15000/88956 (17%)]\tTotal Loss: 0.5643\tAvg Loss: 0.0000\nTrain Epoch: 53\t[20000/88956 (22%)]\tTotal Loss: 0.7639\tAvg Loss: 0.0000\nTrain Epoch: 53\t[25000/88956 (28%)]\tTotal Loss: 0.9586\tAvg Loss: 0.0000\nTrain Epoch: 53\t[30000/88956 (34%)]\tTotal Loss: 1.1615\tAvg Loss: 0.0000\nTrain Epoch: 53\t[35000/88956 (39%)]\tTotal Loss: 1.3498\tAvg Loss: 0.0000\nTrain Epoch: 53\t[40000/88956 (45%)]\tTotal Loss: 1.5387\tAvg Loss: 0.0000\nTrain Epoch: 53\t[45000/88956 (51%)]\tTotal Loss: 1.7327\tAvg Loss: 0.0000\nTrain Epoch: 53\t[50000/88956 (56%)]\tTotal Loss: 1.9324\tAvg Loss: 0.0000\nTrain Epoch: 53\t[55000/88956 (62%)]\tTotal Loss: 2.1208\tAvg Loss: 0.0000\nTrain Epoch: 53\t[60000/88956 (67%)]\tTotal Loss: 2.3229\tAvg Loss: 0.0000\nTrain Epoch: 53\t[65000/88956 (73%)]\tTotal Loss: 2.5301\tAvg Loss: 0.0000\nTrain Epoch: 53\t[70000/88956 (79%)]\tTotal Loss: 2.7187\tAvg Loss: 0.0000\nTrain Epoch: 53\t[75000/88956 (84%)]\tTotal Loss: 2.9318\tAvg Loss: 0.0000\nTrain Epoch: 53\t[80000/88956 (90%)]\tTotal Loss: 3.1214\tAvg Loss: 0.0000\nTrain Epoch: 53\t[85000/88956 (96%)]\tTotal Loss: 3.3221\tAvg Loss: 0.0000\n====> Epoch: 53\tTotal Loss: 3.4734\t Avg Loss: 0.0000\tCorrect: 66952/88956\tPercentage Correct: 75.26\n====> Val Loss: 0.5899\t Avg Loss: 0.0001\tCorrect: 6655/9885\tPercentage Correct: 67.32\n====> Test Loss: 1.4157\t Avg Loss: 0.0001\tCorrect: 16800/24711\tPercentage Correct: 67.99\nTrain Epoch: 54\t[5000/88956 (6%)]\tTotal Loss: 0.1779\tAvg Loss: 0.0000\nTrain Epoch: 54\t[10000/88956 (11%)]\tTotal Loss: 0.3384\tAvg Loss: 0.0000\nTrain Epoch: 54\t[15000/88956 (17%)]\tTotal Loss: 0.5198\tAvg Loss: 0.0000\nTrain Epoch: 54\t[20000/88956 (22%)]\tTotal Loss: 0.7082\tAvg Loss: 0.0000\nTrain Epoch: 54\t[25000/88956 (28%)]\tTotal Loss: 0.8910\tAvg Loss: 0.0000\nTrain Epoch: 54\t[30000/88956 (34%)]\tTotal Loss: 1.0820\tAvg Loss: 0.0000\nTrain Epoch: 54\t[35000/88956 (39%)]\tTotal Loss: 1.2802\tAvg Loss: 0.0000\nTrain Epoch: 54\t[40000/88956 (45%)]\tTotal Loss: 1.4900\tAvg Loss: 0.0000\nTrain Epoch: 54\t[45000/88956 (51%)]\tTotal Loss: 1.6914\tAvg Loss: 0.0000\nTrain Epoch: 54\t[50000/88956 (56%)]\tTotal Loss: 1.8842\tAvg Loss: 0.0000\nTrain Epoch: 54\t[55000/88956 (62%)]\tTotal Loss: 2.0646\tAvg Loss: 0.0000\nTrain Epoch: 54\t[60000/88956 (67%)]\tTotal Loss: 2.2644\tAvg Loss: 0.0000\nTrain Epoch: 54\t[65000/88956 (73%)]\tTotal Loss: 2.4769\tAvg Loss: 0.0000\nTrain Epoch: 54\t[70000/88956 (79%)]\tTotal Loss: 2.6777\tAvg Loss: 0.0000\nTrain Epoch: 54\t[75000/88956 (84%)]\tTotal Loss: 2.8752\tAvg Loss: 0.0000\nTrain Epoch: 54\t[80000/88956 (90%)]\tTotal Loss: 3.0547\tAvg Loss: 0.0000\nTrain Epoch: 54\t[85000/88956 (96%)]\tTotal Loss: 3.2568\tAvg Loss: 0.0000\n====> Epoch: 54\tTotal Loss: 3.4059\t Avg Loss: 0.0000\tCorrect: 67510/88956\tPercentage Correct: 75.89\n====> Val Loss: 0.5884\t Avg Loss: 0.0001\tCorrect: 6601/9885\tPercentage Correct: 66.78\n====> Test Loss: 1.4337\t Avg Loss: 0.0001\tCorrect: 16671/24711\tPercentage Correct: 67.46\nTrain Epoch: 55\t[5000/88956 (6%)]\tTotal Loss: 0.1808\tAvg Loss: 0.0000\nTrain Epoch: 55\t[10000/88956 (11%)]\tTotal Loss: 0.3480\tAvg Loss: 0.0000\nTrain Epoch: 55\t[15000/88956 (17%)]\tTotal Loss: 0.5334\tAvg Loss: 0.0000\nTrain Epoch: 55\t[20000/88956 (22%)]\tTotal Loss: 0.7129\tAvg Loss: 0.0000\nTrain Epoch: 55\t[25000/88956 (28%)]\tTotal Loss: 0.8994\tAvg Loss: 0.0000\nTrain Epoch: 55\t[30000/88956 (34%)]\tTotal Loss: 1.0759\tAvg Loss: 0.0000\nTrain Epoch: 55\t[35000/88956 (39%)]\tTotal Loss: 1.2787\tAvg Loss: 0.0000\nTrain Epoch: 55\t[40000/88956 (45%)]\tTotal Loss: 1.4658\tAvg Loss: 0.0000\nTrain Epoch: 55\t[45000/88956 (51%)]\tTotal Loss: 1.6503\tAvg Loss: 0.0000\nTrain Epoch: 55\t[50000/88956 (56%)]\tTotal Loss: 1.8430\tAvg Loss: 0.0000\nTrain Epoch: 55\t[55000/88956 (62%)]\tTotal Loss: 2.0538\tAvg Loss: 0.0000\nTrain Epoch: 55\t[60000/88956 (67%)]\tTotal Loss: 2.2511\tAvg Loss: 0.0000\nTrain Epoch: 55\t[65000/88956 (73%)]\tTotal Loss: 2.4378\tAvg Loss: 0.0000\nTrain Epoch: 55\t[70000/88956 (79%)]\tTotal Loss: 2.6212\tAvg Loss: 0.0000\nTrain Epoch: 55\t[75000/88956 (84%)]\tTotal Loss: 2.8119\tAvg Loss: 0.0000\nTrain Epoch: 55\t[80000/88956 (90%)]\tTotal Loss: 3.0103\tAvg Loss: 0.0000\nTrain Epoch: 55\t[85000/88956 (96%)]\tTotal Loss: 3.2069\tAvg Loss: 0.0000\n====> Epoch: 55\tTotal Loss: 3.3485\t Avg Loss: 0.0000\tCorrect: 67822/88956\tPercentage Correct: 76.24\n====> Val Loss: 0.5585\t Avg Loss: 0.0001\tCorrect: 6736/9885\tPercentage Correct: 68.14\n====> Test Loss: 1.3850\t Avg Loss: 0.0001\tCorrect: 16770/24711\tPercentage Correct: 67.86\n\n=== saved best model ===\n\nTrain Epoch: 56\t[5000/88956 (6%)]\tTotal Loss: 0.1687\tAvg Loss: 0.0000\nTrain Epoch: 56\t[10000/88956 (11%)]\tTotal Loss: 0.3473\tAvg Loss: 0.0000\nTrain Epoch: 56\t[15000/88956 (17%)]\tTotal Loss: 0.5250\tAvg Loss: 0.0000\nTrain Epoch: 56\t[20000/88956 (22%)]\tTotal Loss: 0.7040\tAvg Loss: 0.0000\nTrain Epoch: 56\t[25000/88956 (28%)]\tTotal Loss: 0.8850\tAvg Loss: 0.0000\nTrain Epoch: 56\t[30000/88956 (34%)]\tTotal Loss: 1.0673\tAvg Loss: 0.0000\nTrain Epoch: 56\t[35000/88956 (39%)]\tTotal Loss: 1.2582\tAvg Loss: 0.0000\nTrain Epoch: 56\t[40000/88956 (45%)]\tTotal Loss: 1.4585\tAvg Loss: 0.0000\nTrain Epoch: 56\t[45000/88956 (51%)]\tTotal Loss: 1.6527\tAvg Loss: 0.0000\nTrain Epoch: 56\t[50000/88956 (56%)]\tTotal Loss: 1.8575\tAvg Loss: 0.0000\nTrain Epoch: 56\t[55000/88956 (62%)]\tTotal Loss: 2.0381\tAvg Loss: 0.0000\nTrain Epoch: 56\t[60000/88956 (67%)]\tTotal Loss: 2.2223\tAvg Loss: 0.0000\nTrain Epoch: 56\t[65000/88956 (73%)]\tTotal Loss: 2.4196\tAvg Loss: 0.0000\nTrain Epoch: 56\t[70000/88956 (79%)]\tTotal Loss: 2.6135\tAvg Loss: 0.0000\nTrain Epoch: 56\t[75000/88956 (84%)]\tTotal Loss: 2.8033\tAvg Loss: 0.0000\nTrain Epoch: 56\t[80000/88956 (90%)]\tTotal Loss: 2.9941\tAvg Loss: 0.0000\nTrain Epoch: 56\t[85000/88956 (96%)]\tTotal Loss: 3.1751\tAvg Loss: 0.0000\n====> Epoch: 56\tTotal Loss: 3.3204\t Avg Loss: 0.0000\tCorrect: 67717/88956\tPercentage Correct: 76.12\n====> Val Loss: 0.5702\t Avg Loss: 0.0001\tCorrect: 6667/9885\tPercentage Correct: 67.45\n====> Test Loss: 1.3819\t Avg Loss: 0.0001\tCorrect: 16784/24711\tPercentage Correct: 67.92\nTrain Epoch: 57\t[5000/88956 (6%)]\tTotal Loss: 0.2900\tAvg Loss: 0.0001\nTrain Epoch: 57\t[10000/88956 (11%)]\tTotal Loss: 0.5517\tAvg Loss: 0.0001\nTrain Epoch: 57\t[15000/88956 (17%)]\tTotal Loss: 0.7557\tAvg Loss: 0.0001\nTrain Epoch: 57\t[20000/88956 (22%)]\tTotal Loss: 0.9567\tAvg Loss: 0.0000\nTrain Epoch: 57\t[25000/88956 (28%)]\tTotal Loss: 1.1494\tAvg Loss: 0.0000\nTrain Epoch: 57\t[30000/88956 (34%)]\tTotal Loss: 1.3319\tAvg Loss: 0.0000\nTrain Epoch: 57\t[35000/88956 (39%)]\tTotal Loss: 1.5173\tAvg Loss: 0.0000\nTrain Epoch: 57\t[40000/88956 (45%)]\tTotal Loss: 1.6972\tAvg Loss: 0.0000\nTrain Epoch: 57\t[45000/88956 (51%)]\tTotal Loss: 1.8737\tAvg Loss: 0.0000\nTrain Epoch: 57\t[50000/88956 (56%)]\tTotal Loss: 2.0562\tAvg Loss: 0.0000\nTrain Epoch: 57\t[55000/88956 (62%)]\tTotal Loss: 2.2299\tAvg Loss: 0.0000\nTrain Epoch: 57\t[60000/88956 (67%)]\tTotal Loss: 2.4137\tAvg Loss: 0.0000\nTrain Epoch: 57\t[65000/88956 (73%)]\tTotal Loss: 2.6073\tAvg Loss: 0.0000\nTrain Epoch: 57\t[70000/88956 (79%)]\tTotal Loss: 2.8050\tAvg Loss: 0.0000\nTrain Epoch: 57\t[75000/88956 (84%)]\tTotal Loss: 2.9954\tAvg Loss: 0.0000\nTrain Epoch: 57\t[80000/88956 (90%)]\tTotal Loss: 3.1814\tAvg Loss: 0.0000\nTrain Epoch: 57\t[85000/88956 (96%)]\tTotal Loss: 3.3723\tAvg Loss: 0.0000\n====> Epoch: 57\tTotal Loss: 3.5196\t Avg Loss: 0.0000\tCorrect: 66622/88956\tPercentage Correct: 74.89\n====> Val Loss: 0.5659\t Avg Loss: 0.0001\tCorrect: 6774/9885\tPercentage Correct: 68.53\n====> Test Loss: 1.4158\t Avg Loss: 0.0001\tCorrect: 16955/24711\tPercentage Correct: 68.61\n\n=== saved best model ===\n\nTrain Epoch: 58\t[5000/88956 (6%)]\tTotal Loss: 0.1694\tAvg Loss: 0.0000\nTrain Epoch: 58\t[10000/88956 (11%)]\tTotal Loss: 0.3414\tAvg Loss: 0.0000\nTrain Epoch: 58\t[15000/88956 (17%)]\tTotal Loss: 0.5076\tAvg Loss: 0.0000\nTrain Epoch: 58\t[20000/88956 (22%)]\tTotal Loss: 0.6751\tAvg Loss: 0.0000\nTrain Epoch: 58\t[25000/88956 (28%)]\tTotal Loss: 0.8473\tAvg Loss: 0.0000\nTrain Epoch: 58\t[30000/88956 (34%)]\tTotal Loss: 1.0221\tAvg Loss: 0.0000\nTrain Epoch: 58\t[35000/88956 (39%)]\tTotal Loss: 1.2104\tAvg Loss: 0.0000\nTrain Epoch: 58\t[40000/88956 (45%)]\tTotal Loss: 1.3863\tAvg Loss: 0.0000\nTrain Epoch: 58\t[45000/88956 (51%)]\tTotal Loss: 1.5408\tAvg Loss: 0.0000\nTrain Epoch: 58\t[50000/88956 (56%)]\tTotal Loss: 1.7171\tAvg Loss: 0.0000\nTrain Epoch: 58\t[55000/88956 (62%)]\tTotal Loss: 1.8822\tAvg Loss: 0.0000\nTrain Epoch: 58\t[60000/88956 (67%)]\tTotal Loss: 2.0664\tAvg Loss: 0.0000\nTrain Epoch: 58\t[65000/88956 (73%)]\tTotal Loss: 2.2387\tAvg Loss: 0.0000\nTrain Epoch: 58\t[70000/88956 (79%)]\tTotal Loss: 2.4157\tAvg Loss: 0.0000\nTrain Epoch: 58\t[75000/88956 (84%)]\tTotal Loss: 2.6065\tAvg Loss: 0.0000\nTrain Epoch: 58\t[80000/88956 (90%)]\tTotal Loss: 2.7982\tAvg Loss: 0.0000\nTrain Epoch: 58\t[85000/88956 (96%)]\tTotal Loss: 2.9986\tAvg Loss: 0.0000\n====> Epoch: 58\tTotal Loss: 3.1505\t Avg Loss: 0.0000\tCorrect: 68877/88956\tPercentage Correct: 77.43\n====> Val Loss: 0.5391\t Avg Loss: 0.0001\tCorrect: 6749/9885\tPercentage Correct: 68.28\n====> Test Loss: 1.3066\t Avg Loss: 0.0001\tCorrect: 16982/24711\tPercentage Correct: 68.72\nTrain Epoch: 59\t[5000/88956 (6%)]\tTotal Loss: 0.1674\tAvg Loss: 0.0000\nTrain Epoch: 59\t[10000/88956 (11%)]\tTotal Loss: 0.3265\tAvg Loss: 0.0000\nTrain Epoch: 59\t[15000/88956 (17%)]\tTotal Loss: 0.5070\tAvg Loss: 0.0000\nTrain Epoch: 59\t[20000/88956 (22%)]\tTotal Loss: 0.6870\tAvg Loss: 0.0000\nTrain Epoch: 59\t[25000/88956 (28%)]\tTotal Loss: 0.8631\tAvg Loss: 0.0000\nTrain Epoch: 59\t[30000/88956 (34%)]\tTotal Loss: 1.0436\tAvg Loss: 0.0000\nTrain Epoch: 59\t[35000/88956 (39%)]\tTotal Loss: 1.2112\tAvg Loss: 0.0000\nTrain Epoch: 59\t[40000/88956 (45%)]\tTotal Loss: 1.3726\tAvg Loss: 0.0000\nTrain Epoch: 59\t[45000/88956 (51%)]\tTotal Loss: 1.5444\tAvg Loss: 0.0000\nTrain Epoch: 59\t[50000/88956 (56%)]\tTotal Loss: 1.7263\tAvg Loss: 0.0000\nTrain Epoch: 59\t[55000/88956 (62%)]\tTotal Loss: 1.9116\tAvg Loss: 0.0000\nTrain Epoch: 59\t[60000/88956 (67%)]\tTotal Loss: 2.0937\tAvg Loss: 0.0000\nTrain Epoch: 59\t[65000/88956 (73%)]\tTotal Loss: 2.2852\tAvg Loss: 0.0000\nTrain Epoch: 59\t[70000/88956 (79%)]\tTotal Loss: 2.4733\tAvg Loss: 0.0000\nTrain Epoch: 59\t[75000/88956 (84%)]\tTotal Loss: 2.6523\tAvg Loss: 0.0000\nTrain Epoch: 59\t[80000/88956 (90%)]\tTotal Loss: 2.8331\tAvg Loss: 0.0000\nTrain Epoch: 59\t[85000/88956 (96%)]\tTotal Loss: 3.0173\tAvg Loss: 0.0000\n====> Epoch: 59\tTotal Loss: 3.1645\t Avg Loss: 0.0000\tCorrect: 68478/88956\tPercentage Correct: 76.98\n====> Val Loss: 0.5300\t Avg Loss: 0.0001\tCorrect: 6683/9885\tPercentage Correct: 67.61\n====> Test Loss: 1.2828\t Avg Loss: 0.0001\tCorrect: 16992/24711\tPercentage Correct: 68.76\nTrain Epoch: 60\t[5000/88956 (6%)]\tTotal Loss: 0.1655\tAvg Loss: 0.0000\nTrain Epoch: 60\t[10000/88956 (11%)]\tTotal Loss: 0.3302\tAvg Loss: 0.0000\nTrain Epoch: 60\t[15000/88956 (17%)]\tTotal Loss: 0.4880\tAvg Loss: 0.0000\nTrain Epoch: 60\t[20000/88956 (22%)]\tTotal Loss: 0.6556\tAvg Loss: 0.0000\nTrain Epoch: 60\t[25000/88956 (28%)]\tTotal Loss: 0.8460\tAvg Loss: 0.0000\nTrain Epoch: 60\t[30000/88956 (34%)]\tTotal Loss: 1.0238\tAvg Loss: 0.0000\nTrain Epoch: 60\t[35000/88956 (39%)]\tTotal Loss: 1.1883\tAvg Loss: 0.0000\nTrain Epoch: 60\t[40000/88956 (45%)]\tTotal Loss: 1.3506\tAvg Loss: 0.0000\nTrain Epoch: 60\t[45000/88956 (51%)]\tTotal Loss: 1.5408\tAvg Loss: 0.0000\nTrain Epoch: 60\t[50000/88956 (56%)]\tTotal Loss: 1.7240\tAvg Loss: 0.0000\nTrain Epoch: 60\t[55000/88956 (62%)]\tTotal Loss: 1.9030\tAvg Loss: 0.0000\nTrain Epoch: 60\t[60000/88956 (67%)]\tTotal Loss: 2.0765\tAvg Loss: 0.0000\nTrain Epoch: 60\t[65000/88956 (73%)]\tTotal Loss: 2.2510\tAvg Loss: 0.0000\nTrain Epoch: 60\t[70000/88956 (79%)]\tTotal Loss: 2.4651\tAvg Loss: 0.0000\nTrain Epoch: 60\t[75000/88956 (84%)]\tTotal Loss: 2.6453\tAvg Loss: 0.0000\nTrain Epoch: 60\t[80000/88956 (90%)]\tTotal Loss: 2.8148\tAvg Loss: 0.0000\nTrain Epoch: 60\t[85000/88956 (96%)]\tTotal Loss: 2.9865\tAvg Loss: 0.0000\n====> Epoch: 60\tTotal Loss: 3.1230\t Avg Loss: 0.0000\tCorrect: 68959/88956\tPercentage Correct: 77.52\n====> Val Loss: 0.5127\t Avg Loss: 0.0001\tCorrect: 6787/9885\tPercentage Correct: 68.66\n====> Test Loss: 1.2490\t Avg Loss: 0.0001\tCorrect: 17097/24711\tPercentage Correct: 69.19\n\n=== saved best model ===\n\nTrain Epoch: 61\t[5000/88956 (6%)]\tTotal Loss: 0.1565\tAvg Loss: 0.0000\nTrain Epoch: 61\t[10000/88956 (11%)]\tTotal Loss: 0.3220\tAvg Loss: 0.0000\nTrain Epoch: 61\t[15000/88956 (17%)]\tTotal Loss: 0.4960\tAvg Loss: 0.0000\nTrain Epoch: 61\t[20000/88956 (22%)]\tTotal Loss: 0.6820\tAvg Loss: 0.0000\nTrain Epoch: 61\t[25000/88956 (28%)]\tTotal Loss: 0.8583\tAvg Loss: 0.0000\nTrain Epoch: 61\t[30000/88956 (34%)]\tTotal Loss: 1.0310\tAvg Loss: 0.0000\nTrain Epoch: 61\t[35000/88956 (39%)]\tTotal Loss: 1.2117\tAvg Loss: 0.0000\nTrain Epoch: 61\t[40000/88956 (45%)]\tTotal Loss: 1.3826\tAvg Loss: 0.0000\nTrain Epoch: 61\t[45000/88956 (51%)]\tTotal Loss: 1.5633\tAvg Loss: 0.0000\nTrain Epoch: 61\t[50000/88956 (56%)]\tTotal Loss: 1.7380\tAvg Loss: 0.0000\nTrain Epoch: 61\t[55000/88956 (62%)]\tTotal Loss: 1.9104\tAvg Loss: 0.0000\nTrain Epoch: 61\t[60000/88956 (67%)]\tTotal Loss: 2.0906\tAvg Loss: 0.0000\nTrain Epoch: 61\t[65000/88956 (73%)]\tTotal Loss: 2.2767\tAvg Loss: 0.0000\nTrain Epoch: 61\t[70000/88956 (79%)]\tTotal Loss: 2.4674\tAvg Loss: 0.0000\nTrain Epoch: 61\t[75000/88956 (84%)]\tTotal Loss: 2.6301\tAvg Loss: 0.0000\nTrain Epoch: 61\t[80000/88956 (90%)]\tTotal Loss: 2.8051\tAvg Loss: 0.0000\nTrain Epoch: 61\t[85000/88956 (96%)]\tTotal Loss: 2.9909\tAvg Loss: 0.0000\n====> Epoch: 61\tTotal Loss: 3.1356\t Avg Loss: 0.0000\tCorrect: 68819/88956\tPercentage Correct: 77.36\n====> Val Loss: 0.5462\t Avg Loss: 0.0001\tCorrect: 6776/9885\tPercentage Correct: 68.55\n====> Test Loss: 1.3123\t Avg Loss: 0.0001\tCorrect: 17040/24711\tPercentage Correct: 68.96\nTrain Epoch: 62\t[5000/88956 (6%)]\tTotal Loss: 0.1738\tAvg Loss: 0.0000\nTrain Epoch: 62\t[10000/88956 (11%)]\tTotal Loss: 0.3447\tAvg Loss: 0.0000\nTrain Epoch: 62\t[15000/88956 (17%)]\tTotal Loss: 0.5115\tAvg Loss: 0.0000\nTrain Epoch: 62\t[20000/88956 (22%)]\tTotal Loss: 0.6727\tAvg Loss: 0.0000\nTrain Epoch: 62\t[25000/88956 (28%)]\tTotal Loss: 0.8508\tAvg Loss: 0.0000\nTrain Epoch: 62\t[30000/88956 (34%)]\tTotal Loss: 1.0132\tAvg Loss: 0.0000\nTrain Epoch: 62\t[35000/88956 (39%)]\tTotal Loss: 1.1725\tAvg Loss: 0.0000\nTrain Epoch: 62\t[40000/88956 (45%)]\tTotal Loss: 1.3479\tAvg Loss: 0.0000\nTrain Epoch: 62\t[45000/88956 (51%)]\tTotal Loss: 1.5228\tAvg Loss: 0.0000\nTrain Epoch: 62\t[50000/88956 (56%)]\tTotal Loss: 1.6956\tAvg Loss: 0.0000\nTrain Epoch: 62\t[55000/88956 (62%)]\tTotal Loss: 1.8784\tAvg Loss: 0.0000\nTrain Epoch: 62\t[60000/88956 (67%)]\tTotal Loss: 2.0496\tAvg Loss: 0.0000\nTrain Epoch: 62\t[65000/88956 (73%)]\tTotal Loss: 2.2256\tAvg Loss: 0.0000\nTrain Epoch: 62\t[70000/88956 (79%)]\tTotal Loss: 2.3938\tAvg Loss: 0.0000\nTrain Epoch: 62\t[75000/88956 (84%)]\tTotal Loss: 2.5995\tAvg Loss: 0.0000\nTrain Epoch: 62\t[80000/88956 (90%)]\tTotal Loss: 2.7920\tAvg Loss: 0.0000\nTrain Epoch: 62\t[85000/88956 (96%)]\tTotal Loss: 2.9569\tAvg Loss: 0.0000\n====> Epoch: 62\tTotal Loss: 3.0819\t Avg Loss: 0.0000\tCorrect: 68959/88956\tPercentage Correct: 77.52\n====> Val Loss: 0.5074\t Avg Loss: 0.0001\tCorrect: 6855/9885\tPercentage Correct: 69.35\n====> Test Loss: 1.2607\t Avg Loss: 0.0001\tCorrect: 17168/24711\tPercentage Correct: 69.48\n\n=== saved best model ===\n\nTrain Epoch: 63\t[5000/88956 (6%)]\tTotal Loss: 0.1542\tAvg Loss: 0.0000\nTrain Epoch: 63\t[10000/88956 (11%)]\tTotal Loss: 0.3174\tAvg Loss: 0.0000\nTrain Epoch: 63\t[15000/88956 (17%)]\tTotal Loss: 0.4923\tAvg Loss: 0.0000\nTrain Epoch: 63\t[20000/88956 (22%)]\tTotal Loss: 0.6703\tAvg Loss: 0.0000\nTrain Epoch: 63\t[25000/88956 (28%)]\tTotal Loss: 0.8290\tAvg Loss: 0.0000\nTrain Epoch: 63\t[30000/88956 (34%)]\tTotal Loss: 1.0046\tAvg Loss: 0.0000\nTrain Epoch: 63\t[35000/88956 (39%)]\tTotal Loss: 1.1819\tAvg Loss: 0.0000\nTrain Epoch: 63\t[40000/88956 (45%)]\tTotal Loss: 1.3634\tAvg Loss: 0.0000\nTrain Epoch: 63\t[45000/88956 (51%)]\tTotal Loss: 1.5451\tAvg Loss: 0.0000\nTrain Epoch: 63\t[50000/88956 (56%)]\tTotal Loss: 1.7077\tAvg Loss: 0.0000\nTrain Epoch: 63\t[55000/88956 (62%)]\tTotal Loss: 1.8793\tAvg Loss: 0.0000\nTrain Epoch: 63\t[60000/88956 (67%)]\tTotal Loss: 2.0524\tAvg Loss: 0.0000\nTrain Epoch: 63\t[65000/88956 (73%)]\tTotal Loss: 2.2233\tAvg Loss: 0.0000\nTrain Epoch: 63\t[70000/88956 (79%)]\tTotal Loss: 2.4013\tAvg Loss: 0.0000\nTrain Epoch: 63\t[75000/88956 (84%)]\tTotal Loss: 2.5846\tAvg Loss: 0.0000\nTrain Epoch: 63\t[80000/88956 (90%)]\tTotal Loss: 2.7610\tAvg Loss: 0.0000\nTrain Epoch: 63\t[85000/88956 (96%)]\tTotal Loss: 2.9332\tAvg Loss: 0.0000\n====> Epoch: 63\tTotal Loss: 3.0685\t Avg Loss: 0.0000\tCorrect: 69114/88956\tPercentage Correct: 77.69\n====> Val Loss: 0.5051\t Avg Loss: 0.0001\tCorrect: 6874/9885\tPercentage Correct: 69.54\n====> Test Loss: 1.2483\t Avg Loss: 0.0001\tCorrect: 17415/24711\tPercentage Correct: 70.47\n\n=== saved best model ===\n\nTrain Epoch: 64\t[5000/88956 (6%)]\tTotal Loss: 0.1581\tAvg Loss: 0.0000\nTrain Epoch: 64\t[10000/88956 (11%)]\tTotal Loss: 0.3324\tAvg Loss: 0.0000\nTrain Epoch: 64\t[15000/88956 (17%)]\tTotal Loss: 0.5014\tAvg Loss: 0.0000\nTrain Epoch: 64\t[20000/88956 (22%)]\tTotal Loss: 0.6819\tAvg Loss: 0.0000\nTrain Epoch: 64\t[25000/88956 (28%)]\tTotal Loss: 0.8432\tAvg Loss: 0.0000\nTrain Epoch: 64\t[30000/88956 (34%)]\tTotal Loss: 1.0005\tAvg Loss: 0.0000\nTrain Epoch: 64\t[35000/88956 (39%)]\tTotal Loss: 1.1768\tAvg Loss: 0.0000\nTrain Epoch: 64\t[40000/88956 (45%)]\tTotal Loss: 1.3461\tAvg Loss: 0.0000\nTrain Epoch: 64\t[45000/88956 (51%)]\tTotal Loss: 1.5073\tAvg Loss: 0.0000\nTrain Epoch: 64\t[50000/88956 (56%)]\tTotal Loss: 1.7214\tAvg Loss: 0.0000\nTrain Epoch: 64\t[55000/88956 (62%)]\tTotal Loss: 1.9545\tAvg Loss: 0.0000\nTrain Epoch: 64\t[60000/88956 (67%)]\tTotal Loss: 2.1445\tAvg Loss: 0.0000\nTrain Epoch: 64\t[65000/88956 (73%)]\tTotal Loss: 2.3254\tAvg Loss: 0.0000\nTrain Epoch: 64\t[70000/88956 (79%)]\tTotal Loss: 2.4978\tAvg Loss: 0.0000\nTrain Epoch: 64\t[75000/88956 (84%)]\tTotal Loss: 2.6675\tAvg Loss: 0.0000\nTrain Epoch: 64\t[80000/88956 (90%)]\tTotal Loss: 2.8280\tAvg Loss: 0.0000\nTrain Epoch: 64\t[85000/88956 (96%)]\tTotal Loss: 3.0079\tAvg Loss: 0.0000\n====> Epoch: 64\tTotal Loss: 3.1785\t Avg Loss: 0.0000\tCorrect: 68625/88956\tPercentage Correct: 77.14\n====> Val Loss: 0.5679\t Avg Loss: 0.0001\tCorrect: 6608/9885\tPercentage Correct: 66.85\n====> Test Loss: 1.4302\t Avg Loss: 0.0001\tCorrect: 16524/24711\tPercentage Correct: 66.87\nTrain Epoch: 65\t[5000/88956 (6%)]\tTotal Loss: 0.1896\tAvg Loss: 0.0000\nTrain Epoch: 65\t[10000/88956 (11%)]\tTotal Loss: 0.3628\tAvg Loss: 0.0000\nTrain Epoch: 65\t[15000/88956 (17%)]\tTotal Loss: 0.5334\tAvg Loss: 0.0000\nTrain Epoch: 65\t[20000/88956 (22%)]\tTotal Loss: 0.6903\tAvg Loss: 0.0000\nTrain Epoch: 65\t[25000/88956 (28%)]\tTotal Loss: 0.8407\tAvg Loss: 0.0000\nTrain Epoch: 65\t[30000/88956 (34%)]\tTotal Loss: 0.9989\tAvg Loss: 0.0000\nTrain Epoch: 65\t[35000/88956 (39%)]\tTotal Loss: 1.1546\tAvg Loss: 0.0000\nTrain Epoch: 65\t[40000/88956 (45%)]\tTotal Loss: 1.3349\tAvg Loss: 0.0000\nTrain Epoch: 65\t[45000/88956 (51%)]\tTotal Loss: 1.5081\tAvg Loss: 0.0000\nTrain Epoch: 65\t[50000/88956 (56%)]\tTotal Loss: 1.6685\tAvg Loss: 0.0000\nTrain Epoch: 65\t[55000/88956 (62%)]\tTotal Loss: 1.8240\tAvg Loss: 0.0000\nTrain Epoch: 65\t[60000/88956 (67%)]\tTotal Loss: 1.9809\tAvg Loss: 0.0000\nTrain Epoch: 65\t[65000/88956 (73%)]\tTotal Loss: 2.1393\tAvg Loss: 0.0000\nTrain Epoch: 65\t[70000/88956 (79%)]\tTotal Loss: 2.3137\tAvg Loss: 0.0000\nTrain Epoch: 65\t[75000/88956 (84%)]\tTotal Loss: 2.4668\tAvg Loss: 0.0000\nTrain Epoch: 65\t[80000/88956 (90%)]\tTotal Loss: 2.6337\tAvg Loss: 0.0000\nTrain Epoch: 65\t[85000/88956 (96%)]\tTotal Loss: 2.7962\tAvg Loss: 0.0000\n====> Epoch: 65\tTotal Loss: 2.9261\t Avg Loss: 0.0000\tCorrect: 69660/88956\tPercentage Correct: 78.31\n====> Val Loss: 0.5135\t Avg Loss: 0.0001\tCorrect: 7012/9885\tPercentage Correct: 70.94\n====> Test Loss: 1.2487\t Avg Loss: 0.0001\tCorrect: 17451/24711\tPercentage Correct: 70.62\n\n=== saved best model ===\n\nTrain Epoch: 66\t[5000/88956 (6%)]\tTotal Loss: 0.1494\tAvg Loss: 0.0000\nTrain Epoch: 66\t[10000/88956 (11%)]\tTotal Loss: 0.2985\tAvg Loss: 0.0000\nTrain Epoch: 66\t[15000/88956 (17%)]\tTotal Loss: 0.4603\tAvg Loss: 0.0000\nTrain Epoch: 66\t[20000/88956 (22%)]\tTotal Loss: 0.6202\tAvg Loss: 0.0000\nTrain Epoch: 66\t[25000/88956 (28%)]\tTotal Loss: 0.7856\tAvg Loss: 0.0000\nTrain Epoch: 66\t[30000/88956 (34%)]\tTotal Loss: 0.9448\tAvg Loss: 0.0000\nTrain Epoch: 66\t[35000/88956 (39%)]\tTotal Loss: 1.0939\tAvg Loss: 0.0000\nTrain Epoch: 66\t[40000/88956 (45%)]\tTotal Loss: 1.2653\tAvg Loss: 0.0000\nTrain Epoch: 66\t[45000/88956 (51%)]\tTotal Loss: 1.4241\tAvg Loss: 0.0000\nTrain Epoch: 66\t[50000/88956 (56%)]\tTotal Loss: 1.5858\tAvg Loss: 0.0000\nTrain Epoch: 66\t[55000/88956 (62%)]\tTotal Loss: 1.7310\tAvg Loss: 0.0000\nTrain Epoch: 66\t[60000/88956 (67%)]\tTotal Loss: 1.9044\tAvg Loss: 0.0000\nTrain Epoch: 66\t[65000/88956 (73%)]\tTotal Loss: 2.0660\tAvg Loss: 0.0000\nTrain Epoch: 66\t[70000/88956 (79%)]\tTotal Loss: 2.2380\tAvg Loss: 0.0000\nTrain Epoch: 66\t[75000/88956 (84%)]\tTotal Loss: 2.4037\tAvg Loss: 0.0000\nTrain Epoch: 66\t[80000/88956 (90%)]\tTotal Loss: 2.5829\tAvg Loss: 0.0000\nTrain Epoch: 66\t[85000/88956 (96%)]\tTotal Loss: 2.7482\tAvg Loss: 0.0000\n====> Epoch: 66\tTotal Loss: 2.8721\t Avg Loss: 0.0000\tCorrect: 70254/88956\tPercentage Correct: 78.98\n====> Val Loss: 0.5092\t Avg Loss: 0.0001\tCorrect: 6840/9885\tPercentage Correct: 69.20\n====> Test Loss: 1.2521\t Avg Loss: 0.0001\tCorrect: 17164/24711\tPercentage Correct: 69.46\nTrain Epoch: 67\t[5000/88956 (6%)]\tTotal Loss: 0.1489\tAvg Loss: 0.0000\nTrain Epoch: 67\t[10000/88956 (11%)]\tTotal Loss: 0.3174\tAvg Loss: 0.0000\nTrain Epoch: 67\t[15000/88956 (17%)]\tTotal Loss: 0.4604\tAvg Loss: 0.0000\nTrain Epoch: 67\t[20000/88956 (22%)]\tTotal Loss: 0.6139\tAvg Loss: 0.0000\nTrain Epoch: 67\t[25000/88956 (28%)]\tTotal Loss: 0.7618\tAvg Loss: 0.0000\nTrain Epoch: 67\t[30000/88956 (34%)]\tTotal Loss: 0.9261\tAvg Loss: 0.0000\nTrain Epoch: 67\t[35000/88956 (39%)]\tTotal Loss: 1.0891\tAvg Loss: 0.0000\nTrain Epoch: 67\t[40000/88956 (45%)]\tTotal Loss: 1.2401\tAvg Loss: 0.0000\nTrain Epoch: 67\t[45000/88956 (51%)]\tTotal Loss: 1.3865\tAvg Loss: 0.0000\nTrain Epoch: 67\t[50000/88956 (56%)]\tTotal Loss: 1.5461\tAvg Loss: 0.0000\nTrain Epoch: 67\t[55000/88956 (62%)]\tTotal Loss: 1.7063\tAvg Loss: 0.0000\nTrain Epoch: 67\t[60000/88956 (67%)]\tTotal Loss: 1.8541\tAvg Loss: 0.0000\nTrain Epoch: 67\t[65000/88956 (73%)]\tTotal Loss: 2.0070\tAvg Loss: 0.0000\nTrain Epoch: 67\t[70000/88956 (79%)]\tTotal Loss: 2.1724\tAvg Loss: 0.0000\nTrain Epoch: 67\t[75000/88956 (84%)]\tTotal Loss: 2.3488\tAvg Loss: 0.0000\nTrain Epoch: 67\t[80000/88956 (90%)]\tTotal Loss: 2.5475\tAvg Loss: 0.0000\nTrain Epoch: 67\t[85000/88956 (96%)]\tTotal Loss: 2.7097\tAvg Loss: 0.0000\n====> Epoch: 67\tTotal Loss: 2.8310\t Avg Loss: 0.0000\tCorrect: 70280/88956\tPercentage Correct: 79.01\n====> Val Loss: 0.4968\t Avg Loss: 0.0001\tCorrect: 6954/9885\tPercentage Correct: 70.35\n====> Test Loss: 1.1989\t Avg Loss: 0.0000\tCorrect: 17560/24711\tPercentage Correct: 71.06\nTrain Epoch: 68\t[5000/88956 (6%)]\tTotal Loss: 0.1571\tAvg Loss: 0.0000\nTrain Epoch: 68\t[10000/88956 (11%)]\tTotal Loss: 0.3183\tAvg Loss: 0.0000\nTrain Epoch: 68\t[15000/88956 (17%)]\tTotal Loss: 0.4735\tAvg Loss: 0.0000\nTrain Epoch: 68\t[20000/88956 (22%)]\tTotal Loss: 0.6143\tAvg Loss: 0.0000\nTrain Epoch: 68\t[25000/88956 (28%)]\tTotal Loss: 0.7670\tAvg Loss: 0.0000\nTrain Epoch: 68\t[30000/88956 (34%)]\tTotal Loss: 0.9273\tAvg Loss: 0.0000\nTrain Epoch: 68\t[35000/88956 (39%)]\tTotal Loss: 1.1000\tAvg Loss: 0.0000\nTrain Epoch: 68\t[40000/88956 (45%)]\tTotal Loss: 1.2689\tAvg Loss: 0.0000\nTrain Epoch: 68\t[45000/88956 (51%)]\tTotal Loss: 1.4366\tAvg Loss: 0.0000\nTrain Epoch: 68\t[50000/88956 (56%)]\tTotal Loss: 1.5998\tAvg Loss: 0.0000\nTrain Epoch: 68\t[55000/88956 (62%)]\tTotal Loss: 1.7552\tAvg Loss: 0.0000\nTrain Epoch: 68\t[60000/88956 (67%)]\tTotal Loss: 1.9178\tAvg Loss: 0.0000\nTrain Epoch: 68\t[65000/88956 (73%)]\tTotal Loss: 2.0767\tAvg Loss: 0.0000\nTrain Epoch: 68\t[70000/88956 (79%)]\tTotal Loss: 2.2436\tAvg Loss: 0.0000\nTrain Epoch: 68\t[75000/88956 (84%)]\tTotal Loss: 2.4010\tAvg Loss: 0.0000\nTrain Epoch: 68\t[80000/88956 (90%)]\tTotal Loss: 2.5770\tAvg Loss: 0.0000\nTrain Epoch: 68\t[85000/88956 (96%)]\tTotal Loss: 2.7448\tAvg Loss: 0.0000\n====> Epoch: 68\tTotal Loss: 2.8712\t Avg Loss: 0.0000\tCorrect: 69975/88956\tPercentage Correct: 78.66\n====> Val Loss: 0.4959\t Avg Loss: 0.0001\tCorrect: 6774/9885\tPercentage Correct: 68.53\n====> Test Loss: 1.2209\t Avg Loss: 0.0000\tCorrect: 16966/24711\tPercentage Correct: 68.66\nTrain Epoch: 69\t[5000/88956 (6%)]\tTotal Loss: 0.1451\tAvg Loss: 0.0000\nTrain Epoch: 69\t[10000/88956 (11%)]\tTotal Loss: 0.2886\tAvg Loss: 0.0000\nTrain Epoch: 69\t[15000/88956 (17%)]\tTotal Loss: 0.4325\tAvg Loss: 0.0000\nTrain Epoch: 69\t[20000/88956 (22%)]\tTotal Loss: 0.5790\tAvg Loss: 0.0000\nTrain Epoch: 69\t[25000/88956 (28%)]\tTotal Loss: 0.7395\tAvg Loss: 0.0000\nTrain Epoch: 69\t[30000/88956 (34%)]\tTotal Loss: 0.8900\tAvg Loss: 0.0000\nTrain Epoch: 69\t[35000/88956 (39%)]\tTotal Loss: 1.0492\tAvg Loss: 0.0000\nTrain Epoch: 69\t[40000/88956 (45%)]\tTotal Loss: 1.2035\tAvg Loss: 0.0000\nTrain Epoch: 69\t[45000/88956 (51%)]\tTotal Loss: 1.3736\tAvg Loss: 0.0000\nTrain Epoch: 69\t[50000/88956 (56%)]\tTotal Loss: 1.5250\tAvg Loss: 0.0000\nTrain Epoch: 69\t[55000/88956 (62%)]\tTotal Loss: 1.6839\tAvg Loss: 0.0000\nTrain Epoch: 69\t[60000/88956 (67%)]\tTotal Loss: 1.8387\tAvg Loss: 0.0000\nTrain Epoch: 69\t[65000/88956 (73%)]\tTotal Loss: 1.9975\tAvg Loss: 0.0000\nTrain Epoch: 69\t[70000/88956 (79%)]\tTotal Loss: 2.1545\tAvg Loss: 0.0000\nTrain Epoch: 69\t[75000/88956 (84%)]\tTotal Loss: 2.3164\tAvg Loss: 0.0000\nTrain Epoch: 69\t[80000/88956 (90%)]\tTotal Loss: 2.4862\tAvg Loss: 0.0000\nTrain Epoch: 69\t[85000/88956 (96%)]\tTotal Loss: 2.6547\tAvg Loss: 0.0000\n====> Epoch: 69\tTotal Loss: 2.7785\t Avg Loss: 0.0000\tCorrect: 70540/88956\tPercentage Correct: 79.30\n====> Val Loss: 0.4996\t Avg Loss: 0.0001\tCorrect: 6807/9885\tPercentage Correct: 68.86\n====> Test Loss: 1.2632\t Avg Loss: 0.0001\tCorrect: 17123/24711\tPercentage Correct: 69.29\nTrain Epoch: 70\t[5000/88956 (6%)]\tTotal Loss: 0.1503\tAvg Loss: 0.0000\nTrain Epoch: 70\t[10000/88956 (11%)]\tTotal Loss: 0.3019\tAvg Loss: 0.0000\nTrain Epoch: 70\t[15000/88956 (17%)]\tTotal Loss: 0.4502\tAvg Loss: 0.0000\nTrain Epoch: 70\t[20000/88956 (22%)]\tTotal Loss: 0.6094\tAvg Loss: 0.0000\nTrain Epoch: 70\t[25000/88956 (28%)]\tTotal Loss: 0.7676\tAvg Loss: 0.0000\nTrain Epoch: 70\t[30000/88956 (34%)]\tTotal Loss: 0.9183\tAvg Loss: 0.0000\nTrain Epoch: 70\t[35000/88956 (39%)]\tTotal Loss: 1.0677\tAvg Loss: 0.0000\nTrain Epoch: 70\t[40000/88956 (45%)]\tTotal Loss: 1.2212\tAvg Loss: 0.0000\nTrain Epoch: 70\t[45000/88956 (51%)]\tTotal Loss: 1.3808\tAvg Loss: 0.0000\nTrain Epoch: 70\t[50000/88956 (56%)]\tTotal Loss: 1.5309\tAvg Loss: 0.0000\nTrain Epoch: 70\t[55000/88956 (62%)]\tTotal Loss: 1.6967\tAvg Loss: 0.0000\nTrain Epoch: 70\t[60000/88956 (67%)]\tTotal Loss: 1.8599\tAvg Loss: 0.0000\nTrain Epoch: 70\t[65000/88956 (73%)]\tTotal Loss: 2.0219\tAvg Loss: 0.0000\nTrain Epoch: 70\t[70000/88956 (79%)]\tTotal Loss: 2.1793\tAvg Loss: 0.0000\nTrain Epoch: 70\t[75000/88956 (84%)]\tTotal Loss: 2.3447\tAvg Loss: 0.0000\nTrain Epoch: 70\t[80000/88956 (90%)]\tTotal Loss: 2.4984\tAvg Loss: 0.0000\nTrain Epoch: 70\t[85000/88956 (96%)]\tTotal Loss: 2.6471\tAvg Loss: 0.0000\n====> Epoch: 70\tTotal Loss: 2.7677\t Avg Loss: 0.0000\tCorrect: 70706/88956\tPercentage Correct: 79.48\n====> Val Loss: 0.5056\t Avg Loss: 0.0001\tCorrect: 6960/9885\tPercentage Correct: 70.41\n====> Test Loss: 1.2190\t Avg Loss: 0.0000\tCorrect: 17402/24711\tPercentage Correct: 70.42\nTrain Epoch: 71\t[5000/88956 (6%)]\tTotal Loss: 0.1558\tAvg Loss: 0.0000\nTrain Epoch: 71\t[10000/88956 (11%)]\tTotal Loss: 0.2872\tAvg Loss: 0.0000\nTrain Epoch: 71\t[15000/88956 (17%)]\tTotal Loss: 0.4230\tAvg Loss: 0.0000\nTrain Epoch: 71\t[20000/88956 (22%)]\tTotal Loss: 0.5767\tAvg Loss: 0.0000\nTrain Epoch: 71\t[25000/88956 (28%)]\tTotal Loss: 0.7226\tAvg Loss: 0.0000\nTrain Epoch: 71\t[30000/88956 (34%)]\tTotal Loss: 0.8707\tAvg Loss: 0.0000\nTrain Epoch: 71\t[35000/88956 (39%)]\tTotal Loss: 1.0258\tAvg Loss: 0.0000\nTrain Epoch: 71\t[40000/88956 (45%)]\tTotal Loss: 1.1745\tAvg Loss: 0.0000\nTrain Epoch: 71\t[45000/88956 (51%)]\tTotal Loss: 1.3412\tAvg Loss: 0.0000\nTrain Epoch: 71\t[50000/88956 (56%)]\tTotal Loss: 1.4868\tAvg Loss: 0.0000\nTrain Epoch: 71\t[55000/88956 (62%)]\tTotal Loss: 1.6384\tAvg Loss: 0.0000\nTrain Epoch: 71\t[60000/88956 (67%)]\tTotal Loss: 1.7943\tAvg Loss: 0.0000\nTrain Epoch: 71\t[65000/88956 (73%)]\tTotal Loss: 1.9481\tAvg Loss: 0.0000\nTrain Epoch: 71\t[70000/88956 (79%)]\tTotal Loss: 2.1025\tAvg Loss: 0.0000\nTrain Epoch: 71\t[75000/88956 (84%)]\tTotal Loss: 2.2641\tAvg Loss: 0.0000\nTrain Epoch: 71\t[80000/88956 (90%)]\tTotal Loss: 2.5076\tAvg Loss: 0.0000\nTrain Epoch: 71\t[85000/88956 (96%)]\tTotal Loss: 2.6999\tAvg Loss: 0.0000\n====> Epoch: 71\tTotal Loss: 2.8258\t Avg Loss: 0.0000\tCorrect: 70401/88956\tPercentage Correct: 79.14\n====> Val Loss: 0.4836\t Avg Loss: 0.0000\tCorrect: 6915/9885\tPercentage Correct: 69.95\n====> Test Loss: 1.1758\t Avg Loss: 0.0000\tCorrect: 17346/24711\tPercentage Correct: 70.20\nTrain Epoch: 72\t[5000/88956 (6%)]\tTotal Loss: 0.1367\tAvg Loss: 0.0000\nTrain Epoch: 72\t[10000/88956 (11%)]\tTotal Loss: 0.2849\tAvg Loss: 0.0000\nTrain Epoch: 72\t[15000/88956 (17%)]\tTotal Loss: 0.4330\tAvg Loss: 0.0000\nTrain Epoch: 72\t[20000/88956 (22%)]\tTotal Loss: 0.5689\tAvg Loss: 0.0000\nTrain Epoch: 72\t[25000/88956 (28%)]\tTotal Loss: 0.7190\tAvg Loss: 0.0000\nTrain Epoch: 72\t[30000/88956 (34%)]\tTotal Loss: 0.8677\tAvg Loss: 0.0000\nTrain Epoch: 72\t[35000/88956 (39%)]\tTotal Loss: 1.0200\tAvg Loss: 0.0000\nTrain Epoch: 72\t[40000/88956 (45%)]\tTotal Loss: 1.1790\tAvg Loss: 0.0000\nTrain Epoch: 72\t[45000/88956 (51%)]\tTotal Loss: 1.3342\tAvg Loss: 0.0000\nTrain Epoch: 72\t[50000/88956 (56%)]\tTotal Loss: 1.4968\tAvg Loss: 0.0000\nTrain Epoch: 72\t[55000/88956 (62%)]\tTotal Loss: 1.6448\tAvg Loss: 0.0000\nTrain Epoch: 72\t[60000/88956 (67%)]\tTotal Loss: 1.8064\tAvg Loss: 0.0000\nTrain Epoch: 72\t[65000/88956 (73%)]\tTotal Loss: 1.9527\tAvg Loss: 0.0000\nTrain Epoch: 72\t[70000/88956 (79%)]\tTotal Loss: 2.1114\tAvg Loss: 0.0000\nTrain Epoch: 72\t[75000/88956 (84%)]\tTotal Loss: 2.2611\tAvg Loss: 0.0000\nTrain Epoch: 72\t[80000/88956 (90%)]\tTotal Loss: 2.4133\tAvg Loss: 0.0000\nTrain Epoch: 72\t[85000/88956 (96%)]\tTotal Loss: 2.5643\tAvg Loss: 0.0000\n====> Epoch: 72\tTotal Loss: 2.6877\t Avg Loss: 0.0000\tCorrect: 71250/88956\tPercentage Correct: 80.10\n====> Val Loss: 0.4874\t Avg Loss: 0.0000\tCorrect: 6864/9885\tPercentage Correct: 69.44\n====> Test Loss: 1.2117\t Avg Loss: 0.0000\tCorrect: 17371/24711\tPercentage Correct: 70.30\nTrain Epoch: 73\t[5000/88956 (6%)]\tTotal Loss: 0.1489\tAvg Loss: 0.0000\nTrain Epoch: 73\t[10000/88956 (11%)]\tTotal Loss: 0.2895\tAvg Loss: 0.0000\nTrain Epoch: 73\t[15000/88956 (17%)]\tTotal Loss: 0.4306\tAvg Loss: 0.0000\nTrain Epoch: 73\t[20000/88956 (22%)]\tTotal Loss: 0.5652\tAvg Loss: 0.0000\nTrain Epoch: 73\t[25000/88956 (28%)]\tTotal Loss: 0.7045\tAvg Loss: 0.0000\nTrain Epoch: 73\t[30000/88956 (34%)]\tTotal Loss: 0.8452\tAvg Loss: 0.0000\nTrain Epoch: 73\t[35000/88956 (39%)]\tTotal Loss: 0.9945\tAvg Loss: 0.0000\nTrain Epoch: 73\t[40000/88956 (45%)]\tTotal Loss: 1.1387\tAvg Loss: 0.0000\nTrain Epoch: 73\t[45000/88956 (51%)]\tTotal Loss: 1.2717\tAvg Loss: 0.0000\nTrain Epoch: 73\t[50000/88956 (56%)]\tTotal Loss: 1.4117\tAvg Loss: 0.0000\nTrain Epoch: 73\t[55000/88956 (62%)]\tTotal Loss: 1.5738\tAvg Loss: 0.0000\nTrain Epoch: 73\t[60000/88956 (67%)]\tTotal Loss: 1.7158\tAvg Loss: 0.0000\nTrain Epoch: 73\t[65000/88956 (73%)]\tTotal Loss: 1.8773\tAvg Loss: 0.0000\nTrain Epoch: 73\t[70000/88956 (79%)]\tTotal Loss: 2.0374\tAvg Loss: 0.0000\nTrain Epoch: 73\t[75000/88956 (84%)]\tTotal Loss: 2.1933\tAvg Loss: 0.0000\nTrain Epoch: 73\t[80000/88956 (90%)]\tTotal Loss: 2.3412\tAvg Loss: 0.0000\nTrain Epoch: 73\t[85000/88956 (96%)]\tTotal Loss: 2.4877\tAvg Loss: 0.0000\n====> Epoch: 73\tTotal Loss: 2.6095\t Avg Loss: 0.0000\tCorrect: 71608/88956\tPercentage Correct: 80.50\n====> Val Loss: 0.4817\t Avg Loss: 0.0000\tCorrect: 6942/9885\tPercentage Correct: 70.23\n====> Test Loss: 1.1657\t Avg Loss: 0.0000\tCorrect: 17553/24711\tPercentage Correct: 71.03\nTrain Epoch: 74\t[5000/88956 (6%)]\tTotal Loss: 0.1427\tAvg Loss: 0.0000\nTrain Epoch: 74\t[10000/88956 (11%)]\tTotal Loss: 0.2820\tAvg Loss: 0.0000\nTrain Epoch: 74\t[15000/88956 (17%)]\tTotal Loss: 0.4282\tAvg Loss: 0.0000\nTrain Epoch: 74\t[20000/88956 (22%)]\tTotal Loss: 0.5714\tAvg Loss: 0.0000\nTrain Epoch: 74\t[25000/88956 (28%)]\tTotal Loss: 0.7150\tAvg Loss: 0.0000\nTrain Epoch: 74\t[30000/88956 (34%)]\tTotal Loss: 0.8786\tAvg Loss: 0.0000\nTrain Epoch: 74\t[35000/88956 (39%)]\tTotal Loss: 1.0259\tAvg Loss: 0.0000\nTrain Epoch: 74\t[40000/88956 (45%)]\tTotal Loss: 1.1727\tAvg Loss: 0.0000\nTrain Epoch: 74\t[45000/88956 (51%)]\tTotal Loss: 1.3188\tAvg Loss: 0.0000\nTrain Epoch: 74\t[50000/88956 (56%)]\tTotal Loss: 1.4707\tAvg Loss: 0.0000\nTrain Epoch: 74\t[55000/88956 (62%)]\tTotal Loss: 1.6363\tAvg Loss: 0.0000\nTrain Epoch: 74\t[60000/88956 (67%)]\tTotal Loss: 1.7839\tAvg Loss: 0.0000\nTrain Epoch: 74\t[65000/88956 (73%)]\tTotal Loss: 1.9390\tAvg Loss: 0.0000\nTrain Epoch: 74\t[70000/88956 (79%)]\tTotal Loss: 2.0872\tAvg Loss: 0.0000\nTrain Epoch: 74\t[75000/88956 (84%)]\tTotal Loss: 2.2464\tAvg Loss: 0.0000\nTrain Epoch: 74\t[80000/88956 (90%)]\tTotal Loss: 2.3921\tAvg Loss: 0.0000\nTrain Epoch: 74\t[85000/88956 (96%)]\tTotal Loss: 2.5496\tAvg Loss: 0.0000\n====> Epoch: 74\tTotal Loss: 2.6696\t Avg Loss: 0.0000\tCorrect: 71435/88956\tPercentage Correct: 80.30\n====> Val Loss: 0.4557\t Avg Loss: 0.0000\tCorrect: 7040/9885\tPercentage Correct: 71.22\n====> Test Loss: 1.1191\t Avg Loss: 0.0000\tCorrect: 17688/24711\tPercentage Correct: 71.58\n\n=== saved best model ===\n\nTrain Epoch: 75\t[5000/88956 (6%)]\tTotal Loss: 0.1480\tAvg Loss: 0.0000\nTrain Epoch: 75\t[10000/88956 (11%)]\tTotal Loss: 0.2874\tAvg Loss: 0.0000\nTrain Epoch: 75\t[15000/88956 (17%)]\tTotal Loss: 0.4273\tAvg Loss: 0.0000\nTrain Epoch: 75\t[20000/88956 (22%)]\tTotal Loss: 0.5627\tAvg Loss: 0.0000\nTrain Epoch: 75\t[25000/88956 (28%)]\tTotal Loss: 0.6979\tAvg Loss: 0.0000\nTrain Epoch: 75\t[30000/88956 (34%)]\tTotal Loss: 0.8487\tAvg Loss: 0.0000\nTrain Epoch: 75\t[35000/88956 (39%)]\tTotal Loss: 0.9958\tAvg Loss: 0.0000\nTrain Epoch: 75\t[40000/88956 (45%)]\tTotal Loss: 1.1372\tAvg Loss: 0.0000\nTrain Epoch: 75\t[45000/88956 (51%)]\tTotal Loss: 1.2900\tAvg Loss: 0.0000\nTrain Epoch: 75\t[50000/88956 (56%)]\tTotal Loss: 1.4363\tAvg Loss: 0.0000\nTrain Epoch: 75\t[55000/88956 (62%)]\tTotal Loss: 1.5890\tAvg Loss: 0.0000\nTrain Epoch: 75\t[60000/88956 (67%)]\tTotal Loss: 1.7661\tAvg Loss: 0.0000\nTrain Epoch: 75\t[65000/88956 (73%)]\tTotal Loss: 1.9141\tAvg Loss: 0.0000\nTrain Epoch: 75\t[70000/88956 (79%)]\tTotal Loss: 2.0611\tAvg Loss: 0.0000\nTrain Epoch: 75\t[75000/88956 (84%)]\tTotal Loss: 2.2064\tAvg Loss: 0.0000\nTrain Epoch: 75\t[80000/88956 (90%)]\tTotal Loss: 2.3600\tAvg Loss: 0.0000\nTrain Epoch: 75\t[85000/88956 (96%)]\tTotal Loss: 2.5074\tAvg Loss: 0.0000\n====> Epoch: 75\tTotal Loss: 2.6383\t Avg Loss: 0.0000\tCorrect: 71480/88956\tPercentage Correct: 80.35\n====> Val Loss: 0.4682\t Avg Loss: 0.0000\tCorrect: 7027/9885\tPercentage Correct: 71.09\n====> Test Loss: 1.1422\t Avg Loss: 0.0000\tCorrect: 17652/24711\tPercentage Correct: 71.43\nTrain Epoch: 76\t[5000/88956 (6%)]\tTotal Loss: 0.1355\tAvg Loss: 0.0000\nTrain Epoch: 76\t[10000/88956 (11%)]\tTotal Loss: 0.2671\tAvg Loss: 0.0000\nTrain Epoch: 76\t[15000/88956 (17%)]\tTotal Loss: 0.3997\tAvg Loss: 0.0000\nTrain Epoch: 76\t[20000/88956 (22%)]\tTotal Loss: 0.5302\tAvg Loss: 0.0000\nTrain Epoch: 76\t[25000/88956 (28%)]\tTotal Loss: 0.6598\tAvg Loss: 0.0000\nTrain Epoch: 76\t[30000/88956 (34%)]\tTotal Loss: 0.8010\tAvg Loss: 0.0000\nTrain Epoch: 76\t[35000/88956 (39%)]\tTotal Loss: 0.9426\tAvg Loss: 0.0000\nTrain Epoch: 76\t[40000/88956 (45%)]\tTotal Loss: 1.0988\tAvg Loss: 0.0000\nTrain Epoch: 76\t[45000/88956 (51%)]\tTotal Loss: 1.2419\tAvg Loss: 0.0000\nTrain Epoch: 76\t[50000/88956 (56%)]\tTotal Loss: 1.3887\tAvg Loss: 0.0000\nTrain Epoch: 76\t[55000/88956 (62%)]\tTotal Loss: 1.5306\tAvg Loss: 0.0000\nTrain Epoch: 76\t[60000/88956 (67%)]\tTotal Loss: 1.6766\tAvg Loss: 0.0000\nTrain Epoch: 76\t[65000/88956 (73%)]\tTotal Loss: 1.8242\tAvg Loss: 0.0000\nTrain Epoch: 76\t[70000/88956 (79%)]\tTotal Loss: 1.9871\tAvg Loss: 0.0000\nTrain Epoch: 76\t[75000/88956 (84%)]\tTotal Loss: 2.1240\tAvg Loss: 0.0000\nTrain Epoch: 76\t[80000/88956 (90%)]\tTotal Loss: 2.2721\tAvg Loss: 0.0000\nTrain Epoch: 76\t[85000/88956 (96%)]\tTotal Loss: 2.4165\tAvg Loss: 0.0000\n====> Epoch: 76\tTotal Loss: 2.5365\t Avg Loss: 0.0000\tCorrect: 71947/88956\tPercentage Correct: 80.88\n====> Val Loss: 0.4544\t Avg Loss: 0.0000\tCorrect: 7086/9885\tPercentage Correct: 71.68\n====> Test Loss: 1.1302\t Avg Loss: 0.0000\tCorrect: 17706/24711\tPercentage Correct: 71.65\n\n=== saved best model ===\n\nTrain Epoch: 77\t[5000/88956 (6%)]\tTotal Loss: 0.1331\tAvg Loss: 0.0000\nTrain Epoch: 77\t[10000/88956 (11%)]\tTotal Loss: 0.2787\tAvg Loss: 0.0000\nTrain Epoch: 77\t[15000/88956 (17%)]\tTotal Loss: 0.4147\tAvg Loss: 0.0000\nTrain Epoch: 77\t[20000/88956 (22%)]\tTotal Loss: 0.5517\tAvg Loss: 0.0000\nTrain Epoch: 77\t[25000/88956 (28%)]\tTotal Loss: 0.6907\tAvg Loss: 0.0000\nTrain Epoch: 77\t[30000/88956 (34%)]\tTotal Loss: 0.8375\tAvg Loss: 0.0000\nTrain Epoch: 77\t[35000/88956 (39%)]\tTotal Loss: 1.0011\tAvg Loss: 0.0000\nTrain Epoch: 77\t[40000/88956 (45%)]\tTotal Loss: 1.1391\tAvg Loss: 0.0000\nTrain Epoch: 77\t[45000/88956 (51%)]\tTotal Loss: 1.2750\tAvg Loss: 0.0000\nTrain Epoch: 77\t[50000/88956 (56%)]\tTotal Loss: 1.4093\tAvg Loss: 0.0000\nTrain Epoch: 77\t[55000/88956 (62%)]\tTotal Loss: 1.5552\tAvg Loss: 0.0000\nTrain Epoch: 77\t[60000/88956 (67%)]\tTotal Loss: 1.6967\tAvg Loss: 0.0000\nTrain Epoch: 77\t[65000/88956 (73%)]\tTotal Loss: 1.8269\tAvg Loss: 0.0000\nTrain Epoch: 77\t[70000/88956 (79%)]\tTotal Loss: 1.9648\tAvg Loss: 0.0000\nTrain Epoch: 77\t[75000/88956 (84%)]\tTotal Loss: 2.1124\tAvg Loss: 0.0000\nTrain Epoch: 77\t[80000/88956 (90%)]\tTotal Loss: 2.2653\tAvg Loss: 0.0000\nTrain Epoch: 77\t[85000/88956 (96%)]\tTotal Loss: 2.4129\tAvg Loss: 0.0000\n====> Epoch: 77\tTotal Loss: 2.5255\t Avg Loss: 0.0000\tCorrect: 71960/88956\tPercentage Correct: 80.89\n====> Val Loss: 0.4471\t Avg Loss: 0.0000\tCorrect: 7085/9885\tPercentage Correct: 71.67\n====> Test Loss: 1.0974\t Avg Loss: 0.0000\tCorrect: 17804/24711\tPercentage Correct: 72.05\nTrain Epoch: 78\t[5000/88956 (6%)]\tTotal Loss: 0.1220\tAvg Loss: 0.0000\nTrain Epoch: 78\t[10000/88956 (11%)]\tTotal Loss: 0.2484\tAvg Loss: 0.0000\nTrain Epoch: 78\t[15000/88956 (17%)]\tTotal Loss: 0.3678\tAvg Loss: 0.0000\nTrain Epoch: 78\t[20000/88956 (22%)]\tTotal Loss: 0.5514\tAvg Loss: 0.0000\nTrain Epoch: 78\t[25000/88956 (28%)]\tTotal Loss: 0.8216\tAvg Loss: 0.0000\nTrain Epoch: 78\t[30000/88956 (34%)]\tTotal Loss: 0.9903\tAvg Loss: 0.0000\nTrain Epoch: 78\t[35000/88956 (39%)]\tTotal Loss: 1.1463\tAvg Loss: 0.0000\nTrain Epoch: 78\t[40000/88956 (45%)]\tTotal Loss: 1.2862\tAvg Loss: 0.0000\nTrain Epoch: 78\t[45000/88956 (51%)]\tTotal Loss: 1.4339\tAvg Loss: 0.0000\nTrain Epoch: 78\t[50000/88956 (56%)]\tTotal Loss: 1.5642\tAvg Loss: 0.0000\nTrain Epoch: 78\t[55000/88956 (62%)]\tTotal Loss: 1.7031\tAvg Loss: 0.0000\nTrain Epoch: 78\t[60000/88956 (67%)]\tTotal Loss: 1.8508\tAvg Loss: 0.0000\nTrain Epoch: 78\t[65000/88956 (73%)]\tTotal Loss: 2.0047\tAvg Loss: 0.0000\nTrain Epoch: 78\t[70000/88956 (79%)]\tTotal Loss: 2.1519\tAvg Loss: 0.0000\nTrain Epoch: 78\t[75000/88956 (84%)]\tTotal Loss: 2.3002\tAvg Loss: 0.0000\nTrain Epoch: 78\t[80000/88956 (90%)]\tTotal Loss: 2.4347\tAvg Loss: 0.0000\nTrain Epoch: 78\t[85000/88956 (96%)]\tTotal Loss: 2.5690\tAvg Loss: 0.0000\n====> Epoch: 78\tTotal Loss: 2.6750\t Avg Loss: 0.0000\tCorrect: 71282/88956\tPercentage Correct: 80.13\n====> Val Loss: 0.4763\t Avg Loss: 0.0000\tCorrect: 7087/9885\tPercentage Correct: 71.69\n====> Test Loss: 1.1612\t Avg Loss: 0.0000\tCorrect: 17832/24711\tPercentage Correct: 72.16\n\n=== saved best model ===\n\nTrain Epoch: 79\t[5000/88956 (6%)]\tTotal Loss: 0.1308\tAvg Loss: 0.0000\nTrain Epoch: 79\t[10000/88956 (11%)]\tTotal Loss: 0.2621\tAvg Loss: 0.0000\nTrain Epoch: 79\t[15000/88956 (17%)]\tTotal Loss: 0.3957\tAvg Loss: 0.0000\nTrain Epoch: 79\t[20000/88956 (22%)]\tTotal Loss: 0.5321\tAvg Loss: 0.0000\nTrain Epoch: 79\t[25000/88956 (28%)]\tTotal Loss: 0.6760\tAvg Loss: 0.0000\nTrain Epoch: 79\t[30000/88956 (34%)]\tTotal Loss: 0.8151\tAvg Loss: 0.0000\nTrain Epoch: 79\t[35000/88956 (39%)]\tTotal Loss: 0.9379\tAvg Loss: 0.0000\nTrain Epoch: 79\t[40000/88956 (45%)]\tTotal Loss: 1.0894\tAvg Loss: 0.0000\nTrain Epoch: 79\t[45000/88956 (51%)]\tTotal Loss: 1.3160\tAvg Loss: 0.0000\nTrain Epoch: 79\t[50000/88956 (56%)]\tTotal Loss: 1.4700\tAvg Loss: 0.0000\nTrain Epoch: 79\t[55000/88956 (62%)]\tTotal Loss: 1.6087\tAvg Loss: 0.0000\nTrain Epoch: 79\t[60000/88956 (67%)]\tTotal Loss: 1.7558\tAvg Loss: 0.0000\nTrain Epoch: 79\t[65000/88956 (73%)]\tTotal Loss: 1.8931\tAvg Loss: 0.0000\nTrain Epoch: 79\t[70000/88956 (79%)]\tTotal Loss: 2.0367\tAvg Loss: 0.0000\nTrain Epoch: 79\t[75000/88956 (84%)]\tTotal Loss: 2.1725\tAvg Loss: 0.0000\nTrain Epoch: 79\t[80000/88956 (90%)]\tTotal Loss: 2.3232\tAvg Loss: 0.0000\nTrain Epoch: 79\t[85000/88956 (96%)]\tTotal Loss: 2.4621\tAvg Loss: 0.0000\n====> Epoch: 79\tTotal Loss: 2.5868\t Avg Loss: 0.0000\tCorrect: 71630/88956\tPercentage Correct: 80.52\n====> Val Loss: 0.4619\t Avg Loss: 0.0000\tCorrect: 7041/9885\tPercentage Correct: 71.23\n====> Test Loss: 1.1051\t Avg Loss: 0.0000\tCorrect: 17736/24711\tPercentage Correct: 71.77\nTrain Epoch: 80\t[5000/88956 (6%)]\tTotal Loss: 0.1243\tAvg Loss: 0.0000\nTrain Epoch: 80\t[10000/88956 (11%)]\tTotal Loss: 0.2481\tAvg Loss: 0.0000\nTrain Epoch: 80\t[15000/88956 (17%)]\tTotal Loss: 0.3707\tAvg Loss: 0.0000\nTrain Epoch: 80\t[20000/88956 (22%)]\tTotal Loss: 0.4897\tAvg Loss: 0.0000\nTrain Epoch: 80\t[25000/88956 (28%)]\tTotal Loss: 0.6080\tAvg Loss: 0.0000\nTrain Epoch: 80\t[30000/88956 (34%)]\tTotal Loss: 0.7322\tAvg Loss: 0.0000\nTrain Epoch: 80\t[35000/88956 (39%)]\tTotal Loss: 0.8823\tAvg Loss: 0.0000\nTrain Epoch: 80\t[40000/88956 (45%)]\tTotal Loss: 1.0247\tAvg Loss: 0.0000\nTrain Epoch: 80\t[45000/88956 (51%)]\tTotal Loss: 1.1713\tAvg Loss: 0.0000\nTrain Epoch: 80\t[50000/88956 (56%)]\tTotal Loss: 1.2977\tAvg Loss: 0.0000\nTrain Epoch: 80\t[55000/88956 (62%)]\tTotal Loss: 1.4360\tAvg Loss: 0.0000\nTrain Epoch: 80\t[60000/88956 (67%)]\tTotal Loss: 1.5715\tAvg Loss: 0.0000\nTrain Epoch: 80\t[65000/88956 (73%)]\tTotal Loss: 1.7072\tAvg Loss: 0.0000\nTrain Epoch: 80\t[70000/88956 (79%)]\tTotal Loss: 1.8380\tAvg Loss: 0.0000\nTrain Epoch: 80\t[75000/88956 (84%)]\tTotal Loss: 1.9777\tAvg Loss: 0.0000\nTrain Epoch: 80\t[80000/88956 (90%)]\tTotal Loss: 2.1176\tAvg Loss: 0.0000\nTrain Epoch: 80\t[85000/88956 (96%)]\tTotal Loss: 2.2530\tAvg Loss: 0.0000\n====> Epoch: 80\tTotal Loss: 2.3549\t Avg Loss: 0.0000\tCorrect: 72838/88956\tPercentage Correct: 81.88\n====> Val Loss: 0.4734\t Avg Loss: 0.0000\tCorrect: 7063/9885\tPercentage Correct: 71.45\n====> Test Loss: 1.1425\t Avg Loss: 0.0000\tCorrect: 17812/24711\tPercentage Correct: 72.08\nTrain Epoch: 81\t[5000/88956 (6%)]\tTotal Loss: 0.1346\tAvg Loss: 0.0000\nTrain Epoch: 81\t[10000/88956 (11%)]\tTotal Loss: 0.2466\tAvg Loss: 0.0000\nTrain Epoch: 81\t[15000/88956 (17%)]\tTotal Loss: 0.3775\tAvg Loss: 0.0000\nTrain Epoch: 81\t[20000/88956 (22%)]\tTotal Loss: 0.5076\tAvg Loss: 0.0000\nTrain Epoch: 81\t[25000/88956 (28%)]\tTotal Loss: 0.6417\tAvg Loss: 0.0000\nTrain Epoch: 81\t[30000/88956 (34%)]\tTotal Loss: 0.7688\tAvg Loss: 0.0000\nTrain Epoch: 81\t[35000/88956 (39%)]\tTotal Loss: 0.8989\tAvg Loss: 0.0000\nTrain Epoch: 81\t[40000/88956 (45%)]\tTotal Loss: 1.0376\tAvg Loss: 0.0000\nTrain Epoch: 81\t[45000/88956 (51%)]\tTotal Loss: 1.1633\tAvg Loss: 0.0000\nTrain Epoch: 81\t[50000/88956 (56%)]\tTotal Loss: 1.2902\tAvg Loss: 0.0000\nTrain Epoch: 81\t[55000/88956 (62%)]\tTotal Loss: 1.4112\tAvg Loss: 0.0000\nTrain Epoch: 81\t[60000/88956 (67%)]\tTotal Loss: 1.5474\tAvg Loss: 0.0000\nTrain Epoch: 81\t[65000/88956 (73%)]\tTotal Loss: 1.7041\tAvg Loss: 0.0000\nTrain Epoch: 81\t[70000/88956 (79%)]\tTotal Loss: 1.8348\tAvg Loss: 0.0000\nTrain Epoch: 81\t[75000/88956 (84%)]\tTotal Loss: 1.9742\tAvg Loss: 0.0000\nTrain Epoch: 81\t[80000/88956 (90%)]\tTotal Loss: 2.1097\tAvg Loss: 0.0000\nTrain Epoch: 81\t[85000/88956 (96%)]\tTotal Loss: 2.2470\tAvg Loss: 0.0000\n====> Epoch: 81\tTotal Loss: 2.3513\t Avg Loss: 0.0000\tCorrect: 73049/88956\tPercentage Correct: 82.12\n====> Val Loss: 0.4332\t Avg Loss: 0.0000\tCorrect: 7219/9885\tPercentage Correct: 73.03\n====> Test Loss: 1.0628\t Avg Loss: 0.0000\tCorrect: 18015/24711\tPercentage Correct: 72.90\n\n=== saved best model ===\n\nTrain Epoch: 82\t[5000/88956 (6%)]\tTotal Loss: 0.1269\tAvg Loss: 0.0000\nTrain Epoch: 82\t[10000/88956 (11%)]\tTotal Loss: 0.2489\tAvg Loss: 0.0000\nTrain Epoch: 82\t[15000/88956 (17%)]\tTotal Loss: 0.3834\tAvg Loss: 0.0000\nTrain Epoch: 82\t[20000/88956 (22%)]\tTotal Loss: 0.4981\tAvg Loss: 0.0000\nTrain Epoch: 82\t[25000/88956 (28%)]\tTotal Loss: 0.6355\tAvg Loss: 0.0000\nTrain Epoch: 82\t[30000/88956 (34%)]\tTotal Loss: 0.7646\tAvg Loss: 0.0000\nTrain Epoch: 82\t[35000/88956 (39%)]\tTotal Loss: 0.8960\tAvg Loss: 0.0000\nTrain Epoch: 82\t[40000/88956 (45%)]\tTotal Loss: 1.0348\tAvg Loss: 0.0000\nTrain Epoch: 82\t[45000/88956 (51%)]\tTotal Loss: 1.1624\tAvg Loss: 0.0000\nTrain Epoch: 82\t[50000/88956 (56%)]\tTotal Loss: 1.2979\tAvg Loss: 0.0000\nTrain Epoch: 82\t[55000/88956 (62%)]\tTotal Loss: 1.4294\tAvg Loss: 0.0000\nTrain Epoch: 82\t[60000/88956 (67%)]\tTotal Loss: 1.5739\tAvg Loss: 0.0000\nTrain Epoch: 82\t[65000/88956 (73%)]\tTotal Loss: 1.7077\tAvg Loss: 0.0000\nTrain Epoch: 82\t[70000/88956 (79%)]\tTotal Loss: 1.8551\tAvg Loss: 0.0000\nTrain Epoch: 82\t[75000/88956 (84%)]\tTotal Loss: 1.9849\tAvg Loss: 0.0000\nTrain Epoch: 82\t[80000/88956 (90%)]\tTotal Loss: 2.1141\tAvg Loss: 0.0000\nTrain Epoch: 82\t[85000/88956 (96%)]\tTotal Loss: 2.2625\tAvg Loss: 0.0000\n====> Epoch: 82\tTotal Loss: 2.3654\t Avg Loss: 0.0000\tCorrect: 72853/88956\tPercentage Correct: 81.90\n====> Val Loss: 0.5101\t Avg Loss: 0.0001\tCorrect: 6963/9885\tPercentage Correct: 70.44\n====> Test Loss: 1.2397\t Avg Loss: 0.0001\tCorrect: 17523/24711\tPercentage Correct: 70.91\nTrain Epoch: 83\t[5000/88956 (6%)]\tTotal Loss: 0.1310\tAvg Loss: 0.0000\nTrain Epoch: 83\t[10000/88956 (11%)]\tTotal Loss: 0.2447\tAvg Loss: 0.0000\nTrain Epoch: 83\t[15000/88956 (17%)]\tTotal Loss: 0.3517\tAvg Loss: 0.0000\nTrain Epoch: 83\t[20000/88956 (22%)]\tTotal Loss: 0.4836\tAvg Loss: 0.0000\nTrain Epoch: 83\t[25000/88956 (28%)]\tTotal Loss: 0.6169\tAvg Loss: 0.0000\nTrain Epoch: 83\t[30000/88956 (34%)]\tTotal Loss: 0.7496\tAvg Loss: 0.0000\nTrain Epoch: 83\t[35000/88956 (39%)]\tTotal Loss: 0.8775\tAvg Loss: 0.0000\nTrain Epoch: 83\t[40000/88956 (45%)]\tTotal Loss: 1.0101\tAvg Loss: 0.0000\nTrain Epoch: 83\t[45000/88956 (51%)]\tTotal Loss: 1.1342\tAvg Loss: 0.0000\nTrain Epoch: 83\t[50000/88956 (56%)]\tTotal Loss: 1.2656\tAvg Loss: 0.0000\nTrain Epoch: 83\t[55000/88956 (62%)]\tTotal Loss: 1.4159\tAvg Loss: 0.0000\nTrain Epoch: 83\t[60000/88956 (67%)]\tTotal Loss: 1.5595\tAvg Loss: 0.0000\nTrain Epoch: 83\t[65000/88956 (73%)]\tTotal Loss: 1.6987\tAvg Loss: 0.0000\nTrain Epoch: 83\t[70000/88956 (79%)]\tTotal Loss: 1.8431\tAvg Loss: 0.0000\nTrain Epoch: 83\t[75000/88956 (84%)]\tTotal Loss: 1.9824\tAvg Loss: 0.0000\nTrain Epoch: 83\t[80000/88956 (90%)]\tTotal Loss: 2.1180\tAvg Loss: 0.0000\nTrain Epoch: 83\t[85000/88956 (96%)]\tTotal Loss: 2.2638\tAvg Loss: 0.0000\n====> Epoch: 83\tTotal Loss: 2.3667\t Avg Loss: 0.0000\tCorrect: 72833/88956\tPercentage Correct: 81.88\n====> Val Loss: 0.4665\t Avg Loss: 0.0000\tCorrect: 7051/9885\tPercentage Correct: 71.33\n====> Test Loss: 1.1316\t Avg Loss: 0.0000\tCorrect: 17765/24711\tPercentage Correct: 71.89\nTrain Epoch: 84\t[5000/88956 (6%)]\tTotal Loss: 0.1298\tAvg Loss: 0.0000\nTrain Epoch: 84\t[10000/88956 (11%)]\tTotal Loss: 0.2519\tAvg Loss: 0.0000\nTrain Epoch: 84\t[15000/88956 (17%)]\tTotal Loss: 0.3678\tAvg Loss: 0.0000\nTrain Epoch: 84\t[20000/88956 (22%)]\tTotal Loss: 0.4948\tAvg Loss: 0.0000\nTrain Epoch: 84\t[25000/88956 (28%)]\tTotal Loss: 0.6189\tAvg Loss: 0.0000\nTrain Epoch: 84\t[30000/88956 (34%)]\tTotal Loss: 0.7470\tAvg Loss: 0.0000\nTrain Epoch: 84\t[35000/88956 (39%)]\tTotal Loss: 0.8888\tAvg Loss: 0.0000\nTrain Epoch: 84\t[40000/88956 (45%)]\tTotal Loss: 1.0303\tAvg Loss: 0.0000\nTrain Epoch: 84\t[45000/88956 (51%)]\tTotal Loss: 1.1616\tAvg Loss: 0.0000\nTrain Epoch: 84\t[50000/88956 (56%)]\tTotal Loss: 1.2981\tAvg Loss: 0.0000\nTrain Epoch: 84\t[55000/88956 (62%)]\tTotal Loss: 1.4244\tAvg Loss: 0.0000\nTrain Epoch: 84\t[60000/88956 (67%)]\tTotal Loss: 1.5533\tAvg Loss: 0.0000\nTrain Epoch: 84\t[65000/88956 (73%)]\tTotal Loss: 1.6857\tAvg Loss: 0.0000\nTrain Epoch: 84\t[70000/88956 (79%)]\tTotal Loss: 1.8078\tAvg Loss: 0.0000\nTrain Epoch: 84\t[75000/88956 (84%)]\tTotal Loss: 1.9445\tAvg Loss: 0.0000\nTrain Epoch: 84\t[80000/88956 (90%)]\tTotal Loss: 2.0779\tAvg Loss: 0.0000\nTrain Epoch: 84\t[85000/88956 (96%)]\tTotal Loss: 2.2049\tAvg Loss: 0.0000\n====> Epoch: 84\tTotal Loss: 2.3089\t Avg Loss: 0.0000\tCorrect: 73114/88956\tPercentage Correct: 82.19\n====> Val Loss: 0.4646\t Avg Loss: 0.0000\tCorrect: 7084/9885\tPercentage Correct: 71.66\n====> Test Loss: 1.1139\t Avg Loss: 0.0000\tCorrect: 17885/24711\tPercentage Correct: 72.38\nTrain Epoch: 85\t[5000/88956 (6%)]\tTotal Loss: 0.1248\tAvg Loss: 0.0000\nTrain Epoch: 85\t[10000/88956 (11%)]\tTotal Loss: 0.2445\tAvg Loss: 0.0000\nTrain Epoch: 85\t[15000/88956 (17%)]\tTotal Loss: 0.3661\tAvg Loss: 0.0000\nTrain Epoch: 85\t[20000/88956 (22%)]\tTotal Loss: 0.4879\tAvg Loss: 0.0000\nTrain Epoch: 85\t[25000/88956 (28%)]\tTotal Loss: 0.6122\tAvg Loss: 0.0000\nTrain Epoch: 85\t[30000/88956 (34%)]\tTotal Loss: 0.7398\tAvg Loss: 0.0000\nTrain Epoch: 85\t[35000/88956 (39%)]\tTotal Loss: 0.8732\tAvg Loss: 0.0000\nTrain Epoch: 85\t[40000/88956 (45%)]\tTotal Loss: 1.0016\tAvg Loss: 0.0000\nTrain Epoch: 85\t[45000/88956 (51%)]\tTotal Loss: 1.1356\tAvg Loss: 0.0000\nTrain Epoch: 85\t[50000/88956 (56%)]\tTotal Loss: 1.2586\tAvg Loss: 0.0000\nTrain Epoch: 85\t[55000/88956 (62%)]\tTotal Loss: 1.3939\tAvg Loss: 0.0000\nTrain Epoch: 85\t[60000/88956 (67%)]\tTotal Loss: 1.5236\tAvg Loss: 0.0000\nTrain Epoch: 85\t[65000/88956 (73%)]\tTotal Loss: 1.6642\tAvg Loss: 0.0000\nTrain Epoch: 85\t[70000/88956 (79%)]\tTotal Loss: 1.7939\tAvg Loss: 0.0000\nTrain Epoch: 85\t[75000/88956 (84%)]\tTotal Loss: 1.9217\tAvg Loss: 0.0000\nTrain Epoch: 85\t[80000/88956 (90%)]\tTotal Loss: 2.0545\tAvg Loss: 0.0000\nTrain Epoch: 85\t[85000/88956 (96%)]\tTotal Loss: 2.2056\tAvg Loss: 0.0000\n====> Epoch: 85\tTotal Loss: 2.3261\t Avg Loss: 0.0000\tCorrect: 73216/88956\tPercentage Correct: 82.31\n====> Val Loss: 0.5435\t Avg Loss: 0.0001\tCorrect: 6703/9885\tPercentage Correct: 67.81\n====> Test Loss: 1.3366\t Avg Loss: 0.0001\tCorrect: 16833/24711\tPercentage Correct: 68.12\nTrain Epoch: 86\t[5000/88956 (6%)]\tTotal Loss: 0.1705\tAvg Loss: 0.0000\nTrain Epoch: 86\t[10000/88956 (11%)]\tTotal Loss: 0.3549\tAvg Loss: 0.0000\nTrain Epoch: 86\t[15000/88956 (17%)]\tTotal Loss: 0.4954\tAvg Loss: 0.0000\nTrain Epoch: 86\t[20000/88956 (22%)]\tTotal Loss: 0.6266\tAvg Loss: 0.0000\nTrain Epoch: 86\t[25000/88956 (28%)]\tTotal Loss: 0.7535\tAvg Loss: 0.0000\nTrain Epoch: 86\t[30000/88956 (34%)]\tTotal Loss: 0.8915\tAvg Loss: 0.0000\nTrain Epoch: 86\t[35000/88956 (39%)]\tTotal Loss: 1.0188\tAvg Loss: 0.0000\nTrain Epoch: 86\t[40000/88956 (45%)]\tTotal Loss: 1.1415\tAvg Loss: 0.0000\nTrain Epoch: 86\t[45000/88956 (51%)]\tTotal Loss: 1.2681\tAvg Loss: 0.0000\nTrain Epoch: 86\t[50000/88956 (56%)]\tTotal Loss: 1.3896\tAvg Loss: 0.0000\nTrain Epoch: 86\t[55000/88956 (62%)]\tTotal Loss: 1.5131\tAvg Loss: 0.0000\nTrain Epoch: 86\t[60000/88956 (67%)]\tTotal Loss: 1.6401\tAvg Loss: 0.0000\nTrain Epoch: 86\t[65000/88956 (73%)]\tTotal Loss: 1.7713\tAvg Loss: 0.0000\nTrain Epoch: 86\t[70000/88956 (79%)]\tTotal Loss: 1.8957\tAvg Loss: 0.0000\nTrain Epoch: 86\t[75000/88956 (84%)]\tTotal Loss: 2.0247\tAvg Loss: 0.0000\nTrain Epoch: 86\t[80000/88956 (90%)]\tTotal Loss: 2.1610\tAvg Loss: 0.0000\nTrain Epoch: 86\t[85000/88956 (96%)]\tTotal Loss: 2.2843\tAvg Loss: 0.0000\n====> Epoch: 86\tTotal Loss: 2.3906\t Avg Loss: 0.0000\tCorrect: 72534/88956\tPercentage Correct: 81.54\n====> Val Loss: 0.4558\t Avg Loss: 0.0000\tCorrect: 7048/9885\tPercentage Correct: 71.30\n====> Test Loss: 1.0953\t Avg Loss: 0.0000\tCorrect: 17807/24711\tPercentage Correct: 72.06\nTrain Epoch: 87\t[5000/88956 (6%)]\tTotal Loss: 0.1366\tAvg Loss: 0.0000\nTrain Epoch: 87\t[10000/88956 (11%)]\tTotal Loss: 0.2497\tAvg Loss: 0.0000\nTrain Epoch: 87\t[15000/88956 (17%)]\tTotal Loss: 0.3655\tAvg Loss: 0.0000\nTrain Epoch: 87\t[20000/88956 (22%)]\tTotal Loss: 0.4791\tAvg Loss: 0.0000\nTrain Epoch: 87\t[25000/88956 (28%)]\tTotal Loss: 0.6029\tAvg Loss: 0.0000\nTrain Epoch: 87\t[30000/88956 (34%)]\tTotal Loss: 0.7220\tAvg Loss: 0.0000\nTrain Epoch: 87\t[35000/88956 (39%)]\tTotal Loss: 0.8366\tAvg Loss: 0.0000\nTrain Epoch: 87\t[40000/88956 (45%)]\tTotal Loss: 0.9523\tAvg Loss: 0.0000\nTrain Epoch: 87\t[45000/88956 (51%)]\tTotal Loss: 1.0706\tAvg Loss: 0.0000\nTrain Epoch: 87\t[50000/88956 (56%)]\tTotal Loss: 1.2045\tAvg Loss: 0.0000\nTrain Epoch: 87\t[55000/88956 (62%)]\tTotal Loss: 1.3314\tAvg Loss: 0.0000\nTrain Epoch: 87\t[60000/88956 (67%)]\tTotal Loss: 1.4504\tAvg Loss: 0.0000\nTrain Epoch: 87\t[65000/88956 (73%)]\tTotal Loss: 1.5673\tAvg Loss: 0.0000\nTrain Epoch: 87\t[70000/88956 (79%)]\tTotal Loss: 1.6869\tAvg Loss: 0.0000\nTrain Epoch: 87\t[75000/88956 (84%)]\tTotal Loss: 1.8142\tAvg Loss: 0.0000\nTrain Epoch: 87\t[80000/88956 (90%)]\tTotal Loss: 1.9484\tAvg Loss: 0.0000\nTrain Epoch: 87\t[85000/88956 (96%)]\tTotal Loss: 2.0764\tAvg Loss: 0.0000\n====> Epoch: 87\tTotal Loss: 2.1788\t Avg Loss: 0.0000\tCorrect: 74028/88956\tPercentage Correct: 83.22\n====> Val Loss: 0.4331\t Avg Loss: 0.0000\tCorrect: 7080/9885\tPercentage Correct: 71.62\n====> Test Loss: 1.0872\t Avg Loss: 0.0000\tCorrect: 17753/24711\tPercentage Correct: 71.84\nTrain Epoch: 88\t[5000/88956 (6%)]\tTotal Loss: 0.1170\tAvg Loss: 0.0000\nTrain Epoch: 88\t[10000/88956 (11%)]\tTotal Loss: 0.2377\tAvg Loss: 0.0000\nTrain Epoch: 88\t[15000/88956 (17%)]\tTotal Loss: 0.3623\tAvg Loss: 0.0000\nTrain Epoch: 88\t[20000/88956 (22%)]\tTotal Loss: 0.4873\tAvg Loss: 0.0000\nTrain Epoch: 88\t[25000/88956 (28%)]\tTotal Loss: 0.6091\tAvg Loss: 0.0000\nTrain Epoch: 88\t[30000/88956 (34%)]\tTotal Loss: 0.7322\tAvg Loss: 0.0000\nTrain Epoch: 88\t[35000/88956 (39%)]\tTotal Loss: 0.8518\tAvg Loss: 0.0000\nTrain Epoch: 88\t[40000/88956 (45%)]\tTotal Loss: 0.9682\tAvg Loss: 0.0000\nTrain Epoch: 88\t[45000/88956 (51%)]\tTotal Loss: 1.1029\tAvg Loss: 0.0000\nTrain Epoch: 88\t[50000/88956 (56%)]\tTotal Loss: 1.2412\tAvg Loss: 0.0000\nTrain Epoch: 88\t[55000/88956 (62%)]\tTotal Loss: 1.3570\tAvg Loss: 0.0000\nTrain Epoch: 88\t[60000/88956 (67%)]\tTotal Loss: 1.4684\tAvg Loss: 0.0000\nTrain Epoch: 88\t[65000/88956 (73%)]\tTotal Loss: 1.5979\tAvg Loss: 0.0000\nTrain Epoch: 88\t[70000/88956 (79%)]\tTotal Loss: 1.7211\tAvg Loss: 0.0000\nTrain Epoch: 88\t[75000/88956 (84%)]\tTotal Loss: 1.8404\tAvg Loss: 0.0000\nTrain Epoch: 88\t[80000/88956 (90%)]\tTotal Loss: 1.9699\tAvg Loss: 0.0000\nTrain Epoch: 88\t[85000/88956 (96%)]\tTotal Loss: 2.0928\tAvg Loss: 0.0000\n====> Epoch: 88\tTotal Loss: 2.1949\t Avg Loss: 0.0000\tCorrect: 73751/88956\tPercentage Correct: 82.91\n====> Val Loss: 0.4483\t Avg Loss: 0.0000\tCorrect: 7128/9885\tPercentage Correct: 72.11\n====> Test Loss: 1.0827\t Avg Loss: 0.0000\tCorrect: 17856/24711\tPercentage Correct: 72.26\nTrain Epoch: 89\t[5000/88956 (6%)]\tTotal Loss: 0.1094\tAvg Loss: 0.0000\nTrain Epoch: 89\t[10000/88956 (11%)]\tTotal Loss: 0.2199\tAvg Loss: 0.0000\nTrain Epoch: 89\t[15000/88956 (17%)]\tTotal Loss: 0.3329\tAvg Loss: 0.0000\nTrain Epoch: 89\t[20000/88956 (22%)]\tTotal Loss: 0.4542\tAvg Loss: 0.0000\nTrain Epoch: 89\t[25000/88956 (28%)]\tTotal Loss: 0.5681\tAvg Loss: 0.0000\nTrain Epoch: 89\t[30000/88956 (34%)]\tTotal Loss: 0.6899\tAvg Loss: 0.0000\nTrain Epoch: 89\t[35000/88956 (39%)]\tTotal Loss: 0.8145\tAvg Loss: 0.0000\nTrain Epoch: 89\t[40000/88956 (45%)]\tTotal Loss: 0.9387\tAvg Loss: 0.0000\nTrain Epoch: 89\t[45000/88956 (51%)]\tTotal Loss: 1.0820\tAvg Loss: 0.0000\nTrain Epoch: 89\t[50000/88956 (56%)]\tTotal Loss: 1.2041\tAvg Loss: 0.0000\nTrain Epoch: 89\t[55000/88956 (62%)]\tTotal Loss: 1.3254\tAvg Loss: 0.0000\nTrain Epoch: 89\t[60000/88956 (67%)]\tTotal Loss: 1.4525\tAvg Loss: 0.0000\nTrain Epoch: 89\t[65000/88956 (73%)]\tTotal Loss: 1.6065\tAvg Loss: 0.0000\nTrain Epoch: 89\t[70000/88956 (79%)]\tTotal Loss: 1.7313\tAvg Loss: 0.0000\nTrain Epoch: 89\t[75000/88956 (84%)]\tTotal Loss: 1.8684\tAvg Loss: 0.0000\nTrain Epoch: 89\t[80000/88956 (90%)]\tTotal Loss: 1.9998\tAvg Loss: 0.0000\nTrain Epoch: 89\t[85000/88956 (96%)]\tTotal Loss: 2.1214\tAvg Loss: 0.0000\n====> Epoch: 89\tTotal Loss: 2.2094\t Avg Loss: 0.0000\tCorrect: 73819/88956\tPercentage Correct: 82.98\n====> Val Loss: 0.4076\t Avg Loss: 0.0000\tCorrect: 7260/9885\tPercentage Correct: 73.44\n====> Test Loss: 1.0189\t Avg Loss: 0.0000\tCorrect: 18203/24711\tPercentage Correct: 73.66\n\n=== saved best model ===\n\nTrain Epoch: 90\t[5000/88956 (6%)]\tTotal Loss: 0.1069\tAvg Loss: 0.0000\nTrain Epoch: 90\t[10000/88956 (11%)]\tTotal Loss: 0.2153\tAvg Loss: 0.0000\nTrain Epoch: 90\t[15000/88956 (17%)]\tTotal Loss: 0.3289\tAvg Loss: 0.0000\nTrain Epoch: 90\t[20000/88956 (22%)]\tTotal Loss: 0.4538\tAvg Loss: 0.0000\nTrain Epoch: 90\t[25000/88956 (28%)]\tTotal Loss: 0.5776\tAvg Loss: 0.0000\nTrain Epoch: 90\t[30000/88956 (34%)]\tTotal Loss: 0.7103\tAvg Loss: 0.0000\nTrain Epoch: 90\t[35000/88956 (39%)]\tTotal Loss: 0.8307\tAvg Loss: 0.0000\nTrain Epoch: 90\t[40000/88956 (45%)]\tTotal Loss: 0.9444\tAvg Loss: 0.0000\nTrain Epoch: 90\t[45000/88956 (51%)]\tTotal Loss: 1.0782\tAvg Loss: 0.0000\nTrain Epoch: 90\t[50000/88956 (56%)]\tTotal Loss: 1.1935\tAvg Loss: 0.0000\nTrain Epoch: 90\t[55000/88956 (62%)]\tTotal Loss: 1.3224\tAvg Loss: 0.0000\nTrain Epoch: 90\t[60000/88956 (67%)]\tTotal Loss: 1.4508\tAvg Loss: 0.0000\nTrain Epoch: 90\t[65000/88956 (73%)]\tTotal Loss: 1.5858\tAvg Loss: 0.0000\nTrain Epoch: 90\t[70000/88956 (79%)]\tTotal Loss: 1.7189\tAvg Loss: 0.0000\nTrain Epoch: 90\t[75000/88956 (84%)]\tTotal Loss: 1.8429\tAvg Loss: 0.0000\nTrain Epoch: 90\t[80000/88956 (90%)]\tTotal Loss: 1.9714\tAvg Loss: 0.0000\nTrain Epoch: 90\t[85000/88956 (96%)]\tTotal Loss: 2.0990\tAvg Loss: 0.0000\n====> Epoch: 90\tTotal Loss: 2.2022\t Avg Loss: 0.0000\tCorrect: 73783/88956\tPercentage Correct: 82.94\n====> Val Loss: 0.4338\t Avg Loss: 0.0000\tCorrect: 7166/9885\tPercentage Correct: 72.49\n====> Test Loss: 1.0610\t Avg Loss: 0.0000\tCorrect: 18024/24711\tPercentage Correct: 72.94\nTrain Epoch: 91\t[5000/88956 (6%)]\tTotal Loss: 0.1172\tAvg Loss: 0.0000\nTrain Epoch: 91\t[10000/88956 (11%)]\tTotal Loss: 0.2156\tAvg Loss: 0.0000\nTrain Epoch: 91\t[15000/88956 (17%)]\tTotal Loss: 0.3326\tAvg Loss: 0.0000\nTrain Epoch: 91\t[20000/88956 (22%)]\tTotal Loss: 0.4595\tAvg Loss: 0.0000\nTrain Epoch: 91\t[25000/88956 (28%)]\tTotal Loss: 0.5738\tAvg Loss: 0.0000\nTrain Epoch: 91\t[30000/88956 (34%)]\tTotal Loss: 0.7053\tAvg Loss: 0.0000\nTrain Epoch: 91\t[35000/88956 (39%)]\tTotal Loss: 0.8197\tAvg Loss: 0.0000\nTrain Epoch: 91\t[40000/88956 (45%)]\tTotal Loss: 0.9346\tAvg Loss: 0.0000\nTrain Epoch: 91\t[45000/88956 (51%)]\tTotal Loss: 1.0522\tAvg Loss: 0.0000\nTrain Epoch: 91\t[50000/88956 (56%)]\tTotal Loss: 1.1897\tAvg Loss: 0.0000\nTrain Epoch: 91\t[55000/88956 (62%)]\tTotal Loss: 1.3045\tAvg Loss: 0.0000\nTrain Epoch: 91\t[60000/88956 (67%)]\tTotal Loss: 1.4294\tAvg Loss: 0.0000\nTrain Epoch: 91\t[65000/88956 (73%)]\tTotal Loss: 1.5657\tAvg Loss: 0.0000\nTrain Epoch: 91\t[70000/88956 (79%)]\tTotal Loss: 1.6901\tAvg Loss: 0.0000\nTrain Epoch: 91\t[75000/88956 (84%)]\tTotal Loss: 1.8151\tAvg Loss: 0.0000\nTrain Epoch: 91\t[80000/88956 (90%)]\tTotal Loss: 1.9567\tAvg Loss: 0.0000\nTrain Epoch: 91\t[85000/88956 (96%)]\tTotal Loss: 2.0858\tAvg Loss: 0.0000\n====> Epoch: 91\tTotal Loss: 2.1864\t Avg Loss: 0.0000\tCorrect: 73919/88956\tPercentage Correct: 83.10\n====> Val Loss: 0.4247\t Avg Loss: 0.0000\tCorrect: 7145/9885\tPercentage Correct: 72.28\n====> Test Loss: 1.0853\t Avg Loss: 0.0000\tCorrect: 17766/24711\tPercentage Correct: 71.90\nTrain Epoch: 92\t[5000/88956 (6%)]\tTotal Loss: 0.1078\tAvg Loss: 0.0000\nTrain Epoch: 92\t[10000/88956 (11%)]\tTotal Loss: 0.2207\tAvg Loss: 0.0000\nTrain Epoch: 92\t[15000/88956 (17%)]\tTotal Loss: 0.3398\tAvg Loss: 0.0000\nTrain Epoch: 92\t[20000/88956 (22%)]\tTotal Loss: 0.4589\tAvg Loss: 0.0000\nTrain Epoch: 92\t[25000/88956 (28%)]\tTotal Loss: 0.5687\tAvg Loss: 0.0000\nTrain Epoch: 92\t[30000/88956 (34%)]\tTotal Loss: 0.6843\tAvg Loss: 0.0000\nTrain Epoch: 92\t[35000/88956 (39%)]\tTotal Loss: 0.8074\tAvg Loss: 0.0000\nTrain Epoch: 92\t[40000/88956 (45%)]\tTotal Loss: 0.9327\tAvg Loss: 0.0000\nTrain Epoch: 92\t[45000/88956 (51%)]\tTotal Loss: 1.0545\tAvg Loss: 0.0000\nTrain Epoch: 92\t[50000/88956 (56%)]\tTotal Loss: 1.1696\tAvg Loss: 0.0000\nTrain Epoch: 92\t[55000/88956 (62%)]\tTotal Loss: 1.2994\tAvg Loss: 0.0000\nTrain Epoch: 92\t[60000/88956 (67%)]\tTotal Loss: 1.4204\tAvg Loss: 0.0000\nTrain Epoch: 92\t[65000/88956 (73%)]\tTotal Loss: 1.5326\tAvg Loss: 0.0000\nTrain Epoch: 92\t[70000/88956 (79%)]\tTotal Loss: 1.6661\tAvg Loss: 0.0000\nTrain Epoch: 92\t[75000/88956 (84%)]\tTotal Loss: 1.7987\tAvg Loss: 0.0000\nTrain Epoch: 92\t[80000/88956 (90%)]\tTotal Loss: 1.9242\tAvg Loss: 0.0000\nTrain Epoch: 92\t[85000/88956 (96%)]\tTotal Loss: 2.0682\tAvg Loss: 0.0000\n====> Epoch: 92\tTotal Loss: 2.1708\t Avg Loss: 0.0000\tCorrect: 74172/88956\tPercentage Correct: 83.38\n====> Val Loss: 0.4604\t Avg Loss: 0.0000\tCorrect: 6988/9885\tPercentage Correct: 70.69\n====> Test Loss: 1.1180\t Avg Loss: 0.0000\tCorrect: 17552/24711\tPercentage Correct: 71.03\nTrain Epoch: 93\t[5000/88956 (6%)]\tTotal Loss: 0.1112\tAvg Loss: 0.0000\nTrain Epoch: 93\t[10000/88956 (11%)]\tTotal Loss: 0.2165\tAvg Loss: 0.0000\nTrain Epoch: 93\t[15000/88956 (17%)]\tTotal Loss: 0.3381\tAvg Loss: 0.0000\nTrain Epoch: 93\t[20000/88956 (22%)]\tTotal Loss: 0.4520\tAvg Loss: 0.0000\nTrain Epoch: 93\t[25000/88956 (28%)]\tTotal Loss: 0.5745\tAvg Loss: 0.0000\nTrain Epoch: 93\t[30000/88956 (34%)]\tTotal Loss: 0.6911\tAvg Loss: 0.0000\nTrain Epoch: 93\t[35000/88956 (39%)]\tTotal Loss: 0.8050\tAvg Loss: 0.0000\nTrain Epoch: 93\t[40000/88956 (45%)]\tTotal Loss: 0.9167\tAvg Loss: 0.0000\nTrain Epoch: 93\t[45000/88956 (51%)]\tTotal Loss: 1.0434\tAvg Loss: 0.0000\nTrain Epoch: 93\t[50000/88956 (56%)]\tTotal Loss: 1.1757\tAvg Loss: 0.0000\nTrain Epoch: 93\t[55000/88956 (62%)]\tTotal Loss: 1.2989\tAvg Loss: 0.0000\nTrain Epoch: 93\t[60000/88956 (67%)]\tTotal Loss: 1.4166\tAvg Loss: 0.0000\nTrain Epoch: 93\t[65000/88956 (73%)]\tTotal Loss: 1.5440\tAvg Loss: 0.0000\nTrain Epoch: 93\t[70000/88956 (79%)]\tTotal Loss: 1.6795\tAvg Loss: 0.0000\nTrain Epoch: 93\t[75000/88956 (84%)]\tTotal Loss: 1.8003\tAvg Loss: 0.0000\nTrain Epoch: 93\t[80000/88956 (90%)]\tTotal Loss: 1.9228\tAvg Loss: 0.0000\nTrain Epoch: 93\t[85000/88956 (96%)]\tTotal Loss: 2.0556\tAvg Loss: 0.0000\n====> Epoch: 93\tTotal Loss: 2.1525\t Avg Loss: 0.0000\tCorrect: 74006/88956\tPercentage Correct: 83.19\n====> Val Loss: 0.4049\t Avg Loss: 0.0000\tCorrect: 7190/9885\tPercentage Correct: 72.74\n====> Test Loss: 0.9922\t Avg Loss: 0.0000\tCorrect: 18131/24711\tPercentage Correct: 73.37\nTrain Epoch: 94\t[5000/88956 (6%)]\tTotal Loss: 0.0997\tAvg Loss: 0.0000\nTrain Epoch: 94\t[10000/88956 (11%)]\tTotal Loss: 0.2111\tAvg Loss: 0.0000\nTrain Epoch: 94\t[15000/88956 (17%)]\tTotal Loss: 0.3178\tAvg Loss: 0.0000\nTrain Epoch: 94\t[20000/88956 (22%)]\tTotal Loss: 0.4265\tAvg Loss: 0.0000\nTrain Epoch: 94\t[25000/88956 (28%)]\tTotal Loss: 0.5384\tAvg Loss: 0.0000\nTrain Epoch: 94\t[30000/88956 (34%)]\tTotal Loss: 0.6824\tAvg Loss: 0.0000\nTrain Epoch: 94\t[35000/88956 (39%)]\tTotal Loss: 0.8035\tAvg Loss: 0.0000\nTrain Epoch: 94\t[40000/88956 (45%)]\tTotal Loss: 0.9065\tAvg Loss: 0.0000\nTrain Epoch: 94\t[45000/88956 (51%)]\tTotal Loss: 1.0160\tAvg Loss: 0.0000\nTrain Epoch: 94\t[50000/88956 (56%)]\tTotal Loss: 1.1295\tAvg Loss: 0.0000\nTrain Epoch: 94\t[55000/88956 (62%)]\tTotal Loss: 1.2380\tAvg Loss: 0.0000\nTrain Epoch: 94\t[60000/88956 (67%)]\tTotal Loss: 1.3534\tAvg Loss: 0.0000\nTrain Epoch: 94\t[65000/88956 (73%)]\tTotal Loss: 1.4775\tAvg Loss: 0.0000\nTrain Epoch: 94\t[70000/88956 (79%)]\tTotal Loss: 1.6008\tAvg Loss: 0.0000\nTrain Epoch: 94\t[75000/88956 (84%)]\tTotal Loss: 1.7225\tAvg Loss: 0.0000\nTrain Epoch: 94\t[80000/88956 (90%)]\tTotal Loss: 1.8481\tAvg Loss: 0.0000\nTrain Epoch: 94\t[85000/88956 (96%)]\tTotal Loss: 1.9699\tAvg Loss: 0.0000\n====> Epoch: 94\tTotal Loss: 2.0579\t Avg Loss: 0.0000\tCorrect: 74715/88956\tPercentage Correct: 83.99\n====> Val Loss: 0.4250\t Avg Loss: 0.0000\tCorrect: 7174/9885\tPercentage Correct: 72.57\n====> Test Loss: 1.0493\t Avg Loss: 0.0000\tCorrect: 18069/24711\tPercentage Correct: 73.12\nTrain Epoch: 95\t[5000/88956 (6%)]\tTotal Loss: 0.1013\tAvg Loss: 0.0000\nTrain Epoch: 95\t[10000/88956 (11%)]\tTotal Loss: 0.2188\tAvg Loss: 0.0000\nTrain Epoch: 95\t[15000/88956 (17%)]\tTotal Loss: 0.3273\tAvg Loss: 0.0000\nTrain Epoch: 95\t[20000/88956 (22%)]\tTotal Loss: 0.4464\tAvg Loss: 0.0000\nTrain Epoch: 95\t[25000/88956 (28%)]\tTotal Loss: 0.5619\tAvg Loss: 0.0000\nTrain Epoch: 95\t[30000/88956 (34%)]\tTotal Loss: 0.6801\tAvg Loss: 0.0000\nTrain Epoch: 95\t[35000/88956 (39%)]\tTotal Loss: 0.7868\tAvg Loss: 0.0000\nTrain Epoch: 95\t[40000/88956 (45%)]\tTotal Loss: 0.9061\tAvg Loss: 0.0000\nTrain Epoch: 95\t[45000/88956 (51%)]\tTotal Loss: 1.0174\tAvg Loss: 0.0000\nTrain Epoch: 95\t[50000/88956 (56%)]\tTotal Loss: 1.1248\tAvg Loss: 0.0000\nTrain Epoch: 95\t[55000/88956 (62%)]\tTotal Loss: 1.2362\tAvg Loss: 0.0000\nTrain Epoch: 95\t[60000/88956 (67%)]\tTotal Loss: 1.3470\tAvg Loss: 0.0000\nTrain Epoch: 95\t[65000/88956 (73%)]\tTotal Loss: 1.4793\tAvg Loss: 0.0000\nTrain Epoch: 95\t[70000/88956 (79%)]\tTotal Loss: 1.5944\tAvg Loss: 0.0000\nTrain Epoch: 95\t[75000/88956 (84%)]\tTotal Loss: 1.7137\tAvg Loss: 0.0000\nTrain Epoch: 95\t[80000/88956 (90%)]\tTotal Loss: 1.8704\tAvg Loss: 0.0000\nTrain Epoch: 95\t[85000/88956 (96%)]\tTotal Loss: 1.9973\tAvg Loss: 0.0000\n====> Epoch: 95\tTotal Loss: 2.0850\t Avg Loss: 0.0000\tCorrect: 74593/88956\tPercentage Correct: 83.85\n====> Val Loss: 0.4209\t Avg Loss: 0.0000\tCorrect: 7229/9885\tPercentage Correct: 73.13\n====> Test Loss: 1.0305\t Avg Loss: 0.0000\tCorrect: 18159/24711\tPercentage Correct: 73.49\nTrain Epoch: 96\t[5000/88956 (6%)]\tTotal Loss: 0.1080\tAvg Loss: 0.0000\nTrain Epoch: 96\t[10000/88956 (11%)]\tTotal Loss: 0.2162\tAvg Loss: 0.0000\nTrain Epoch: 96\t[15000/88956 (17%)]\tTotal Loss: 0.3185\tAvg Loss: 0.0000\nTrain Epoch: 96\t[20000/88956 (22%)]\tTotal Loss: 0.4186\tAvg Loss: 0.0000\nTrain Epoch: 96\t[25000/88956 (28%)]\tTotal Loss: 0.5281\tAvg Loss: 0.0000\nTrain Epoch: 96\t[30000/88956 (34%)]\tTotal Loss: 0.6405\tAvg Loss: 0.0000\nTrain Epoch: 96\t[35000/88956 (39%)]\tTotal Loss: 0.7536\tAvg Loss: 0.0000\nTrain Epoch: 96\t[40000/88956 (45%)]\tTotal Loss: 0.8661\tAvg Loss: 0.0000\nTrain Epoch: 96\t[45000/88956 (51%)]\tTotal Loss: 0.9849\tAvg Loss: 0.0000\nTrain Epoch: 96\t[50000/88956 (56%)]\tTotal Loss: 1.1136\tAvg Loss: 0.0000\nTrain Epoch: 96\t[55000/88956 (62%)]\tTotal Loss: 1.2249\tAvg Loss: 0.0000\nTrain Epoch: 96\t[60000/88956 (67%)]\tTotal Loss: 1.3314\tAvg Loss: 0.0000\nTrain Epoch: 96\t[65000/88956 (73%)]\tTotal Loss: 1.4448\tAvg Loss: 0.0000\nTrain Epoch: 96\t[70000/88956 (79%)]\tTotal Loss: 1.5674\tAvg Loss: 0.0000\nTrain Epoch: 96\t[75000/88956 (84%)]\tTotal Loss: 1.6836\tAvg Loss: 0.0000\nTrain Epoch: 96\t[80000/88956 (90%)]\tTotal Loss: 1.8001\tAvg Loss: 0.0000\nTrain Epoch: 96\t[85000/88956 (96%)]\tTotal Loss: 1.9152\tAvg Loss: 0.0000\n====> Epoch: 96\tTotal Loss: 2.0132\t Avg Loss: 0.0000\tCorrect: 74966/88956\tPercentage Correct: 84.27\n====> Val Loss: 0.4193\t Avg Loss: 0.0000\tCorrect: 7244/9885\tPercentage Correct: 73.28\n====> Test Loss: 1.0105\t Avg Loss: 0.0000\tCorrect: 18207/24711\tPercentage Correct: 73.68\nTrain Epoch: 97\t[5000/88956 (6%)]\tTotal Loss: 0.1031\tAvg Loss: 0.0000\nTrain Epoch: 97\t[10000/88956 (11%)]\tTotal Loss: 0.2214\tAvg Loss: 0.0000\nTrain Epoch: 97\t[15000/88956 (17%)]\tTotal Loss: 0.3156\tAvg Loss: 0.0000\nTrain Epoch: 97\t[20000/88956 (22%)]\tTotal Loss: 0.4252\tAvg Loss: 0.0000\nTrain Epoch: 97\t[25000/88956 (28%)]\tTotal Loss: 0.5335\tAvg Loss: 0.0000\nTrain Epoch: 97\t[30000/88956 (34%)]\tTotal Loss: 0.6569\tAvg Loss: 0.0000\nTrain Epoch: 97\t[35000/88956 (39%)]\tTotal Loss: 0.7648\tAvg Loss: 0.0000\nTrain Epoch: 97\t[40000/88956 (45%)]\tTotal Loss: 0.8841\tAvg Loss: 0.0000\nTrain Epoch: 97\t[45000/88956 (51%)]\tTotal Loss: 0.9976\tAvg Loss: 0.0000\nTrain Epoch: 97\t[50000/88956 (56%)]\tTotal Loss: 1.1076\tAvg Loss: 0.0000\nTrain Epoch: 97\t[55000/88956 (62%)]\tTotal Loss: 1.2394\tAvg Loss: 0.0000\nTrain Epoch: 97\t[60000/88956 (67%)]\tTotal Loss: 1.3766\tAvg Loss: 0.0000\nTrain Epoch: 97\t[65000/88956 (73%)]\tTotal Loss: 1.5080\tAvg Loss: 0.0000\nTrain Epoch: 97\t[70000/88956 (79%)]\tTotal Loss: 1.6160\tAvg Loss: 0.0000\nTrain Epoch: 97\t[75000/88956 (84%)]\tTotal Loss: 1.7325\tAvg Loss: 0.0000\nTrain Epoch: 97\t[80000/88956 (90%)]\tTotal Loss: 1.8582\tAvg Loss: 0.0000\nTrain Epoch: 97\t[85000/88956 (96%)]\tTotal Loss: 1.9753\tAvg Loss: 0.0000\n====> Epoch: 97\tTotal Loss: 2.0696\t Avg Loss: 0.0000\tCorrect: 74579/88956\tPercentage Correct: 83.84\n====> Val Loss: 0.4400\t Avg Loss: 0.0000\tCorrect: 7157/9885\tPercentage Correct: 72.40\n====> Test Loss: 1.0631\t Avg Loss: 0.0000\tCorrect: 18144/24711\tPercentage Correct: 73.42\nTrain Epoch: 98\t[5000/88956 (6%)]\tTotal Loss: 0.1077\tAvg Loss: 0.0000\nTrain Epoch: 98\t[10000/88956 (11%)]\tTotal Loss: 0.2236\tAvg Loss: 0.0000\nTrain Epoch: 98\t[15000/88956 (17%)]\tTotal Loss: 0.3248\tAvg Loss: 0.0000\nTrain Epoch: 98\t[20000/88956 (22%)]\tTotal Loss: 0.4296\tAvg Loss: 0.0000\nTrain Epoch: 98\t[25000/88956 (28%)]\tTotal Loss: 0.5244\tAvg Loss: 0.0000\nTrain Epoch: 98\t[30000/88956 (34%)]\tTotal Loss: 0.6319\tAvg Loss: 0.0000\nTrain Epoch: 98\t[35000/88956 (39%)]\tTotal Loss: 0.7539\tAvg Loss: 0.0000\nTrain Epoch: 98\t[40000/88956 (45%)]\tTotal Loss: 0.8657\tAvg Loss: 0.0000\nTrain Epoch: 98\t[45000/88956 (51%)]\tTotal Loss: 0.9776\tAvg Loss: 0.0000\nTrain Epoch: 98\t[50000/88956 (56%)]\tTotal Loss: 1.0843\tAvg Loss: 0.0000\nTrain Epoch: 98\t[55000/88956 (62%)]\tTotal Loss: 1.1985\tAvg Loss: 0.0000\nTrain Epoch: 98\t[60000/88956 (67%)]\tTotal Loss: 1.3121\tAvg Loss: 0.0000\nTrain Epoch: 98\t[65000/88956 (73%)]\tTotal Loss: 1.4266\tAvg Loss: 0.0000\nTrain Epoch: 98\t[70000/88956 (79%)]\tTotal Loss: 1.5438\tAvg Loss: 0.0000\nTrain Epoch: 98\t[75000/88956 (84%)]\tTotal Loss: 1.6618\tAvg Loss: 0.0000\nTrain Epoch: 98\t[80000/88956 (90%)]\tTotal Loss: 1.7689\tAvg Loss: 0.0000\nTrain Epoch: 98\t[85000/88956 (96%)]\tTotal Loss: 1.8807\tAvg Loss: 0.0000\n====> Epoch: 98\tTotal Loss: 1.9690\t Avg Loss: 0.0000\tCorrect: 75057/88956\tPercentage Correct: 84.38\n====> Val Loss: 0.4483\t Avg Loss: 0.0000\tCorrect: 6996/9885\tPercentage Correct: 70.77\n====> Test Loss: 1.1005\t Avg Loss: 0.0000\tCorrect: 17673/24711\tPercentage Correct: 71.52\nTrain Epoch: 99\t[5000/88956 (6%)]\tTotal Loss: 0.1067\tAvg Loss: 0.0000\nTrain Epoch: 99\t[10000/88956 (11%)]\tTotal Loss: 0.2160\tAvg Loss: 0.0000\nTrain Epoch: 99\t[15000/88956 (17%)]\tTotal Loss: 0.3199\tAvg Loss: 0.0000\nTrain Epoch: 99\t[20000/88956 (22%)]\tTotal Loss: 0.4298\tAvg Loss: 0.0000\nTrain Epoch: 99\t[25000/88956 (28%)]\tTotal Loss: 0.5524\tAvg Loss: 0.0000\nTrain Epoch: 99\t[30000/88956 (34%)]\tTotal Loss: 0.6710\tAvg Loss: 0.0000\nTrain Epoch: 99\t[35000/88956 (39%)]\tTotal Loss: 0.7758\tAvg Loss: 0.0000\nTrain Epoch: 99\t[40000/88956 (45%)]\tTotal Loss: 0.8952\tAvg Loss: 0.0000\nTrain Epoch: 99\t[45000/88956 (51%)]\tTotal Loss: 1.0147\tAvg Loss: 0.0000\nTrain Epoch: 99\t[50000/88956 (56%)]\tTotal Loss: 1.1347\tAvg Loss: 0.0000\nTrain Epoch: 99\t[55000/88956 (62%)]\tTotal Loss: 1.2514\tAvg Loss: 0.0000\nTrain Epoch: 99\t[60000/88956 (67%)]\tTotal Loss: 1.3701\tAvg Loss: 0.0000\nTrain Epoch: 99\t[65000/88956 (73%)]\tTotal Loss: 1.5041\tAvg Loss: 0.0000\nTrain Epoch: 99\t[70000/88956 (79%)]\tTotal Loss: 1.6226\tAvg Loss: 0.0000\nTrain Epoch: 99\t[75000/88956 (84%)]\tTotal Loss: 1.7349\tAvg Loss: 0.0000\nTrain Epoch: 99\t[80000/88956 (90%)]\tTotal Loss: 1.8937\tAvg Loss: 0.0000\nTrain Epoch: 99\t[85000/88956 (96%)]\tTotal Loss: 2.0273\tAvg Loss: 0.0000\n====> Epoch: 99\tTotal Loss: 2.1260\t Avg Loss: 0.0000\tCorrect: 74504/88956\tPercentage Correct: 83.75\n====> Val Loss: 0.3969\t Avg Loss: 0.0000\tCorrect: 7277/9885\tPercentage Correct: 73.62\n====> Test Loss: 0.9654\t Avg Loss: 0.0000\tCorrect: 18340/24711\tPercentage Correct: 74.22\n\n=== saved best model ===\n\nTraining time: 69013.07139778137s\n" ], [ "# BEST RESULTS\nprint('Accuracy: ', 100 * max(all_train_correct) / train_set_size)\nprint('Epoch: ', np.argmax(all_train_correct))\nprint()\nprint('Accuracy: ', 100 * max(all_val_correct) / val_set_size)\nprint('Epoch: ', np.argmax(all_val_correct))\nprint()\nprint('Accuracy: ', 100 * max(all_test_correct) / test_set_size)\nprint('Epoch: ', np.argmax(all_test_correct))\nprint()", "Accuracy: 84.37542155672467\nEpoch: 98\n\nAccuracy: 73.61659079413252\nEpoch: 99\n\nAccuracy: 74.21795961312776\nEpoch: 99\n\n" ], [ "# SAVE RESULTS - all losses, all correct, best results\nall_train_losses_npy = np.array(all_train_losses)\nall_train_correct_npy = np.array(all_train_correct)\nbest_train_results_npy = np.array(all_train_results[95])\n\nall_val_losses_npy = np.array(all_val_losses)\nall_val_correct_npy = np.array(all_val_correct)\nbest_val_results_npy = np.array(all_val_results[95])\n\nall_test_losses_npy = np.array(all_test_losses)\nall_test_correct_npy = np.array(all_test_correct)\nbest_test_results_npy = np.array(all_test_results[95])\n\nfx_labels_npy = np.array(list(dataset.fx_to_label.keys()))\n\nnp.save(file=('%s/%s/%s' % (results_folder, results_subfolder, 'all_train_losses')), arr=all_train_losses_npy)\nnp.save(file=('%s/%s/%s' % (results_folder, results_subfolder, 'all_train_correct')), arr=all_train_correct_npy)\nnp.save(file=('%s/%s/%s' % (results_folder, results_subfolder, 'best_train_results')), arr=best_train_results_npy)\n\nnp.save(file=('%s/%s/%s' % (results_folder, results_subfolder, 'all_val_losses')), arr=all_val_losses_npy)\nnp.save(file=('%s/%s/%s' % (results_folder, results_subfolder, 'all_val_correct')), arr=all_val_correct_npy)\nnp.save(file=('%s/%s/%s' % (results_folder, results_subfolder, 'best_val_results')), arr=best_val_results_npy)\n\nnp.save(file=('%s/%s/%s' % (results_folder, results_subfolder, 'all_test_losses')), arr=all_test_losses_npy)\nnp.save(file=('%s/%s/%s' % (results_folder, results_subfolder, 'all_test_correct')), arr=all_test_correct_npy)\nnp.save(file=('%s/%s/%s' % (results_folder, results_subfolder, 'best_test_results')), arr=best_test_results_npy)\n\nnp.save(file=('%s/%s/%s' % (results_folder, results_subfolder, 'fx_labels')), arr=fx_labels_npy)", "<ipython-input-7-490bdd120e03>:4: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n best_train_results_npy = np.array(all_train_results[95])\n<ipython-input-7-490bdd120e03>:8: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n best_val_results_npy = np.array(all_val_results[95])\n<ipython-input-7-490bdd120e03>:12: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n best_test_results_npy = np.array(all_test_results[95])\n" ] ] ]

[ "code", "markdown", "code", "markdown", "code" ]

[ [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# Quickstart Example with Multi-class Classificatoin Data\n---\nThis notebook provides an example of conducting OPE of an evaluate policy using multi-class classification dataset as logged bandit feedback data.\n\nOur example with multi-class classification data contains the follwoing four major steps:\n- (1) Bandit Reduction\n- (2) Off-Policy Learning\n- (3) Off-Policy Evaluation\n- (4) Evaluation of OPE Estimators\n\nPlease see [../examples/multiclass](../examples/multiclass) for a more sophisticated example of the evaluation of OPE with multi-class classification datasets.", "_____no_output_____" ] ], [ [ "import numpy as np\nfrom sklearn.datasets import load_digits\nfrom sklearn.ensemble import RandomForestClassifier as RandomForest\nfrom sklearn.linear_model import LogisticRegression\n# import open bandit pipeline (obp)\nimport obp\nfrom obp.dataset import MultiClassToBanditReduction\nfrom obp.ope import (\n OffPolicyEvaluation, \n RegressionModel,\n InverseProbabilityWeighting,\n DirectMethod,\n DoublyRobust\n)", "_____no_output_____" ], [ "# obp version\nprint(obp.__version__)", "0.3.3\n" ] ], [ [ "## (1) Bandit Reduction\nWe prepare easy-to-use interface for bandit reduction of multi-class classificatoin dataset: `MultiClassToBanditReduction` class in the dataset module.\n\nIt takes feature vectors (`X`), class labels (`y`), classifier to construct behavior policy (`base_classifier_b`), paramter of behavior policy (`alpha_b`) as inputs and generates a bandit dataset that can be used to evaluate the performance of decision making policies (obtained by `off-policy learning`) and OPE estimators.", "_____no_output_____" ] ], [ [ "# load raw digits data\n# `return_X_y` splits feature vectors and labels, instead of returning a Bunch object\nX, y = load_digits(return_X_y=True)\n\n# convert the raw classification data into a logged bandit dataset\n# we construct a behavior policy using Logistic Regression and parameter alpha_b\n# given a pair of a feature vector and a label (x, c), create a pair of a context vector and reward (x, r)\n# where r = 1 if the output of the behavior policy is equal to c and r = 0 otherwise\n# please refer to https://zr-obp.readthedocs.io/en/latest/_autosummary/obp.dataset.multiclass.html for the details\ndataset = MultiClassToBanditReduction(\n X=X,\n y=y,\n base_classifier_b=LogisticRegression(max_iter=1000, random_state=12345),\n alpha_b=0.8,\n dataset_name=\"digits\",\n)\n# split the original data into training and evaluation sets\ndataset.split_train_eval(eval_size=0.7, random_state=12345)\n# obtain logged bandit feedback generated by behavior policy\nbandit_feedback = dataset.obtain_batch_bandit_feedback(random_state=12345)\n\n# `bandit_feedback` is a dictionary storing logged bandit feedback\nbandit_feedback", "_____no_output_____" ] ], [ [ "## (2) Off-Policy Learning\nAfter generating logged bandit feedback, we now obtain an evaluation policy using the training set. <br>", "_____no_output_____" ] ], [ [ "# obtain action choice probabilities by an evaluation policy\n# we construct an evaluation policy using Random Forest and parameter alpha_e\naction_dist = dataset.obtain_action_dist_by_eval_policy(\n base_classifier_e=RandomForest(random_state=12345),\n alpha_e=0.9,\n)", "_____no_output_____" ] ], [ [ "## (3) Off-Policy Evaluation (OPE)\nOPE attempts to estimate the performance of evaluation policies using their action choice probabilities.\n\nHere, we use the **InverseProbabilityWeighting (IPW)**, **DirectMethod (DM)**, and **Doubly Robust (DR)** estimators and visualize the OPE results.", "_____no_output_____" ] ], [ [ "# estimate the mean reward function by using ML model (Logistic Regression here)\n# the estimated rewards are used by model-dependent estimators such as DM and DR\nregression_model = RegressionModel(\n n_actions=dataset.n_actions,\n base_model=LogisticRegression(random_state=12345, max_iter=1000),\n)\n# please refer to https://arxiv.org/abs/2002.08536 about the details of the cross-fitting procedure.\nestimated_rewards_by_reg_model = regression_model.fit_predict(\n context=bandit_feedback[\"context\"],\n action=bandit_feedback[\"action\"],\n reward=bandit_feedback[\"reward\"],\n n_folds=3, # use 3-fold cross-fitting\n random_state=12345,\n)", "_____no_output_____" ], [ "# estimate the policy value of the evaluation policy based on their action choice probabilities\n# it is possible to set multiple OPE estimators to the `ope_estimators` argument\nope = OffPolicyEvaluation(\n bandit_feedback=bandit_feedback,\n ope_estimators=[InverseProbabilityWeighting(), DirectMethod(), DoublyRobust()]\n)", "_____no_output_____" ], [ "# estimate the policy value of IPWLearner with Logistic Regression\nestimated_policy_value, estimated_interval = ope.summarize_off_policy_estimates(\n action_dist=action_dist,\n estimated_rewards_by_reg_model=estimated_rewards_by_reg_model\n)\nprint(estimated_interval, '\\n')\n# visualize estimated policy values of the evaluation policy with Logistic Regression by the three OPE estimators\n# and their 95% confidence intervals (estimated by nonparametric bootstrap method)\nope.visualize_off_policy_estimates(\n action_dist=action_dist,\n estimated_rewards_by_reg_model=estimated_rewards_by_reg_model,\n n_bootstrap_samples=10000, # number of resampling performed in the bootstrap procedure\n random_state=12345,\n)", " mean 95.0% CI (lower) 95.0% CI (upper)\nipw 0.890339 0.826724 0.975248\ndm 0.787085 0.779634 0.793370\ndr 0.882536 0.808637 0.937305 \n\n" ] ], [ [ "## (4) Evaluation of OPE estimators\nOur final step is **the evaluation of OPE**, which evaluates and compares the estimation accuracy of OPE estimators.\n\nWith the multi-class classification data, we can calculate the ground-truth policy value of the evaluation policy. \nTherefore, we can compare the policy values estimated by OPE estimators with the ground-turth to evaluate OPE estimators.", "_____no_output_____" ] ], [ [ "# calculate the ground-truth performance of the evaluation policy\nground_truth = dataset.calc_ground_truth_policy_value(action_dist=action_dist)\n\nprint(f'ground-truth policy value (classification accuracy): {ground_truth}')", "ground-truth policy value: 0.8770906200317964\n" ], [ "# evaluate the estimation performances of OPE estimators \n# by comparing the estimated policy value of the evaluation policy and its ground-truth.\n# `evaluate_performance_of_estimators` returns a dictionary containing estimation performances of given estimators \nrelative_ee = ope.summarize_estimators_comparison(\n ground_truth_policy_value=ground_truth,\n action_dist=action_dist,\n estimated_rewards_by_reg_model=estimated_rewards_by_reg_model,\n metric=\"relative-ee\", # \"relative-ee\" (relative estimation error) or \"se\" (squared error)\n)\n\n# estimation performances of the three estimators (lower means accurate)\nrelative_ee", "_____no_output_____" ] ], [ [ "Please see [../examples/multiclass](../examples/multiclass) for a more sophisticated example of the evaluation of OPE with multi-class classification data.", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "## Filter comparison", "_____no_output_____" ] ], [ [ "import scipy\nfrom scipy import signal\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.io as sio\nimport matplotlib.pyplot as plt\nimport statistics as stats\nimport pandas as pd\nfrom scipy.fft import fft, fftfreq, fftshift\nfrom scipy import signal\nfrom scipy.signal import savgol_filter\nfrom scipy.signal.signaltools import wiener\n\ndef highfilter(input_signal):\n #filtro: 'hp' high pass, 'low': low pass\n \n b, a = signal.butter(3, 0.05, 'hp') \n y = signal.filtfilt(b, a, input_signal)\n \n return y\n\ndef lowfilter(input_signal):\n #filtro: 'hp' high pass, 'low': low pass\n \n b, a = signal.butter(3, 0.05, 'low') \n y = signal.filtfilt(b, a, input_signal)\n \n return y", "_____no_output_____" ], [ "HA1 = sio.loadmat('H-A-1.mat')\nChannel1 = HA1['Channel_1']\ncanal1 = Channel1.T[0]\nt = np.linspace(0, 9, len(canal1))", "_____no_output_____" ], [ "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2)\nfig.set_size_inches(18,9.5)\nfig.suptitle('Comparison of different filters', fontsize = 15)\nax1.plot(t, canal1, alpha = 0.5)\nax1.plot(t, highfilter(canal1), 'tab:blue')\nax1.set_xlabel('Time')\nax1.set_ylabel('Amplitude')\nax1.set_title('Highpass-filter')\nax2.plot(t, canal1, 'tab:orange', alpha = 0.5)\nax2.plot(t, lowfilter(canal1), 'tab:orange')\nax2.set_xlabel('Time')\nax2.set_ylabel('Amplitude')\nax2.set_title('Lowpass-filter')\nax3.plot(t, canal1, 'tab:green', alpha = 0.5)\nax3.plot(t, savgol_filter(canal1, 5, 2), 'tab:green')\nax3.set_xlabel('Time')\nax3.set_ylabel('Amplitude')\nax3.set_title('Savitzky-Golay filter')\nax4.plot(t, canal1, 'tab:red', alpha = 0.5)\nfiltered_img = wiener(canal1, 99)\nax4.plot(t, filtered_img, 'tab:red')\nax4.set_xlabel('Time')\nax4.set_ylabel('Amplitude')\nax4.set_title('Wiener filter')", "_____no_output_____" ] ] ]

[ "markdown", "code" ]

[ [ "markdown" ], [ "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "!pip install tensorflow==2.0.0b1", "_____no_output_____" ], [ "import tensorflow as tf\nprint(tf.__version__)", "2.0.0-beta1\n" ], [ "import numpy as np\nimport matplotlib.pyplot as plt\ndef plot_series(time, series, format=\"-\", start=0, end=None):\n plt.plot(time[start:end], series[start:end], format)\n plt.xlabel(\"Time\")\n plt.ylabel(\"Value\")\n plt.grid(True)", "_____no_output_____" ], [ "!wget --no-check-certificate \\\n https://storage.googleapis.com/laurencemoroney-blog.appspot.com/Sunspots.csv \\\n -O /tmp/sunspots.csv", "--2019-07-01 15:07:56-- https://storage.googleapis.com/laurencemoroney-blog.appspot.com/Sunspots.csv\nResolving storage.googleapis.com (storage.googleapis.com)... 74.125.195.128, 2607:f8b0:400e:c08::80\nConnecting to storage.googleapis.com (storage.googleapis.com)|74.125.195.128|:443... connected.\nHTTP request sent, awaiting response... 200 OK\nLength: 70827 (69K) [application/octet-stream]\nSaving to: ‘/tmp/sunspots.csv’\n\n\r/tmp/sunspots.csv 0%[ ] 0 --.-KB/s \r/tmp/sunspots.csv 100%[===================>] 69.17K --.-KB/s in 0.001s \n\n2019-07-01 15:07:57 (95.3 MB/s) - ‘/tmp/sunspots.csv’ saved [70827/70827]\n\n" ], [ "import csv\ntime_step = []\nsunspots = []\n\nwith open('/tmp/sunspots.csv') as csvfile:\n reader = csv.reader(csvfile, delimiter=',')\n next(reader)\n for row in reader:\n sunspots.append(float(row[2]))\n time_step.append(int(row[0]))\n\nseries = np.array(sunspots)\ntime = np.array(time_step)\nplt.figure(figsize=(10, 6))\nplot_series(time, series)", "_____no_output_____" ], [ "split_time = 3000\ntime_train = time[:split_time]\nx_train = series[:split_time]\ntime_valid = time[split_time:]\nx_valid = series[split_time:]\n\nwindow_size = 60\nbatch_size = 32\nshuffle_buffer_size = 1000\n\n", "_____no_output_____" ], [ "def windowed_dataset(series, window_size, batch_size, shuffle_buffer):\n dataset = tf.data.Dataset.from_tensor_slices(series)\n dataset = dataset.window(window_size + 1, shift=1, drop_remainder=True)\n dataset = dataset.flat_map(lambda window: window.batch(window_size + 1))\n dataset = dataset.shuffle(shuffle_buffer).map(lambda window: (window[:-1], window[-1]))\n dataset = dataset.batch(batch_size).prefetch(1)\n return dataset", "_____no_output_____" ], [ "dataset = windowed_dataset(x_train, window_size, batch_size, shuffle_buffer_size)\n\nmodel = tf.keras.models.Sequential([\n tf.keras.layers.Dense(20, input_shape=[window_size], activation=\"relu\"), \n tf.keras.layers.Dense(10, activation=\"relu\"),\n tf.keras.layers.Dense(1)\n])\n\nmodel.compile(loss=\"mse\", optimizer=tf.keras.optimizers.SGD(lr=1e-7, momentum=0.9))\nmodel.fit(dataset,epochs=100,verbose=0)\n\n\n", "_____no_output_____" ], [ "forecast=[]\nfor time in range(len(series) - window_size):\n forecast.append(model.predict(series[time:time + window_size][np.newaxis]))\n\nforecast = forecast[split_time-window_size:]\nresults = np.array(forecast)[:, 0, 0]\n\n\nplt.figure(figsize=(10, 6))\n\nplot_series(time_valid, x_valid)\nplot_series(time_valid, results)", "_____no_output_____" ], [ "tf.keras.metrics.mean_absolute_error(x_valid, results).numpy()", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "CNRI-Python" ]

[ "CNRI-Python" ]

[ "CNRI-Python" ]

[ [ [ "### Question 1:\n\nWrite a program that calculates and prints the value according to the given formula:\n\nQ = Square root of [(2 * C * D)/H]\n\nFollowing are the fixed values of C and H:\n\nC is 50. H is 30.\n\nD is the variable whose values should be input to your program in a comma-separated sequence.\n\nExample\n\nLet us assume the following comma separated input sequence is given to the program:\n\n100,150,180\n\nThe output of the program should be:\n\n18,22,24\n", "_____no_output_____" ] ], [ [ "import math\n\nC = 50\nH = 30\nnumbers = input('Please enter the comma-separated values of D: ').split(',')\noutput = []\n\nfor D in numbers:\n Q = math.sqrt((2*C*int(D))/H)\n output.append(i)\n print(round(Q), end=' ')\n ", "Please enter the comma-separated values of D: 23,50,86\n9 13 17 " ] ], [ [ "### Question 2:\n\nWrite a program which takes 2 digits, X,Y as input and generates a 2-dimensional array.\nThe element value in the i-th row and j-th column of the array should be i*j.\n\nNote: i=0,1.., X-1; j=0,1,¡¬Y-1.\n\nExample\n\nSuppose the following inputs are given to the program:\n\n3,5\n\nThen, the output of the program should be:\n\n[[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8]]\n", "_____no_output_____" ] ], [ [ "def Matrix(x,y):\n M = []\n for i in range(x):\n row = []\n for j in range(y):\n row.append(i*j)\n M.append(row)\n return M\n\nX = int(input('Enter the value of X: '))\nY = int(input('Enter the value of Y: '))\n\nMatrix(X,Y)", "Enter the value of X: 3\nEnter the value of Y: 5\n" ] ], [ [ "### Question 3:\n\nWrite a program that accepts a comma separated sequence of words as input and prints the words in a comma-separated sequence after sorting them alphabetically.\n\nSuppose the following input is supplied to the program:\n\nwithout,hello,bag,world\n\nThen, the output should be:\n\nbag,hello,without,world\n", "_____no_output_____" ] ], [ [ "string = input('Please enter a comma separated sequence of words: ').split(',')\nstring.sort()\nprint(','.join(string))", "Please enter a comma separated sequence of words: without,hello,bag,world\nbag,hello,without,world\n" ] ], [ [ "### Question 4:\n\nWrite a program that accepts a sequence of whitespace separated words as input and prints the words after removing all duplicate words and sorting them alphanumerically.\n\nSuppose the following input is supplied to the program:\n\nhello world and practice makes perfect and hello world again\n\nThen, the output should be:\n\nagain and hello makes perfect practice world\n", "_____no_output_____" ] ], [ [ "string = input('Enter the sequence of white separated words: ').split(' ')\nprint(' '.join(sorted(set(string))))", "Enter the sequence of white separated words: hello world and practice makes perfect and hello world again\nagain and hello makes perfect practice world\n" ] ], [ [ "### Question 5:\n\nWrite a program that accepts a sentence and calculate the number of letters and digits.\n\nSuppose the following input is supplied to the program:\n\nhello world! 123\n\nThen, the output should be:\n\nLETTERS 10\n\nDIGITS 3\n", "_____no_output_____" ] ], [ [ "string = input('Enter a sentence: ')\nletter = 0\ndigit = 0\n\nfor i in string:\n if i.isalpha():\n letter += 1\n elif i.isdigit():\n digit += 1\n else:\n pass\n\nprint('LETTERS', letter)\nprint('DIGITS', digit)\n", "Enter a sentence: hello world! 123\nLETTERS 10\nDIGITS 3\n" ] ], [ [ "### Question 6:\n\nA website requires the users to input username and password to register. Write a program to check the validity of password input by users.\n\nFollowing are the criteria for checking the password:\n\n1. At least 1 letter between [a-z]\n2. At least 1 number between [0-9]\n1. At least 1 letter between [A-Z]\n3. At least 1 character from [$#@]\n4. Minimum length of transaction password: 6\n5. Maximum length of transaction password: 12\n\nYour program should accept a sequence of comma separated passwords and will check them according to the above criteria. Passwords that match the criteria are to be printed, each separated by a comma.\n\nExample\n\nIf the following passwords are given as input to the program:\n\nABd1234@1,a F1#,2w3E*,2We3345\n\nThen, the output of the program should be:\n\nABd1234@1\n", "_____no_output_____" ] ], [ [ "import re\n\npassword= input('Enter your password: ').split(',')\n\nvalid = []\n\nfor i in password:\n if len(i) < 6 or len(i) > 12:\n break\n elif not re.search('([a-z])+', i):\n break\n elif not re.search(\"([A-Z])+\", i):\n break\n elif not re.search(\"([0-9])+\", i):\n break\n elif not re.search(\"([!@$%^&])+\", i):\n break\n else:\n valid.append(i)\n print(' '.join(valid))\n break\n \nelse:\n print('Invalid Password')", "Enter your password: ABd1234@1,a F1#,2w3E*,2We3345\nABd1234@1\n" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "<p style='direction:rtl; text-align: right'>ابتدا باید کتابخانه های زیر را وارد کنیم:\n <ul style='direction:rtl; text-align: right'>\n <li>numpy: برای کار با ماتریس ها</li>\n <li>matplotlib: برای رسم نمودار</li>\n <li>PCA: برای کاهش بعد</li>\n <li>OpenCV: برای کار با عکس</li>\n <li>special_ortho_group: برای تولید پایه اورتونرمال </li>\n </ul>\n</p>\n\n</p>\n<p style='direction:rtl; text-align: right'>تذکر: اگر کتابخانه cv2 اجرا نشد باید آن را نصب کنید. در command prompt دستور زیر را اجرا کنید.\n</p>\n<p style='direction:rtl; text-align: right'> pip install opencv-python\n</p>", "_____no_output_____" ] ], [ [ "!pip install opencv-python", "Requirement already satisfied: opencv-python in c:\\programdata\\anaconda3\\lib\\site-packages (4.5.5.64)\nRequirement already satisfied: numpy>=1.17.3; python_version >= \"3.8\" in c:\\programdata\\anaconda3\\lib\\site-packages (from opencv-python) (1.19.2)\n" ], [ "import numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn.decomposition import PCA\nimport cv2\nfrom scipy.stats import special_ortho_group as sog", "_____no_output_____" ] ], [ [ "<h1 style='direction:rtl; text-align: right'>\nپروژه ۲: استفاده از کاهش بعد\n</h1>", "_____no_output_____" ], [ "<h2 style='direction:rtl; text-align: right'>\nقسمت ۱.۱: تولید دیتا با استفاده از پایه اورتونرمال\n</h2>\n<p style='direction:rtl; text-align: right'> \n عملیات زیر را انجام دهید:\n <ul style='direction:rtl; text-align: right'>\n <li>ابتدا با استفاده از تابع np.zeros آلفا وکتور هایی با ابعاد dim و N بسازید.</li>\n <li>سعی کنید متغیر آلفا وکتور را طوری پر کنید که به ازای هر اندیس از بعد صفر آن، آرایه ای از توزیع نرمال با میانگین ۰ و انحراف معیار i+1 قرار گیرد.</li>\n <li> بردار پایه V را با استفاده از تابع special_ortho_group.rvs(dim) بسازید.</li>\n <li> مشخص کنید که در ده مولفه اول چند درصد دیتا برای هر کدام از ماتریس ها حفظ شده اند. </li>\n <li> حال بردار زیر را تولید کنید و در alpha_v قرار دهید. </li>\n $$\\alpha_1 V_1 + \\alpha_2 V_2 + ... + \\alpha_d V_d $$\n </ul>", "_____no_output_____" ] ], [ [ "dim = 20\nN = 1000\n\nalpha_vectors = np.zeros((N, dim))\n\nfor i in range(N):\n alpha_vectors[i] = np.random.normal(0, i + 1, dim)\n\nV = sog.rvs(dim)\nalpha_v = np.matmul(alpha_vectors, V)\nprint(alpha_v)", "[[ 1.85796782e-01 5.95693503e-01 -1.06141413e+00 ... 1.25360933e+00\n -1.49196549e+00 -1.71645212e+00]\n [-5.52355256e-01 -2.32208128e-01 -1.45257747e+00 ... -5.75353815e-01\n 5.32574186e-01 -1.13204072e+00]\n [ 1.62991497e+00 3.05093383e-01 1.85496227e+00 ... -2.02565163e+00\n 3.66097985e+00 3.27154903e+00]\n ...\n [ 1.37340414e+03 1.19011377e+02 -1.16850578e+02 ... 1.26333703e+03\n -6.42699005e+02 -1.42814042e+03]\n [ 6.25504714e+01 -1.17225432e+03 2.19318481e+03 ... -6.21643322e+02\n 6.56490839e+02 -1.19807228e+03]\n [-3.01445100e+02 5.06836655e+02 -1.09693110e+03 ... 7.73835725e+02\n -1.90212911e+03 6.61624113e+02]]\n" ] ], [ [ "<h2 style='direction:rtl; text-align: right'>\nقسمت ۱.۲:استفاده از PCA برای کاهش بعد\n</h2>\n<p style='direction:rtl; text-align: right'> \n عملیات زیر را انجام دهید:\n <ul style='direction:rtl; text-align: right'>\n <li>ابتدا یک شیی از PCA بسازید.</li>\n <li>با استفاده از تابع fit موجود در شیی PCA عملیات pca را روی دیتا alpha_v انجام دهید.</li>\n <li> با استفاده از تابع components_ موجود در شیی pca بردار های تکین را مشاهده کنید.</li>\n <li> با استفاده از تابع explained_variance_ موجود در شیی pca مقدار های تکین را مشاهده کنید.</li>\n </ul>", "_____no_output_____" ] ], [ [ "pca = PCA()\npca.fit(alpha_v)\nprint(pca.components_)\nprint(pca.explained_variance_)\n\n\n", "[[ 3.34017742e-02 -1.18904961e-01 -4.25147294e-01 1.26947115e-01\n 3.13449083e-01 2.54046525e-01 2.71726916e-01 1.80475336e-01\n -1.14252489e-01 -5.92359744e-02 -7.92421226e-02 -3.44459207e-01\n 2.23677760e-01 4.90444010e-01 -1.12590124e-01 1.54180027e-01\n -5.84606532e-03 1.51139626e-01 -6.85230914e-02 1.50337823e-01]\n [-2.79972536e-01 -3.81875071e-04 -3.04331575e-01 3.97839316e-03\n 6.49960142e-02 2.92714369e-02 -3.76792291e-01 -3.10187582e-02\n -2.83348780e-01 -1.72045979e-01 4.50357740e-01 1.19864404e-01\n -2.44852022e-01 2.43681415e-02 -4.27746871e-01 -2.69710242e-01\n 1.16043399e-01 1.08055343e-01 -9.89675561e-02 5.19226613e-02]\n [ 5.66013430e-02 1.62255138e-01 1.89629385e-01 -7.90057936e-02\n -4.49016462e-01 -2.72328881e-03 -2.47581955e-01 -2.08425381e-01\n 2.48299359e-01 -7.02058223e-02 -1.62835979e-01 -2.72148420e-01\n -2.34592829e-01 4.40363626e-01 -1.12763612e-01 4.19896907e-03\n -7.33795257e-03 3.30866712e-01 -2.58390114e-02 2.87861015e-01]\n [ 1.16596502e-01 2.34476477e-01 2.22083735e-01 2.05160752e-01\n 2.69413528e-01 7.75101413e-02 1.37592325e-01 1.27251116e-01\n 5.81002707e-02 2.35254818e-01 3.90541178e-02 9.31818119e-02\n 7.40481424e-02 -1.54927152e-01 -1.80188308e-01 -4.24604153e-01\n -2.67317884e-01 3.11901416e-01 2.96512308e-01 3.98078448e-01]\n [ 3.59855417e-02 -5.17626653e-02 1.40630251e-01 -8.94043250e-03\n -4.58134241e-02 2.05479443e-01 5.48871842e-06 -3.20580899e-01\n -2.65748599e-01 1.47602854e-01 2.26601677e-01 -1.99249596e-01\n 1.99395675e-02 1.42541763e-02 1.17379666e-01 -3.99412283e-02\n -3.69565553e-01 -4.88639589e-01 -3.12771623e-01 3.95564094e-01]\n [-3.20531938e-01 -1.68911883e-01 1.35162555e-01 -3.63467493e-01\n 1.90352682e-01 2.25246225e-01 -1.76695982e-01 2.20292901e-01\n 1.91407295e-01 1.20663205e-01 -1.01932209e-02 -3.25768669e-02\n 7.86288460e-02 -5.91545549e-02 3.12916229e-01 -1.73479473e-01\n -1.32131024e-01 3.50213609e-01 -4.66191163e-01 -6.42863412e-02]\n [ 2.32335584e-02 -3.54696901e-01 1.06423776e-01 9.98315966e-02\n 1.20139914e-01 -1.55926954e-01 3.65203573e-01 -1.28949230e-01\n -1.42193192e-01 2.87579897e-01 -1.20196670e-01 1.39835624e-01\n -5.52001633e-01 -6.27135404e-02 -1.02557983e-01 1.59260237e-01\n 1.90991522e-01 2.18048498e-01 -2.75346628e-01 1.49424910e-01]\n [ 2.66607071e-01 -1.31786634e-01 9.42340353e-02 -1.10547064e-01\n 4.24367897e-01 -4.56475974e-01 -2.47516296e-01 -3.38312843e-01\n -6.68681288e-02 6.82036170e-02 5.14200233e-02 1.64392102e-01\n 1.34767759e-01 4.03926834e-01 5.40829871e-02 -4.29992410e-02\n -2.25672584e-01 8.94344569e-02 2.53358839e-02 -2.04500309e-01]\n [-4.08446169e-02 9.59503796e-03 -6.59448189e-02 -6.29938856e-02\n 1.67424070e-01 9.39861666e-02 -1.08784937e-01 1.44636550e-01\n 3.08735874e-01 -2.76628434e-01 2.11080379e-02 4.30848437e-01\n -1.86817356e-01 -2.15032615e-03 -8.65690559e-02 5.27572346e-01\n -3.96089734e-01 -7.74597731e-02 3.25106951e-02 2.78767583e-01]\n [ 3.45583546e-01 3.81938476e-01 -4.41654295e-02 -1.11420514e-01\n -1.00706496e-01 3.77177770e-02 8.90994314e-02 4.27785135e-01\n -9.20911845e-02 2.76733882e-01 3.83200526e-01 5.89571753e-02\n -3.39218846e-01 2.62329787e-01 2.02288902e-01 4.24411959e-02\n -6.28788470e-02 -2.77013631e-02 -7.94458466e-02 -2.11670649e-01]\n [-4.01362930e-01 2.14021551e-01 1.80599136e-02 1.40353418e-01\n -3.62893585e-01 -1.69450347e-01 2.38455836e-01 -3.81773246e-02\n -3.66398069e-01 5.67647017e-02 -2.15380061e-02 3.51446668e-01\n 3.13098232e-01 1.57750842e-01 3.37929823e-02 1.43191165e-01\n -2.52062742e-01 2.55866994e-01 -1.32335316e-01 -4.27475643e-02]\n [ 4.69884055e-01 -2.47952452e-01 7.82992081e-02 2.17049833e-01\n -1.87178286e-01 2.90337555e-01 -6.10153074e-02 1.04029127e-01\n -1.50266499e-01 -3.74698139e-01 -1.56568656e-01 4.13465140e-01\n 7.89671357e-02 9.58532374e-02 1.07083606e-01 -2.88326384e-01\n 6.86962104e-02 4.73320970e-02 -2.34077780e-01 1.97531559e-02]\n [-2.41003628e-01 5.71705090e-02 2.47957958e-01 -2.55132140e-01\n 1.02457970e-01 6.49639303e-02 1.03406771e-01 9.02330524e-02\n 1.04937013e-01 1.46428165e-01 -4.13585987e-02 3.47270001e-01\n 1.32369584e-01 4.17429785e-01 -9.97202666e-02 -1.26198961e-01\n 4.65691046e-01 -3.69967967e-01 5.90622794e-02 2.21106089e-01]\n [ 6.21256199e-02 4.13005918e-01 -2.41887713e-01 -3.43042911e-01\n 1.67873370e-01 -1.75186686e-01 -7.36081558e-02 5.00482981e-02\n -3.56101437e-01 -1.35878533e-01 -5.59437282e-01 2.09597019e-03\n -1.55355825e-01 -1.33788858e-01 9.32025284e-02 -1.18009025e-01\n 2.91333398e-04 -7.31636155e-02 -1.14657702e-01 2.02955129e-01]\n [ 1.13340224e-01 -2.90703634e-01 -3.30730196e-01 7.88363473e-03\n -2.81952095e-01 -5.09164234e-01 -1.34108566e-01 3.63603497e-01\n 1.91448426e-01 2.50411291e-01 1.40108620e-02 8.74435726e-03\n 2.04821198e-01 -5.62295383e-02 -5.22170894e-02 -1.10040652e-01\n -3.90952853e-02 -1.15627321e-01 -1.44339731e-01 3.30076886e-01]\n [ 9.08519506e-02 2.49577158e-01 7.14979119e-02 2.52513184e-01\n 1.76386132e-01 -1.17496871e-01 -2.12082684e-01 -6.40664908e-02\n -4.39238249e-02 -6.92512954e-02 2.67867830e-01 -1.78795097e-02\n 2.03895436e-01 -1.36030773e-01 3.69568817e-01 3.08116672e-01\n 4.62306457e-01 2.00492029e-01 -1.47473729e-01 3.47153741e-01]\n [-1.93508996e-02 -1.89717339e-01 3.98482905e-01 8.09161586e-02\n 1.25367916e-02 6.57541972e-02 -4.38008703e-01 4.06516596e-01\n -4.45337861e-01 1.77397772e-01 -1.91001312e-01 -1.44560579e-01\n 3.16491616e-02 8.49143890e-03 -1.80651355e-01 2.91253728e-01\n -1.81369450e-02 -2.55535792e-02 1.71126756e-01 -2.70168328e-02]\n [ 1.29105615e-01 -2.93623107e-01 -7.66601312e-03 -5.90494645e-01\n -1.61729863e-01 2.41921287e-02 1.91687616e-01 -2.96486105e-02\n -2.67072290e-01 -1.53130362e-01 2.62630756e-01 2.05393792e-03\n 7.47165945e-02 -8.15624057e-02 1.51842084e-01 7.16019864e-02\n 3.95853045e-02 2.36257499e-01 4.12561592e-01 2.28570232e-01]\n [-1.03071231e-01 -1.07042472e-01 -4.02887507e-01 1.46197268e-01\n -7.13175209e-02 3.05054740e-01 -2.90292365e-01 -2.12756804e-01\n -2.14447218e-02 4.42104580e-01 -1.69544225e-01 2.26855307e-01\n -1.26069659e-01 7.62996882e-02 3.83517564e-01 -1.64042413e-02\n 1.74308774e-02 2.95504760e-02 3.43425715e-01 4.72580985e-02]\n [-3.38168767e-01 -1.50358236e-01 1.21204491e-01 2.73435240e-01\n 6.98776545e-02 -2.71569663e-01 7.62004119e-02 2.23359419e-01\n -5.04083794e-02 -3.58344131e-01 3.48821749e-02 -1.41264091e-01\n -3.13295579e-01 2.02242187e-01 4.60755751e-01 -2.31049642e-01\n -1.00620747e-01 -1.18946628e-01 2.21317324e-01 9.55729060e-02]]\n[459338.51256464 426099.91399403 410847.21917205 392410.42768038\n 380751.72253453 369528.46403096 362403.79314679 351653.36336259\n 344206.96335909 327495.31605779 315513.97763167 309901.14676994\n 300603.60437195 295271.1739031 287504.79954667 271718.6479452\n 264138.64297627 254663.79547324 236554.66406725 223683.16717356]\n" ] ], [ [ "<h2 style='direction:rtl; text-align: right'>\nقسمت ۱.۳: کاهش بعد به ۳ بعد\n</h2>\n <ul style='direction:rtl; text-align: right'>\n <li>ابتدا یک شیی از PCA با ورودی n_components=3 بسازید.</li>\n <li>با استفاده از تابع fit موجود در شیی PCA عملیات pca را روی دیتا alpha_v انجام دهید.</li>\n <li> تابع explained_variance_ratio_ موجود در شیی pca درصد حفظ دیتا به ازای هر کدام از بعد ها را می دهد.</li>\n <li>با کاهش بعد به ۳، چند درصد از اطلاعات حفظ می شود؟</li>\n </ul>", "_____no_output_____" ] ], [ [ "pca = PCA(n_components = 3)\npca.fit(alpha_v)\nprint(str(100 * np.sum(pca.explained_variance_ratio_)) + \" percent of data is preserved in 3 dimensions!\")\n", "19.544901432955598 percent of data is preserved in 3 dimensions!\n" ] ], [ [ "<p style='direction:rtl; text-align: right'> برای حفظ ۹۰ درصد از اطلاعات به چند بعد نیاز داریم؟ </p>", "_____no_output_____" ] ], [ [ "min_dim = 0\nfor i in range(1, dim):\n pca = PCA(n_components = i)\n pca.fit(alpha_v)\n if (np.sum(pca.explained_variance_ratio_) >= 0.9):\n min_dim = i\n break\nprint(\"Almost \" + str(100 * np.sum(pca.explained_variance_ratio_)) + \" percent of data is preserved in at least \" + str(min_dim) + \" dimensions!\")", "Almost 93.01006062812166 percent of data is preserved in at least 18 dimensions!\n" ] ], [ [ "<h2 style='direction:rtl; text-align: right'>\nقسمت ۲.۱: خواندن فایل تصویر\n</h2>\n<p style='direction:rtl; text-align: right'>ابتدا فایل تصویری رنگی باکیفیتی را از گوگل دانلود کنید.</p>\n<p style='direction:rtl; text-align: right'>با استفاده از تابع imread موجود در کتابخانه <a href=\"https://www.geeksforgeeks.org/python-opencv-cv2-imread-method/\">OpenCV</a> عکس مربوطه را فراخوانی کنید:</p>", "_____no_output_____" ] ], [ [ "image1 = cv2.imread(\"mona.jpg\")", "_____no_output_____" ] ], [ [ "<p style='direction:rtl; text-align: right'>عکس خوانده شده را به فرمت <a href=\"https://www.w3schools.com/colors/colors_rgb.asp\">RGB</a> در می آوریم:</p>", "_____no_output_____" ] ], [ [ "image = cv2.cvtColor(image1, cv2.COLOR_BGR2RGB)", "_____no_output_____" ] ], [ [ "<p style='direction:rtl; text-align: right'>\n همانطور که می بینید عکس خوانده شده به ازای هر پیکسل ۳ عدد دارد: بنابراین برای هر عکس رنگی x*y یک آرایه x*y*3 خواهیم داشت.</p>", "_____no_output_____" ] ], [ [ "dim = image.shape\nprint('Image shape =', dim)", "Image shape = (720, 483, 3)\n" ] ], [ [ "<h2 style='direction:rtl; text-align: right'>\nقسمت ۲.۲: نمایش تصویر\n</h2>\n<p style='direction:rtl; text-align: right'>با استفاده از تابع imshow موجود در <a href=\"https://www.geeksforgeeks.org/matplotlib-pyplot-imshow-in-python/\">matplotlib</a> تصویر خوانده شده را نمایش دهید:</p>", "_____no_output_____" ] ], [ [ "plt.imshow(image)\nplt.show()", "_____no_output_____" ] ], [ [ "<h2 style='direction:rtl; text-align: right'>\nقسمت ۲.۳: آماده سازی تصویر برای کاهش بعد\n</h2>\n<p style='direction:rtl; text-align: right'>سه ماتریس رنگ را در ماتریس های R,G,B ذخیره کنید:</p>", "_____no_output_____" ] ], [ [ "R = image[:, :, 0]\nG = image[:, :, 1]\nB = image[:, :, 2]\nprint(R.shape)\nprint(G.shape)\nprint(B.shape)", "(720, 483)\n(720, 483)\n(720, 483)\n" ] ], [ [ "<h2 style='direction:rtl; text-align: right'>\nقسمت ۲.۴:استفاده از PCA برای کاهش بعد\n</h2>\n\n<p style='direction:rtl; text-align: right'> \nبا استفاده از کلاس PCA در کتابخانه sklearn کاهش بعد را انجام میدهیم.\n عملیات زیر را انجام دهید:\n <a href=\"https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html\">راهنمایی</a>\n <ul style='direction:rtl; text-align: right'>\n <li>برای هر یک از ماتریس های R,G,B یک شی PCA ایجاد کنید. تعداد مولفه ها را ۱۰ قرار دهید.</li>\n <li>با استفاده از تابع fit موجود در pca الگوریتم را روی ماتریس ها فیت کنید.</li>\n <li> با استفاده از دستور _explained_variance_ratio میتوانید ببینید هرکدام از مولفه ها چند درصد دیتای ماتریس را دارند. </li>\n <li> مشخص کنید که در ده مولفه اول چند درصد دیتا برای هر کدام از ماتریس ها حفظ شده اند. </li>\n <li> با استفاده از دستور bar مقادیر _explained_variance_ratio را رسم کنید </li> \n </ul>", "_____no_output_____" ] ], [ [ "k = 10\nrpca = PCA(n_components = k)\ngpca = PCA(n_components = k)\nbpca = PCA(n_components = k)\n\nrpca.fit(R)\ngpca.fit(G)\nbpca.fit(B)\n\nprint(\"First \" + str(k) + \" components of Red Matrix have \" + str(100 * np.sum(rpca.explained_variance_ratio_)) + \" percent of data.\")\nprint(\"First \" + str(k) + \" components of Green Matrix have \" + str(100 * np.sum(gpca.explained_variance_ratio_)) + \" percent of data.\")\nprint(\"First \" + str(k) + \" components of Blue Matrix have \" + str(100 * np.sum(bpca.explained_variance_ratio_)) + \" percent of data.\")", "First 10 components of Red Matrix have 91.5284949220633 percent of data.\nFirst 10 components of Green Matrix have 92.72653593218749 percent of data.\nFirst 10 components of Blue Matrix have 79.66273622738387 percent of data.\n" ], [ "plt.bar([i for i in range(k)], rpca.explained_variance_ratio_, color ='red', width = 0.4)\nplt.xlabel(\"Red Components\")\nplt.ylabel(\"Variance %\")\nplt.show()", "_____no_output_____" ], [ "\nplt.bar([i for i in range(k)], gpca.explained_variance_ratio_, color ='green', width = 0.4)\nplt.xlabel(\"Green Components\")\nplt.ylabel(\"Variance %\")\nplt.show()", "_____no_output_____" ], [ "plt.bar([i for i in range(k)], bpca.explained_variance_ratio_, color ='blue', width = 0.4)\nplt.xlabel(\"Blue Components\")\nplt.ylabel(\"Variance %\")\nplt.show()", "_____no_output_____" ] ], [ [ "<p style='direction:rtl; text-align: right'>عملیات زیر را انجام دهید:\n <ul style='direction:rtl; text-align: right'>\n <li>با استفاده از تابع transform موجود در pca دیتا با بعد کمتر را تولید کنید</li>\n <li> با استفاده از تابع inverse_transform دیتا را به بعد اولیه برگردانید </li>\n </ul>\n</p>", "_____no_output_____" ] ], [ [ "Transform_R = rpca.transform(R)\nTransform_B = gpca.transform(G)\nTransform_G = bpca.transform(B)\nReduced_R = rpca.inverse_transform(Transform_R)\nReduced_G = gpca.inverse_transform(Transform_G)\nReduced_B = bpca.inverse_transform(Transform_B)\n\nprint('Transform Matrix Shape = ', Transform_R.shape)\nprint('Inverse Transform Matrix Shape = ', Reduced_R.shape)", "Transform Matrix Shape = (720, 10)\nInverse Transform Matrix Shape = (720, 483)\n" ] ], [ [ "<p style='direction:rtl; text-align: right'>با استفاده از دستور concatenate سه ماتریس ً Reduced_R,Reduced_G,Reduced_B را کنار هم قرار دهید تا یک آرایه x*y*3 ایجاد شود. x , y همان ابعاد تصویر اولیه (image) هستند </p>\n<p style='direction:rtl; text-align: right'>با استفاده از دستور astype ماتریس بدست آمده را به عدد صحیح تبدیل کنید.</p>\n\n<p style='direction:rtl; text-align: right'>عکس بدست آمده را با imshow نمایش دهید.</p>", "_____no_output_____" ] ], [ [ "Reduced_R = Reduced_R.reshape((dim[0], dim[1], 1))\nReduced_G = Reduced_G.reshape((dim[0], dim[1], 1))\nReduced_B = Reduced_B.reshape((dim[0], dim[1], 1))\n\nreduced_image = np.dstack((Reduced_R, Reduced_G, Reduced_B))\nfinal_image = reduced_image.astype(int)\nprint('final_image shape = ', final_image.shape)\nplt.imshow(final_image)\nplt.show()", "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" ] ], [ [ "<h2 style='direction:rtl; text-align: right'>\nقسمت ۲.۵:استفاده از PCA برای کاهش بعد و حفظ ۹۹ درصد داده ها\n</h2>\n\n<p style='direction:rtl; text-align: right'> \nکل قسمت ۲.۴ را مجددا اجرا کنید. این بار تعداد مولفه ها را عددی قرار دهید که در هر سه ماتریس R,G,B حداقل ۹۹ درصد داده ها حفظ شود.\n ", "_____no_output_____" ] ], [ [ "k = 188\nrpca = PCA(n_components = k)\ngpca = PCA(n_components = k)\nbpca = PCA(n_components = k)\n\nrpca.fit(R)\ngpca.fit(G)\nbpca.fit(B)", "_____no_output_____" ], [ "Transform_R = rpca.transform(R)\nTransform_B = gpca.transform(G)\nTransform_G = bpca.transform(B)\nReduced_R = rpca.inverse_transform(Transform_R)\nReduced_G = gpca.inverse_transform(Transform_G)\nReduced_B = bpca.inverse_transform(Transform_B)\n\nprint('Transform Matrix Shape = ', Transform_R.shape)\nprint('Inverse Transform Matrix Shape = ', Reduced_R.shape)", "Transform Matrix Shape = (720, 188)\nInverse Transform Matrix Shape = (720, 483)\n" ], [ "Reduced_R = Reduced_R.reshape((dim[0], dim[1], 1))\nReduced_G = Reduced_G.reshape((dim[0], dim[1], 1))\nReduced_B = Reduced_B.reshape((dim[0], dim[1], 1))\n\nreduced_image = np.dstack((Reduced_R, Reduced_G, Reduced_B))\nfinal_image = reduced_image.astype(int)\nprint('final_image shape = ', final_image.shape)\nplt.imshow(final_image)\nplt.show()\nprint(np.sum(rpca.explained_variance_ratio_))", "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import numpy as np\nimport pandas as pd\nimport seaborn as sns\nfrom new_heatmap import multi_group_heatmap\nimport matplotlib.pyplot as plt\n\nimport scipy.spatial.distance as distance\nimport scipy.cluster.hierarchy as sch", "_____no_output_____" ], [ "\n\na0 = np.arange(0,1, 1/600).reshape(30,20)\na1 = np.arange(0,1, 1/1200).reshape(30,40)\n\n\n\ns0 = np.arange(0,1, 1/600).reshape(20,30).T\ns1 = np.arange(0,1, 1/1200).reshape(40,30).T\n\nylabels = (np.arange(30)*10).astype(str)\nx_label0 = (np.arange(20)).astype(int).astype(str)\nx_label1 = (np.arange(40)).astype(int).astype(str)\n\n\nval = np.random.rand(30,2)", "_____no_output_____" ], [ "col_pairwise_dists_0 = distance.squareform(distance.pdist(a0.T))\ncol_pairwise_dists_1 = distance.squareform(distance.pdist(a1.T))\ncol_clusters_0 = sch.linkage(col_pairwise_dists_0,method='complete')\ncol_clusters_1 = sch.linkage(col_pairwise_dists_1,method='complete')\ncol_denD_0 = sch.dendrogram(col_clusters_0,color_threshold=np.inf)\ncol_denD_1 = sch.dendrogram(col_clusters_1,color_threshold=np.inf)\n\nx_label0 = np.array(x_label0)[[col_denD_0['leaves']]]\nx_label1 = np.array(x_label1)[[col_denD_1['leaves']]]\na0 = np.array(a0.T[col_denD_0['leaves'],:]).T\na1 = np.array(a1.T[col_denD_1['leaves'],:]).T\n\ns0 = np.array(s0.T[col_denD_0['leaves'],:]).T\ns1 = np.array(s1.T[col_denD_1['leaves'],:]).T", "/usr/local/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:3: ClusterWarning: scipy.cluster: The symmetric non-negative hollow observation matrix looks suspiciously like an uncondensed distance matrix\n This is separate from the ipykernel package so we can avoid doing imports until\n/usr/local/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:4: ClusterWarning: scipy.cluster: The symmetric non-negative hollow observation matrix looks suspiciously like an uncondensed distance matrix\n after removing the cwd from sys.path.\n/usr/local/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:8: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n \n/usr/local/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:9: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n if __name__ == '__main__':\n" ], [ "a0", "_____no_output_____" ], [ "%reload_ext autoreload\n%load_ext autoreload\n%autoreload 2\n\n\nfig0 = plt.figure(figsize=(15, 10))\nmulti_group_heatmap(\n index_group = val,\n index_group_x_ticks = ['index1', 'index2'],\n group0 = a0,\n group1 = a1,\n col_pairwise_dists_0 = col_pairwise_dists_0,\n col_pairwise_dists_1 = col_pairwise_dists_1,\n group0_x_ticks = x_label0,\n group1_x_ticks = x_label1,\n size0 = s0,\n size1 = s1,\n size_scale=60, # Change the overall cube size \n x_axis_label0 = '\\nGroup0',\n x_axis_label1 =' ' + \\\n ' ' + \\\n ' X_labels' + '\\nGroup1',\n y_ticks = ylabels, \n color_range = [0,1],\n size_range = [0,1],\n chart = np.zeros((30,2)),\n chart_x_ticks = ['col_1','col_2'],\n palette=(\"RdYlGn\", 256),\n color_bar = True,\n size_bar = True,\n space_in_size_bar = 1,\n high_ligh_y_ticks = (0,5)\n)", "The autoreload extension is already loaded. To reload it, use:\n %reload_ext autoreload\n" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code" ] ]

[ "ADSL" ]

[ "ADSL" ]

[ "ADSL" ]

[ [ [ "from splinter import Browser\nfrom bs4 import BeautifulSoup\nimport time\nimport requests\nimport pymongo\nfrom selenium import webdriver\n", "_____no_output_____" ] ], [ [ "# **Create Database in MongoDB**\n", "_____no_output_____" ], [ "# **Connect to Mongo DB Mars DB**", "_____no_output_____" ] ], [ [ "conn = 'mongodb://localhost:27017'\nclient = pymongo.MongoClient(conn)", "_____no_output_____" ], [ "# Define database and collection\ndb = client.mars\ncollection = db.items", "_____no_output_____" ] ], [ [ "**Get executable_path**", "_____no_output_____" ] ], [ [ "!which chromedriver", "/usr/local/bin/chromedriver\r\n" ] ], [ [ "# **Step 1 - Scraping**", "_____no_output_____" ], [ "**NASA Mars News**\n\nScrape the NASA Mars News Site and collect the latest News Title and Paragraph Text. Assign the text to variables that you can reference later.", "_____no_output_____" ] ], [ [ "def latest_nasa_news():\n \n executable_path = {'executable_path': '/usr/local/bin/chromedriver'}\n browser = Browser('chrome', **executable_path, headless=False)\n url = \"https://mars.nasa.gov/news/?page=0&per_page=40&order=publish_date+desc%2Ccreated_at+desc&search=&category=19%2C165%2C184%2C204&blank_scope=Latest\"\n browser.visit(url)\n #need timer to ensure page has load before scraping?\n time.sleep(5)\n html = browser.html\n soup = BeautifulSoup(html, 'html.parser')\n news_date = soup.find('div', class_='list_date').text\n news_title = soup.find('div', class_='content_title').text\n news_p = soup.find('div', class_='article_teaser_body').text\n print(news_date)\n print(news_title)\n print(news_p)\n \n#how to print multiple variables?\n\nlatest_nasa_news()\n", "November 27, 2019\nNASA's Briefcase-Size MarCO Satellite Picks Up Honors\nThe twin spacecraft, the first of their kind to fly into deep space, earn a Laureate from Aviation Week & Space Technology.\n" ] ], [ [ "**JPL Mars Space Images - Featured Image**\n\nLatest Mars image", "_____no_output_____" ] ], [ [ "def latest_mars_image():\n \n executable_path = {'executable_path': '/usr/local/bin/chromedriver'}\n browser = Browser('chrome', **executable_path, headless=False)\n url_mars_image = \"https://www.jpl.nasa.gov/spaceimages/?search=&category=Mars\"\n browser.visit(url_mars_image)\n #need timer to ensure page has load before scraping?\n time.sleep(5)\n html = browser.html\n soup = BeautifulSoup(html, 'html.parser')\n image = soup.find('img', class_='thumb')\n #image output <img alt=\"Indus Vallis\" class=\"thumb\" src=\"/spaceimages/images/wallpaper/PIA23573-640x350.jpg\" title=\"Indus Vallis\"/>\n #how to save image url and path to diplay in webpage?\n\n#need to call image?\nlatest_mars_image()", "_____no_output_____" ] ], [ [ "**Twitter Latest Mars Weather**", "_____no_output_____" ] ], [ [ "def latest_mars_weather():\n \n executable_path = {'executable_path': '/usr/local/bin/chromedriver'}\n browser = Browser('chrome', **executable_path, headless=False)\n url_mars_weather = \"https://twitter.com/marswxreport?lang=en\"\n browser.visit(url_mars_weather)\n #need timer to ensure page has load before scraping?\n time.sleep(5)\n soup = BeautifulSoup(browser.html, 'html.parser')\n latest_weather = soup.find('p', class_='TweetTextSize').text\n print('Current Weather on Mars')\n print(latest_weather)\n\n#how to print multiple variables?\n\nlatest_mars_weather()", "Current Weather on Mars\nInSight sol 366 (2019-12-07) low -98.9ºC (-146.1ºF) high -20.4ºC (-4.8ºF)\nwinds from the SSE at 5.7 m/s (12.6 mph) gusting to 20.4 m/s (45.5 mph)\npressure at 6.60 hPapic.twitter.com/BYqMmSLmWr\n" ], [ "import requests\nimport lxml.html as lh\nimport pandas as pd", "_____no_output_____" ], [ "def mars_facts():\n executable_path = {'executable_path': '/usr/local/bin/chromedriver'}\n browser = Browser('chrome', **executable_path, headless=False)\n url_mars_facts = \"http://space-facts.com/mars/\"\n browser.visit(url_mars_facts)\n #need timer to ensure page has load before scraping?\n time.sleep(5)\n soup = BeautifulSoup(html, 'html.parser')\n mars_facts_table = soup.find(\"table\", {\"class\": \"tablepress tablepress-id-p-mars\"})\n df_mars_facts = pd.read_html(str(mars_facts_table))\n print(df_mars_facts)\n\nmars_facts()\n\n\n \n \n \n ", "_____no_output_____" ], [ " latest_weather = soup.find('td', class_='column-2')\n for weather in latest_weather:\n print('----------------------------------')\n print(weather)", "----------------------------------\n6,792 km\n----------------------------------\n<br/>\n" ] ], [ [ "**Mars Hemispheres**\n\nVisit the USGS Astrogeology site here to obtain high resolution images for each of Mar's hemispheres.\n\n\nYou will need to click each of the links to the hemispheres in order to find the image url to the full resolution image.\n\n\nSave both the image url string for the full resolution hemisphere image, and the Hemisphere title containing the hemisphere name. Use a Python dictionary to store the data using the keys img_url and title.\n\n\nAppend the dictionary with the image url string and the hemisphere title to a list. This list will contain one dictionary for each hemisphere.", "_____no_output_____" ] ], [ [ "def mars_image():\n executable_path = {'executable_path': '/usr/local/bin/chromedriver'}\n browser = Browser('chrome', **executable_path, headless=False)\n url = \"https://astrogeology.usgs.gov/search/results?q=hemisphere+enhanced&k1=target&v1=Mars\"\n browser.visit(url)\n #need a pause to ensure page has load before scraping?\n soup = BeautifulSoup(browser.html, 'html.parser')\n div = soup.find('div', class_='results').findAll('div', class_='description')\n print(div)\nmars_image()", "[<div class=\"description\"><a class=\"itemLink product-item\" href=\"/search/map/Mars/Viking/cerberus_enhanced\"><h3>Cerberus Hemisphere Enhanced</h3></a><span class=\"subtitle\" style=\"float:left\">image/tiff 21 MB</span><span class=\"pubDate\" style=\"float:right\"></span><br/><p>Mosaic of the Cerberus hemisphere of Mars projected into point perspective, a view similar to that which one would see from a spacecraft. This mosaic is composed of 104 Viking Orbiter images acquired…</p></div>, <div class=\"description\"><a class=\"itemLink product-item\" href=\"/search/map/Mars/Viking/schiaparelli_enhanced\"><h3>Schiaparelli Hemisphere Enhanced</h3></a><span class=\"subtitle\" style=\"float:left\">image/tiff 35 MB</span><span class=\"pubDate\" style=\"float:right\"></span><br/><p>Mosaic of the Schiaparelli hemisphere of Mars projected into point perspective, a view similar to that which one would see from a spacecraft. The images were acquired in 1980 during early northern…</p></div>, <div class=\"description\"><a class=\"itemLink product-item\" href=\"/search/map/Mars/Viking/syrtis_major_enhanced\"><h3>Syrtis Major Hemisphere Enhanced</h3></a><span class=\"subtitle\" style=\"float:left\">image/tiff 25 MB</span><span class=\"pubDate\" style=\"float:right\"></span><br/><p>Mosaic of the Syrtis Major hemisphere of Mars projected into point perspective, a view similar to that which one would see from a spacecraft. This mosaic is composed of about 100 red and violet…</p></div>, <div class=\"description\"><a class=\"itemLink product-item\" href=\"/search/map/Mars/Viking/valles_marineris_enhanced\"><h3>Valles Marineris Hemisphere Enhanced</h3></a><span class=\"subtitle\" style=\"float:left\">image/tiff 27 MB</span><span class=\"pubDate\" style=\"float:right\"></span><br/><p>Mosaic of the Valles Marineris hemisphere of Mars projected into point perspective, a view similar to that which one would see from a spacecraft. The distance is 2500 kilometers from the surface of…</p></div>]\n" ] ], [ [ "**Step 2 - MongoDB and Flask Application**", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ] ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ [ [ "%matplotlib inline", "_____no_output_____" ], [ "import numpy as np\nfrom matplotlib import pyplot as plt", "_____no_output_____" ] ], [ [ "### Generate a realization of 5000 points within a single halo of conc=5", "_____no_output_____" ] ], [ [ "from ellipsoidal_nfw import random_nfw_ellipsoid\n\nnpts = 5_000\nconc = np.zeros(npts)+5.\nx, y, z = random_nfw_ellipsoid(conc, b=2, c=3)\n\nfig, (ax0, ax1, ax2) = plt.subplots(1, 3, figsize=(12, 4))\nfig.tight_layout(pad=3.0)\n\nfor ax in ax0, ax1, ax2:\n xlim = ax.set_xlim(-4, 4)\n ylim = ax.set_ylim(-4, 4)\n\n__=ax0.scatter(x, y, s=1)\n__=ax1.scatter(x, z, s=1)\n__=ax2.scatter(y, z, s=1)\n\nxlabel = ax0.set_xlabel(r'$x$')\nylabel = ax0.set_ylabel(r'$y$')\nxlabel = ax1.set_xlabel(r'$x$')\nylabel = ax1.set_ylabel(r'$z$')\nxlabel = ax2.set_xlabel(r'$y$')\nylabel = ax2.set_ylabel(r'$z$')\n\nfig.savefig('ellipsoidal_nfw.png', bbox_extra_artists=[xlabel, ylabel], bbox_inches='tight', dpi=200)", "_____no_output_____" ] ], [ [ "### Generate a realization of a collection of 10 halos, each with 5000 points, each with different concentrations", "_____no_output_____" ] ], [ [ "npts_per_halo = 5_000\nn_halos = 10\nconc = np.linspace(5, 25, n_halos)\nconc_halopop = np.repeat(conc, npts_per_halo)\nx, y, z = random_nfw_ellipsoid(conc_halopop, b=2, c=3)\nx = x.reshape((n_halos, npts_per_halo))\ny = y.reshape((n_halos, npts_per_halo))\nz = z.reshape((n_halos, npts_per_halo))\n", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code" ]

[ [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "#This is Task 2 of GRIP internship\nTo Explore Supervised Machine Learning", "_____no_output_____" ] ], [ [ "#Importing all the libraries required for the code\nimport pandas as pd\nimport numpy as np \nimport matplotlib.pyplot as plt \n%matplotlib inline", "_____no_output_____" ], [ "# Loading Data from the given URL\nurl = \"http://bit.ly/w-data\"\ndata = pd.read_csv(url)\nprint(\"shape of dataset: {}\".format(data.shape))\nprint(data.head(5))", "shape of dataset: (25, 2)\n Hours Scores\n0 2.5 21\n1 5.1 47\n2 3.2 27\n3 8.5 75\n4 3.5 30\n" ], [ "# Plotting the distribution of score using matplotlib\nplt.figure(figsize=(10, 6), dpi=100)\nplt.title(\"Distribution of Score\")\nplt.xlabel(\"Hours\")\nplt.ylabel(\"Scores\")\nplt.scatter(data.Hours,data.Scores,color=\"b\",marker=\"*\")\nplt.show()", "_____no_output_____" ] ], [ [ "# Preparing the data for training", "_____no_output_____" ], [ "Dividing the data into attributes (Inputs) and labels (Outputs)", "_____no_output_____" ] ], [ [ "# Dividing the data into attributes(Inputs) and label(Outputs)\nx = data.iloc[:, :-1].values \ny = data.iloc[:, 1].values ", "_____no_output_____" ] ], [ [ "splitting the data set into tranining and testing data", "_____no_output_____" ] ], [ [ "from sklearn.model_selection import train_test_split \nx_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=0) \nprint(\"training dataset shape: {}\".format(x_train.shape))\nprint(\"testing dataset shape: {}\".format(x_test.shape))", "training dataset shape: (20, 1)\ntesting dataset shape: (5, 1)\n" ] ], [ [ "#Training the model", "_____no_output_____" ] ], [ [ "# Importing library for linear regression\nfrom sklearn.linear_model import LinearRegression \nmodel = LinearRegression() \nmodel.fit(x_train, y_train)", "_____no_output_____" ] ], [ [ "Plotting the linear regression line with training data", "_____no_output_____" ] ], [ [ "# Defining the equation of line\nprint(\"coefficient: {}, intercept: {}\".format(model.coef_, model.intercept_))\nline = model.coef_*x + model.intercept_\n# plotting line with data\nplt.figure(figsize=(10, 6), dpi=100)\n#plotting training data\nplt.scatter(x_train, y_train, color=\"c\",marker=\"*\")\n#plotting testing data\nplt.scatter(x_test, y_test, color=\"m\",marker=\"+\")\nplt.plot(x, line)\nplt.title(\"Distribution of Score and Regression line\")\nplt.xlabel(\"Hours\")\nplt.ylabel(\"Scores\")\nplt.show()", "coefficient: [9.91065648], intercept: 2.018160041434662\n" ] ], [ [ "# Results", "_____no_output_____" ] ], [ [ "# getting predictions for test data\ny_predicted = model.predict(x_test)", "_____no_output_____" ], [ "# Comparing Actual vs Predicted\ndf = pd.DataFrame({'Actual': y_test, 'Predicted': y_predicted}) \nprint(df)", " Actual Predicted\n0 20 16.884145\n1 27 33.732261\n2 69 75.357018\n3 30 26.794801\n4 62 60.491033\n" ] ], [ [ "#predicted score if a student study for 9.25 hrs in a day", "_____no_output_____" ] ], [ [ "s_hours = 9.25\ns_score = model.predict([[shours]])\nprint(\"predicted score if a student study for {} hrs in a day is {}\".format(s_hours, s_score[0]))", "predicted score if a student study for 9.25 hrs in a day is 93.69173248737539\n" ] ], [ [ "# Calculating error for the model", "_____no_output_____" ] ], [ [ "from sklearn import metrics \nprint('Mean Absolute Error: {}'.format(metrics.mean_absolute_error(y_test, y_predicted)))\naccuracy = 100 * model.score(x_test, y_test)\nprint(\"Accuracy(%): \", accuracy)", "Mean Absolute Error: 4.183859899002982\nAccuracy(%): 94.54906892105353\n" ], [ "", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code", "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ] ]

[ "CC-BY-4.0" ]

[ "CC-BY-4.0" ]

[ "CC-BY-4.0" ]

[ [ [ "empty" ] ] ]

[ "empty" ]

[ [ "empty" ] ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ [ [ "#Run this cell to install the necessary dependencies\nimport pandas as pd\nimport numpy as np\nfrom datascience import *\n\n%matplotlib inline\nimport matplotlib.pyplot as plt\nplt.style.use('fivethirtyeight')", "_____no_output_____" ] ], [ [ "# Project 2: Spotify", "_____no_output_____" ], [ "## Table of Contents\n<a href='#section 0'>Background Knowledge: Topic</a>\n\n1. <a href='#section 1'> The Data Science Life Cycle</a>\n\n a. <a href='#subsection 1a'>Formulating a question or problem</a> \n\n b. <a href='#subsection 1b'>Acquiring and cleaning data</a>\n\n c. <a href='#subsection 1c'>Conducting exploratory data analysis</a>\n\n d. <a href='#subsection 1d'>Using prediction and inference to draw conclusions</a>\n<br><br>", "_____no_output_____" ], [ "### Background Knowledge <a id='section 0'></a>\n", "_____no_output_____" ], [ "If you listen to music, chances are you use Spotify, Apple Music, or another similar streaming service. This new era of the music industry curates playlists, recommends new artists, and is based on the number of streams more than the number of albums sold. The way these streaming services do this is (you guessed it) data!\n\nSpotify, like many other companies, hire many full-time data scientists to analyze all the incoming user data and use it to make predictions and recommendations for users. If you're interested, feel free to check out [Spotify's Engineering Page](https://engineering.atspotify.com/) for more information!", "_____no_output_____" ], [ "<img src=\"images/spotify.png\" width = 700/>\n\n<center><a href=https://hrblog.spotify.com/2018/02/08/amping-up-diversity-inclusion-at-spotify/>Image Reference</a></center> ", "_____no_output_____" ], [ "# The Data Science Life Cycle <a id='section 1'></a>", "_____no_output_____" ], [ "## Formulating a Question or Problem <a id='subsection 1a'></a>\nIt is important to ask questions that will be informative and can be answered using the data. There are many different questions we could ask about music data. For example, there are many artists who want to find out how to get their music on Spotify's Discover Weekly playlist in order to gain exposure. Similarly, users love to see their *Spotify Wrapped* listening reports at the end of each year.", "_____no_output_____" ], [ "<div class=\"alert alert-warning\">\n<b>Question:</b> Recall the questions you developed with your group on Tuesday. Write down that question below, and try to add on to it with the context from the articles from Wednesday. Think about what data you would need to answer your question. You can review the articles on the bCourses page under Module 4.3.\n </div>", "_____no_output_____" ], [ "**Original Question(s):** *here*\n\n\n**Updated Question(s):** *here*\n\n\n**Data you would need:** *here*\n", "_____no_output_____" ], [ "## Acquiring and Cleaning Data <a id='subsection 1b'></a>\n\nWe'll be looking at song data from Spotify. You can find the raw data [here](https://github.com/rfordatascience/tidytuesday/tree/master/data/2020/2020-01-21). We've cleaned up the datasets a bit, and we will be investigating the popularity and the qualities of songs from this dataset.\n\nThe following table, `spotify`, contains a list of tracks identified by their unique song ID along with attributes about that track.\n\nHere are the descriptions of the columns for your reference. (We will not be using all of these fields):\n\n|Variable Name | Description |\n|--------------|------------|\n|`track_id` | \tSong unique ID |\n|`track_name` | Song Name |\n|`track_artist\t`| Song Artist |\n|`track_popularity` | Song Popularity (0-100) where higher is better |\n|`track_album_id`| Album unique ID |\n|`track_album_name` | Song album name |\n|`track_album_release_date`| Date when album released |\n|`playlist_name`| Name of playlist |\n|`playlist_id`| Playlist ID |\n|`playlist_genre`| Playlist genre |\n|`playlist_subgenre\t`| Playlist subgenre |\n|`danceability`| Danceability describes how suitable a track is for dancing based on a combination of musical elements including tempo, rhythm stability, beat strength, and overall regularity. A value of 0.0 is least danceable and 1.0 is most danceable. |\n|`energy`| Energy is a measure from 0.0 to 1.0 and represents a perceptual measure of intensity and activity. Typically, energetic tracks feel fast, loud, and noisy. For example, death metal has high energy, while a Bach prelude scores low on the scale. Perceptual features contributing to this attribute include dynamic range, perceived loudness, timbre, onset rate, and general entropy. |\n|`key`| The estimated overall key of the track. Integers map to pitches using standard Pitch Class notation . E.g. 0 = C, 1 = C♯/D♭, 2 = D, and so on. If no key was detected, the value is -1. |\n|`loudness`| The overall loudness of a track in decibels (dB). Loudness values are averaged across the entire track and are useful for comparing relative loudness of tracks. Loudness is the quality of a sound that is the primary psychological correlate of physical strength (amplitude). Values typical range between -60 and 0 db. |\n|`mode`| Mode indicates the modality (major or minor) of a track, the type of scale from which its melodic content is derived. Major is represented by 1 and minor is 0. |\n|`speechiness`| Speechiness detects the presence of spoken words in a track. The more exclusively speech-like the recording (e.g. talk show, audio book, poetry), the closer to 1.0 the attribute value. Values above 0.66 describe tracks that are probably made entirely of spoken words. Values between 0.33 and 0.66 describe tracks that may contain both music and speech, either in sections or layered, including such cases as rap music. Values below 0.33 most likely represent music and other non-speech-like tracks. |\n|`acousticness`| A confidence measure from 0.0 to 1.0 of whether the track is acoustic. 1.0 represents high confidence the track is acoustic. |\n|`instrumentalness`| Predicts whether a track contains no vocals. “Ooh” and “aah” sounds are treated as instrumental in this context. Rap or spoken word tracks are clearly “vocal”. The closer the instrumentalness value is to 1.0, the greater likelihood the track contains no vocal content. Values above 0.5 are intended to represent instrumental tracks, but confidence is higher as the value approaches 1.0. |\n|`liveness`| Detects the presence of an audience in the recording. Higher liveness values represent an increased probability that the track was performed live. A value above 0.8 provides strong likelihood that the track is live. |\n|`valence`| A measure from 0.0 to 1.0 describing the musical positiveness conveyed by a track. Tracks with high valence sound more positive (e.g. happy, cheerful, euphoric), while tracks with low valence sound more negative (e.g. sad, depressed, angry). |\n|`tempo`| The overall estimated tempo of a track in beats per minute (BPM). In musical terminology, tempo is the speed or pace of a given piece and derives directly from the average beat duration. |\n|`duration_ms`| Duration of song in milliseconds |\n|`creation_year`| Year when album was released |\n\n\n", "_____no_output_____" ] ], [ [ "spotify = Table.read_table('data/spotify.csv')\nspotify.show(10)", "_____no_output_____" ] ], [ [ "<div class=\"alert alert-info\">\n<b>Question:</b> It's important to evalute our data source. What do you know about the source? What motivations do they have for collecting this data? What data is missing?\n </div>", "_____no_output_____" ], [ "*Insert answer here*", "_____no_output_____" ], [ "<div class=\"alert alert-info\">\n<b>Question:</b> Do you see any missing (nan) values? Why might they be there?\n </div>", "_____no_output_____" ], [ "*Insert answer here*", "_____no_output_____" ], [ "<div class=\"alert alert-info\">\n<b>Question:</b> We want to learn more about the dataset. First, how many total rows are in this table? What does each row represent?\n \n </div>", "_____no_output_____" ] ], [ [ "total_rows = spotify.num_rows\ntotal_rows", "_____no_output_____" ] ], [ [ "*Insert answer here*", "_____no_output_____" ], [ "## Conducting Exploratory Data Analysis <a id='subsection 1c'></a>", "_____no_output_____" ], [ "Visualizations help us to understand what the dataset is telling us. We will be using bar charts, scatter plots, and line plots to try to answer questions like the following:\n> What audio features make a song popular and which artists have these songs? How have features changed over time?", "_____no_output_____" ], [ "### Part 1: We'll start by looking at the length of songs using the `duration_ms` column.", "_____no_output_____" ], [ "Right now, the `duration` array contains the length of each song in milliseconds. However, that's not a common measurement when describing the length of a song - often, we use minutes and seconds. Using array arithmetic, we can find the length of each song in seconds and in minutes. There are 1000 milliseconds in a second, and 60 seconds in a minute. First, we will convert milliseconds to seconds.\n", "_____no_output_____" ] ], [ [ "#Access the duration column as an array.\nduration = spotify.column(\"duration_ms\")\nduration", "_____no_output_____" ], [ "#Divide the milliseconds by 1000\nduration_seconds = duration / 1000\nduration_seconds", "_____no_output_____" ], [ "#Now convert duration_seconds to minutes.\nduration_minutes = duration_seconds / 60\nduration_minutes ", "_____no_output_____" ] ], [ [ "<div class=\"alert alert-info\">\n<b>Question:</b> How would we find the average duration (in minutes) of the songs in this dataset?\n </div>", "_____no_output_____" ] ], [ [ "avg_song_length_mins = np.mean(duration_minutes)\navg_song_length_mins", "_____no_output_____" ] ], [ [ "Now, we can add in the duration for each song (in minutes) by adding a column to our `spotify` table called `duration_min`. Run the following cell to do so.", "_____no_output_____" ] ], [ [ "#This cell will add the duration in minutes column we just created to our dataset.\nspotify = spotify.with_columns('duration_min', duration_minutes)\nspotify", "_____no_output_____" ] ], [ [ "### Artist Comparison", "_____no_output_____" ], [ "Let's see if we can find any meaningful difference in the average length of song for different artists.", "_____no_output_____" ], [ "<div class=\"alert alert-success\">\n <b>Note: </b>Now that we have the average duration for each song, you can compare average song length between two artists. Below is an example!\n </div>", "_____no_output_____" ] ], [ [ "sam_smith = spotify.where(\"track_artist\", are.equal_to(\"Sam Smith\"))\nsam_smith", "_____no_output_____" ], [ "sam_smith_mean = sam_smith.column(\"duration_min\").mean()\nsam_smith_mean", "_____no_output_____" ], [ "#In this cell, choose an artist you want to look at.\nartist_name = spotify.where(\"track_artist\", \"Kanye West\").column(\"duration_min\").mean()\nartist_name", "_____no_output_____" ], [ "#In this cell, choose another artist you want to compare it to.\nartist_name_2 = spotify.where(\"track_artist\", \"Justin Bieber\").column(\"duration_min\").mean()\nartist_name_2", "_____no_output_____" ] ], [ [ "This exercise was just one example of how you can play around with data and answer questions.", "_____no_output_____" ], [ "### Top Genres and Artists\nIn this section, we are interested in the categorical information in our dataset, such as the playlist each song comes from or the genre. There are almost 33,000 songs in our dataset, so let's do some investigating. What are the most popular genres? We can figure this out by grouping by the playlist genre.", "_____no_output_____" ], [ "<div class=\"alert alert-info\">\n<b>Question:</b> How can we group our data by unique genres?\n </div>", "_____no_output_____" ] ], [ [ "genre_counts = spotify.group('playlist_genre')\ngenre_counts", "_____no_output_____" ] ], [ [ "<div class=\"alert alert-info\">\n<b>Question:</b> In our dataset, it looks like the most popular genre is EDM. Make a barchart below to show how the other genres compare.\n </div>", "_____no_output_____" ] ], [ [ "genre_counts.barh('playlist_genre', 'count')", "_____no_output_____" ] ], [ [ "Notice that it was difficult to analyze the above bar chart because the data wasn't sorted first. Let's sort our data and make a new bar chart so that it is much easier to make comparisons.", "_____no_output_____" ] ], [ [ "genre_counts_sorted = genre_counts.sort('count', descending = True)\ngenre_counts_sorted", "_____no_output_____" ], [ "genre_counts_sorted.barh('playlist_genre', 'count')", "_____no_output_____" ] ], [ [ "<div class=\"alert alert-info\">\n<b>Question:</b> Was this what you expected? Which genre did you think would be the most popular?\n </div>", "_____no_output_____" ], [ "*Insert answer here.*", "_____no_output_____" ], [ "<div class=\"alert alert-info\">\n<b>Question:</b> Let's take a look at all the artists in the dataset. We can take a look at the top 25 artists based on the number of songs they have in our dataset. We'll follow a similar method as we did when grouping by genre above. First, we will group our data by artist and sort by count.\n </div>", "_____no_output_____" ] ], [ [ "#Here, we will group and sort in the same line.\n\nartists_grouped = spotify.group('track_artist').sort('count', descending=True)\nartists_grouped", "_____no_output_____" ], [ "top_artists = artists_grouped.take(np.arange(0, 25))\ntop_artists", "_____no_output_____" ], [ "top_artists.barh('track_artist', 'count')", "_____no_output_____" ] ], [ [ "<div class=\"alert alert-info\">\n<b>Question:</b> What do you notice about the top 25 artists in our dataset?\n </div>", "_____no_output_____" ], [ "*insert answer here*", "_____no_output_____" ], [ "### Playlist Popularity", "_____no_output_____" ], [ "In our dataset, each song is listed as belonging to a particular playlist, and each song is given a \"popularity score\", called the `track_popularity`. Using the `track_popularity`, we can calculate an *aggregate popularity* for each playlist, which is just the sum of all the popularity scores for the songs on the playlist.\n\nIn order to create this aggregate popularity score, we need to group our data by playlist, and sum all of the popularity scores. First, we will create a subset of our `spotify` table using the `select` method. This lets us create a table with only the relevant columns we want. In this case, we only care about the name of the playlist and the popularity of each track. Keep in mind that each row still represents one track, even though we no longer have the track title in our table.", "_____no_output_____" ] ], [ [ "spotify_subset = spotify.select(['playlist_name', 'track_popularity'])\nspotify_subset", "_____no_output_____" ] ], [ [ "<div class=\"alert alert-success\">\n<b>Note:</b> By grouping, we can get the number of songs from each playlist.\n </div>", "_____no_output_____" ] ], [ [ "playlists = spotify_subset.group('playlist_name')\nplaylists", "_____no_output_____" ] ], [ [ "<div class=\"alert alert-info\">\n <b>Question:</b> We can use the <code>group</code> method again, this time passing in a second argument <code>collect</code>, which says that we want to take the sum rather than the count when grouping. This results in a table with the total aggregate popularity of each playlist.\n </div>", "_____no_output_____" ] ], [ [ "#Run this cell.\ntotal_playlist_popularity = spotify_subset.group('playlist_name', collect = sum)\ntotal_playlist_popularity", "_____no_output_____" ] ], [ [ "Similar to when we found duration in minutes, we can once again use the `column` method to access just the `track_popularity sum` column, and add it to our playlists table using the `with_column` method.", "_____no_output_____" ] ], [ [ "agg_popularity = total_playlist_popularity.column('track_popularity sum')\nplaylists = playlists.with_column('aggregate_popularity', agg_popularity)\nplaylists", "_____no_output_____" ] ], [ [ "<div class=\"alert alert-info\">\n<b>Question:</b> Do you think that the most popular playlist would be the one with the highest aggregate_popularity score, or the one with the highest number of songs? We can sort our playlists table and compare the outputs.", "_____no_output_____" ] ], [ [ "playlists.sort('count', descending=True)", "_____no_output_____" ] ], [ [ "<div class=\"alert alert-info\">\n<b>Question:</b> Now sort by aggregate popularity.\n </div>", "_____no_output_____" ] ], [ [ "playlists.sort('aggregate_popularity', descending=True)", "_____no_output_____" ] ], [ [ "Comparing these two outputs shows us that the \"most popular playlist\" depends on how we judge popularity. If we have a playlist that has only a few songs, but each of those songs are really popular, should that playlist be higher on the popularity rankings? By way of calculation, playlists with more songs will have a higher aggregate popularity, since more popularity values are being added together. We want a metric that will let us judge the actual quality and popularity of a playlist, not just how many songs it has.\n\nIn order to take into account the number of songs on each playlist, we can calculate the \"average popularity\" of each song on the playlist, or the proportion of aggregate popularity that each song takes up. We can do this by dividing `aggregate_popularity` by `count`. Remember, since the columns are just arrays, we can use array arithmetic to calculate these values.", "_____no_output_____" ] ], [ [ "#Run this cell to get the average.\navg_popularity = playlists.column('aggregate_popularity') / playlists.column('count')", "_____no_output_____" ], [ "#Now add it to the playlists table.\nplaylists = playlists.with_column('average_popularity', avg_popularity)\nplaylists", "_____no_output_____" ] ], [ [ "Let's see if our \"most popular playlist\" changes when we judge popularity by the average popularity of the songs on a playlist.", "_____no_output_____" ] ], [ [ "playlists.sort('average_popularity', descending=True)", "_____no_output_____" ] ], [ [ "Looking at the table above, we notice that 8/10 of the top 10 most popular playlists by the `average_popularity` metric are playlists with less than 100 songs. Just because a playlist has a lot of songs, or a high aggregate popularity, doesn't mean that the average popularity of a song on that playlist is high. Our new metric of `average_popularity` lets us rank playlists where the size of a playlist has no effect on it's overall score. We can visualize the top 25 playlists by average popularity in a bar chart.", "_____no_output_____" ] ], [ [ "top_25_playlists = playlists.sort('average_popularity', descending=True).take(np.arange(25))\ntop_25_playlists.barh('playlist_name', 'average_popularity')", "_____no_output_____" ] ], [ [ "Creating a new metric like `average_popularity` helps us more accurately and fairly measure the popularity of a playlist. \n\nWe saw before when looking at the top 25 artists that they were all male. Now looking at the top playlists, we see that the current landscape of popular playlists and music may have an effect on the artists that are popular. For example, the RapCaviar is the second most popular playlist, and generally there tends to be fewer female rap artists than male. This shows that the current landscape of popular music can affect the types of artists topping the charts.", "_____no_output_____" ], [ "## Using prediction and inference to draw conclusions <a id='subsection 1a'></a>", "_____no_output_____" ], [ "Now that we have some experience making these visualizations, let's go back to the visualizations others are working on to analyze Spotify data using more complex techniques.\n\n[Streaming Dashboard](https://public.tableau.com/profile/vaibhavi.gaekwad#!/vizhome/Spotify_15858686831320/Dashboard1)\n\n[Audio Analysis Visualizer](https://developer.spotify.com/community/showcase/spotify-audio-analysis/)", "_____no_output_____" ], [ "Music and culture are very intertwined so it's interesting to look at when songs are released and what is popular during that time. In this last exercise, you will be looking at the popularity of artists and tracks based on the dates you choose.\n\nLet's look back at the first five rows of our `spotify` table once more.", "_____no_output_____" ] ], [ [ "spotify.show(5)", "_____no_output_____" ] ], [ [ "<div class=\"alert alert-info\">\n <b>Question:</b> Fill in the following cell the data according to the <code>creation_year</code> you choose.\n </div>", "_____no_output_____" ] ], [ [ "#Fill in the year as an integer.\nby_year = spotify.where(\"creation_year\", are.equal_to(2018))\nby_year", "_____no_output_____" ] ], [ [ "Based on the dataset you have now, use previous techniques to find the most popular song during that year. First group by what you want to look at, for example, artist/playlist/track.", "_____no_output_____" ] ], [ [ "your_grouped = by_year.group(\"playlist_name\")\npop_track = your_grouped.sort(\"count\", descending = True)\npop_track", "_____no_output_____" ], [ "pop_track.take(np.arange(25)).barh(\"playlist_name\", \"count\")", "_____no_output_____" ] ], [ [ "<div class=\"alert alert-info\">\n<b>Question:</b> Finally, use this cell if you want to look at the popularity of a track released on a specific date. It's very similar to the process above.\n </div>", "_____no_output_____" ] ], [ [ "by_date = spotify.where(\"track_album_release_date\", are.equal_to(\"2019-06-14\"))\nyour_grouped = by_date.group(\"track_artist\")\npop_track = your_grouped.sort(\"count\", descending = True)\npop_track.take(np.arange(10)).barh(\"track_artist\", \"count\")", "_____no_output_____" ] ], [ [ "<div class=\"alert alert-info\">\n<b>Question:</b> Tell us something interesting about this data.\n </div>", "_____no_output_____" ], [ "*Insert answer here.*", "_____no_output_____" ], [ "Notebook Authors: Alleanna Clark", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "code" ], [ "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code", "code", "code", "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# [01/02/22] LTH on a Data Diet -- 2 Pass Initial Results", "_____no_output_____" ] ], [ [ "import matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nfrom pathlib import Path\nimport seaborn as sns\nplt.style.use('default')\nsns.set_theme(\n style='ticks',\n font_scale=1.2,\n rc={\n 'axes.linewidth': '0.8',\n 'axes.grid': True,\n 'figure.constrained_layout.use': True,\n 'grid.linewidth': '0.8',\n 'legend.edgecolor': '1.0',\n 'legend.fontsize': 'small',\n 'legend.title_fontsize': 'small',\n 'xtick.major.width': '0.8',\n 'ytick.major.width': '0.8'\n },\n)", "_____no_output_____" ] ], [ [ "## Figure 0016", "_____no_output_____" ] ], [ [ "exp_meta_paths = [\n Path(f'/home/mansheej/open_lth_data/lottery_b279562b990bac9b852b17b287fca1ef/'),\n Path(f'/home/mansheej/open_lth_data/lottery_78a119e24960764e0de0964887d2597f/'),\n Path(f'/home/mansheej/open_lth_data/lottery_2cb77ad7e940a06d07b04a4b63fd718d/'),\n Path(f'/home/mansheej/open_lth_data/lottery_511428cbe43275064244db39edd0f60f/'),\n]\nexp_paths = [[emp / f'replicate_{i}' for i in range(1, 5)] for emp in exp_meta_paths]\n\nplt.figure(figsize=(8.4, 4.8))\nls = []\n\nfor i, eps in enumerate(exp_paths):\n num_levels = 15\n acc_run_level = []\n for p in eps:\n acc_level = []\n for l in range(num_levels + 1):\n df = pd.read_csv(p / f'level_{l}/main/logger', header=None)\n acc_level.append(df[2].iloc[-2])\n acc_run_level.append(acc_level)\n acc_run_level = np.array(acc_run_level)\n x = np.arange(16)\n ys = acc_run_level\n y_mean, y_std = ys.mean(0), ys.std(0)\n c = f'C{i}'\n l = plt.plot(x, y_mean, c=c, alpha=0.9, linewidth=2)\n ls.append(l[0])\n plt.fill_between(x, y_mean + y_std, y_mean - y_std, color=c, alpha=0.2)\n\nplt.legend(\n ls, \n [ \n 'Pre-train 1 Pass -> All 50000 Examples',\n 'Pre-train 2 Passes -> All 50000 Examples',\n 'Pre-train 2 Passes -> 32000 Smallest Scores at Epoch 3',\n 'Pre-train 2 Passes -> 12800 Smallest Scores at Epoch 3',\n ],\n)\nplt.xlim(0, 15)\nplt.ylim(0.815, 0.925)\nplt.xticks(np.arange(0, 16, 2), [f'{f*100:.1f}' for f in 0.8**np.arange(0, 16, 2)])\nplt.xlabel('% Weights Remaining')\nplt.ylabel('Test Accuracy')\nplt.title('CIFAR10 ResNet20: Pre-train LR = 0.4')\nsns.despine()\nplt.savefig('/home/mansheej/open_lth/figs/0016.svg')\nplt.show()", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "BSD-3-Clause-No-Nuclear-License-2014", "BSD-3-Clause" ]

[ "BSD-3-Clause-No-Nuclear-License-2014", "BSD-3-Clause" ]

[ "BSD-3-Clause-No-Nuclear-License-2014", "BSD-3-Clause" ]

[ [ [ "# Naive Bayes and Logistic Regression", "_____no_output_____" ], [ "In this tutorial, we'll explore training and evaluation of Naive Bayes and Logitistic Regression Classifiers.\n\nTo start, we import the standard BIDMach class definitions. ", "_____no_output_____" ] ], [ [ "import $exec.^.lib.bidmach_notebook_init", "1 CUDA device found, CUDA version 8.0\n" ] ], [ [ "Now we load some training and test data, and some category labels. The data come from a news collection from Reuters, and is a \"classic\" test set for classification. Each article belongs to one or more of 103 categories. The articles are represented as Bag-of-Words (BoW) column vectors. For a data matrix A, element A(i,j) holds the count of word i in document j. \n\nThe category matrices have 103 rows, and a category matrix C has a one in position C(i,j) if document j is tagged with category i, or zero otherwise. \n\nTo reduce the computing time and memory footprint, the training data have been sampled. The full collection has about 700k documents. Our training set has 60k. \n\nSince the document matrices contain counts of words, we use a min function to limit the count to \"1\", i.e. because we need binary features for naive Bayes. ", "_____no_output_____" ] ], [ [ "val dict = \"../data/rcv1/\"\nval traindata = loadSMat(dict+\"docs.smat.lz4\")\nval traincats = loadFMat(dict+\"cats.fmat.lz4\")\nval testdata = loadSMat(dict+\"testdocs.smat.lz4\")\nval testcats = loadFMat(dict+\"testcats.fmat.lz4\")\nmin(traindata, 1, traindata) // the first \"traindata\" argument is the input, the other is output\nmin(testdata, 1, testdata)", "_____no_output_____" ] ], [ [ "Get the word and document counts from the data. This turns out to be equivalent to a matrix multiply. For a data matrix A and category matrix C, we want all (cat, word) pairs (i,j) such that C(i,k) and A(j,k) are both 1 - this means that document k contains word j, and is also tagged with category i. Summing over all documents gives us\n\n$${\\rm wordcatCounts(i,j)} = \\sum_{k=1}^N C(i,k) A(j,k) = C * A^T$$\n\n\nBecause we are doing independent binary classifiers for each class, we need to construct the counts for words not in the class (negwcounts).\n\nFinally, we add a smoothing count 0.5 to counts that could be zero.", "_____no_output_____" ] ], [ [ "val truecounts = traincats *^ traindata\nval wcounts = truecounts + 0.5\nval negwcounts = sum(truecounts) - truecounts + 0.5\nval dcounts = sum(traincats,2)", "_____no_output_____" ] ], [ [ "Now compute the probabilities \n* pwordcat = probability that a word is in a cat, given the cat.\n* pwordncat = probability of a word, given the complement of the cat.\n* pcat = probability that doc is in a given cat. \n* spcat = sum of pcat probabilities (> 1 because docs can be in multiple cats)", "_____no_output_____" ] ], [ [ "val pwordcat = wcounts / sum(wcounts,2) // Normalize the rows to sum to 1.\nval pwordncat = negwcounts / sum(negwcounts,2) // Each row represents word probabilities conditioned on one cat. \nval pcat = dcounts / traindata.ncols\nval spcat = sum(pcat)", "_____no_output_____" ] ], [ [ "Now take the logs of those probabilities. Here we're using the formula presented <a href=\"https://bcourses.berkeley.edu/courses/1267848/files/51512989/download?wrap=1in\">here</a> to match Naive Bayes to Logistic Regression for independent data.\n\nFor each word, we compute the log of the ratio of the complementary word probability over the in-class word probability. \n\nFor each category, we compute the log of the ratio of the complementary category probability over the current category probability.\n\nlpwordcat(j,i) represents $\\log\\left(\\frac{{\\rm Pr}(X_i|\\neg c_j)}{{\\rm Pr}(X_i|c_j)}\\right)$\n\nwhile lpcat(j) represents $\\log\\left(\\frac{{\\rm Pr}(\\neg c)}{{\\rm Pr}(c)}\\right)$", "_____no_output_____" ] ], [ [ "val lpwordcat = ln(pwordncat/pwordcat) // ln is log to the base e (natural log)\nval lpcat = ln((spcat-pcat)/pcat)", "_____no_output_____" ] ], [ [ "Here's where we apply Naive Bayes. The formula we're using is borrowed from <a href=\"https://bcourses.berkeley.edu/courses/1267848/files/51512989/download?wrap=1in\">here</a>.\n\n$${\\rm Pr}(c|X_1,\\ldots,X_k) = \\frac{1}{1 + \\frac{{\\rm Pr}(\\neg c)}{{\\rm Pr}(c)}\\prod_{i-1}^k\\frac{{\\rm Pr}(X_i|\\neg c)}{{\\rm Pr}(X_i|c)}}$$\n\nand we can rewrite\n\n$$\\frac{{\\rm Pr}(\\neg c)}{{\\rm Pr}(c)}\\prod_{i-1}^k\\frac{{\\rm Pr}(X_i|\\neg c)}{{\\rm Pr}(X_i|c)}$$\n\nas\n\n$$\\exp\\left(\\log\\left(\\frac{{\\rm Pr}(\\neg c)}{{\\rm Pr}(c)}\\right) + \\sum_{i=1}^k\\log\\left(\\frac{{\\rm Pr}(X_i|\\neg c)}{{\\rm Pr}(X_i|c)}\\right)\\right) = \\exp({\\rm lpcat(j)} + {\\rm lpwordcat(j,?)} * X)$$\n\nfor class number j and an input column $X$. This follows because an input column $X$ is a sparse vector with ones in the positions of the input features. The product ${\\rm lpwordcat(i,?)} * X$ picks out the features occuring in the input document and adds the corresponding logs from lpwordcat. \n\nFinally, we take the exponential above and fold it into the formula $P(c_j|X_1,\\ldots,X_k) = 1/(1+\\exp(\\cdots))$. This gives us a matrix of predictions. preds(i,j) = prediction of membership in category i for test document j. ", "_____no_output_____" ] ], [ [ "val logodds = lpwordcat * testdata + lpcat\nval preds = 1 / (1 + exp(logodds))", "_____no_output_____" ] ], [ [ "To measure the accuracy of the predictions above, we can compute the probability that the classifier outputs the right label. We used this formula in class for the expected accuracy for logistic regression. The \"dot arrow\" operator takes dot product along rows:", "_____no_output_____" ] ], [ [ "val acc = ((preds ∙→ testcats) + ((1-preds) ∙→ (1-testcats)))/preds.ncols\nacc.t", "_____no_output_____" ] ], [ [ "Raw accuracy is not a good measure in most cases. When there are few positives (instances in the class vs. its complement), accuracy simply drives down false-positive rate at the expense of false-negative rate. In the worst case, the learner may always predict \"no\" and still achieve high accuracy. \n\nROC curves and ROC Area Under the Curve (AUC) are much better. Here we compute the ROC curves from the predictions above. We need:\n* scores - the predicted quality from the formula above.\n* good - 1 for positive instances, 0 for negative instances.\n* bad - complement of good. \n* npoints (100) - specifies the number of X-axis points for the ROC plot. \n\nitest specifies which of the categories to plot for. We chose itest=6 because that category has one of the highest positive rates, and gives the most stable accuracy plots. ", "_____no_output_____" ] ], [ [ "val itest = 6\nval scores = preds(itest,?)\nval good = testcats(itest,?)\nval bad = 1-testcats(itest,?)\nval rr =roc(scores,good,bad,100)", "_____no_output_____" ] ], [ [ "> TODO 1: In the cell below, write an expression to derive the ROC Area under the curve (AUC) given the curve rr. rr gives the ROC curve y-coordinates at 100 evenly-spaced X-values from 0 to 1.0. ", "_____no_output_____" ] ], [ [ "// auc = ", "_____no_output_____" ] ], [ [ "> TODO 2: In the cell below, write the value of AUC returned by the expression above.", "_____no_output_____" ], [ "## Logistic Regression", "_____no_output_____" ], [ "Now lets train a logistic classifier on the same data. BIDMach has an umbrella classifier called GLM for Generalized Linear Model. GLM includes linear regression, logistic regression (with log accuracy or direct accuracy optimization), and SVM. \n\nThe learner function accepts these arguments:\n* traindata: the training data in the same format as for Naive Bayes\n* traincats: the training category labels\n* testdata: the test input data\n* predcats: a container for the predictions generated by the model\n* modeltype (GLM.logistic here): an integer that specifies the type of model (0=linear, 1=logistic log accuracy, 2=logistic accuracy, 3=SVM). \n\nWe'll construct the learner and then look at its options:", "_____no_output_____" ] ], [ [ "val predcats = zeros(testcats.nrows, testcats.ncols)\nval (mm,mopts) = GLM.learner(traindata, traincats, GLM.maxp)\nmopts.what", "Option Name Type Value\n=========== ==== =====\naddConstFeat boolean false\naopts Opts null\nautoReset boolean true\nbatchSize int 10000\ncheckPointFile String null\ncheckPointInterval float 0.0\nclipByValue float -1.0\ncumScore int 0\ndebug int 0\ndebugCPUmem boolean false\ndebugMem boolean false\ndim int 256\ndoAllReduce boolean false\ndoubleScore boolean false\ndoVariance boolean false\nepsilon float 1.0E-5\nevalStep int 11\nfeatThreshold Mat null\nfeatType int 1\ngsq_decay float -1.0\nhashBound1 int 1000000\nhashBound2 int 1000000\nhashFeatures int 0\ninitsumsq float 1.0E-5\niweight FMat null\nl2reg FMat null\nlangevin float 0.0\nlim float 0.0\nlinks IMat 2,2,2,2,2,2,2,2,2,2,...\nlogDataSink DataSink null\nlogfile String log.txt\nlogFuncs Function2[] null\nlr_policy Function3 null\nlrate FMat 1\nmask FMat null\nmatrixOfScores boolean false\nmax_grad_norm float -1.0\nmixinInterval int 1\nnaturalLambda float 0.0\nnesterov_vel_decay FMat null\nnNatural int 1\nnpasses int 2\nnzPerColumn int 0\npauseAt long -1\npexp FMat 0\npstep float 0.01\nputBack int -1\nr1nmats int 1\nreg1weight FMat 1.0000e-07\nresFile String null\nrmask FMat null\nsample float 1.0\nsizeMargin float 3.0\nstartBlock int 8000\ntargets FMat null\ntargmap FMat null\ntexp FMat 0.50000\ntrace int 0\nupdateAll boolean false\nuseCache boolean true\nuseDouble boolean false\nuseGPU boolean true\nuseGPUcache boolean true\nvel_decay FMat null\nvexp FMat 0.50000\nwaitsteps int 3\n" ] ], [ [ "The most important options are:\n* lrate: the learning rate\n* batchSize: the minibatch size\n* npasses: the number of passes over the dataset\n\nWe'll use the following parameters for this training run. ", "_____no_output_____" ] ], [ [ "mopts.lrate=1.0\nmopts.batchSize=1000\nmopts.npasses=2\nmm.train", "corpus perplexity=81528.088805\n" ], [ "val (nn, nopts) = GLM.predictor(mm.model, testdata)\n\nnn.predict", "_____no_output_____" ], [ "val predcats = FMat(nn.preds(0))\nval lacc = (predcats ∙→ testcats + (1-predcats) ∙→ (1-testcats))/preds.ncols\nlacc.t\nmean(lacc)", "_____no_output_____" ] ], [ [ "Since we have the accuracy scores for both Naive Bayes and Logistic regression, we can plot both of them on the same axes. Naive Bayes is red, Logistic regression is blue. The x-axis is the category number from 0 to 102. The y-axis is the absolute accuracy of the predictor for that category. ", "_____no_output_____" ] ], [ [ "val axaxis = row(0 until 103)\nplot(axaxis, acc, axaxis, lacc)", "_____no_output_____" ] ], [ [ "> TODO 3: With the full training set (700k training documents), Logistic Regression is noticeably more accurate than Naive Bayes in every category. What do you observe in the plot above? Why do you think this is?", "_____no_output_____" ], [ "Next we'll compute the ROC plot and ROC area (AUC) for Logistic regression for category itest.", "_____no_output_____" ] ], [ [ "val lscores = predcats(itest,?)\nval lrr =roc(lscores,good,bad,100)\nval auc = mean(lrr) // Fill in using the formula you used before", "_____no_output_____" ] ], [ [ "We computed the ROC curve for Naive Bayes earlier, so now we can plot them on the same axes. Naive Bayes is once again in red, Logistic regression in blue. ", "_____no_output_____" ] ], [ [ "val rocxaxis = row(0 until 101)\nplot(rocxaxis, rr, rocxaxis, lrr)", "_____no_output_____" ] ], [ [ ">TODO 4: In the cell below, compute and plot lift curves from the ROC curves for Naive Bayes and Logistic regression. The lift curves should show the ratio of ROC y-values over a unit slope diagonal line (Y=X). The X-values should be the same as for the ROC plots, except that X=0 will be omitted since the lift will be undefined. ", "_____no_output_____" ], [ "> TODO 5: Experiment with different values for learning rate and batchSize to get the best performance for absolute accuracy and ROC area on category 6. Write your optimal values below:", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "import pandas as pd\nimport numpy as np\nfrom sklearn import tree\nimport numpy as np\nfrom sklearn.metrics import roc_auc_score\n\n%matplotlib inline", "_____no_output_____" ] ], [ [ "I'll be demonstrating just the classification problems , you can build regression following a very similar process", "_____no_output_____" ] ], [ [ "# data prep from previous module\nci_train=pd.read_csv('census_income.csv')\n\n# if you have a test data, you can combine as shown in the earlier modules", "_____no_output_____" ], [ "ci_train.head()", "_____no_output_____" ], [ "pd.crosstab(ci_train['education'],ci_train['education.num'])", "_____no_output_____" ], [ "ci_train.drop(['education'],axis=1,inplace=True)", "_____no_output_____" ], [ "ci_train['Y'].value_counts().index", "_____no_output_____" ], [ "ci_train['Y']=(ci_train['Y']==' >50K').astype(int)", "_____no_output_____" ], [ "cat_cols=ci_train.select_dtypes(['object']).columns", "_____no_output_____" ], [ "cat_cols", "_____no_output_____" ], [ "ci_train.shape", "_____no_output_____" ], [ "for col in cat_cols:\n freqs=ci_train[col].value_counts()\n k=freqs.index[freqs>500][:-1]\n for cat in k:\n name=col+'_'+cat\n ci_train[name]=(ci_train[col]==cat).astype(int)\n del ci_train[col]\n print(col)", "workclass\nmarital.status\noccupation\nrelationship\nrace\nsex\nnative.country\n" ], [ "ci_train.shape", "_____no_output_____" ], [ "ci_train.isnull().sum()", "_____no_output_____" ], [ "x_train=ci_train.drop(['Y'],1)\ny_train=ci_train['Y']", "_____no_output_____" ] ], [ [ "## Hyper Parameters For Decision Trees\n\n* criterion : there are two options available , \"entropy\" and \"gini\". These are the homogeneity measures that we discussed. By default \"gini\" is used \n\n* The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than min_samples_split samples. Ignored if ``max_leaf_nodes`` is not None. We'll finding optimal value for max_leaf_nodes [which is basically size of the tree] through cross validation.\n\n* min_sample_split : The minimum number of samples required to split an internal node. defaults to too, good idea is to keep it slightly higher in order to reduce overfitting of the data. recommended values is between 5 to 10\n\n* min_sample_leaf : The minimum number of samples required to be at a leaf node. This defaults to 1. If this number is higher and a split results in a leaf node having lesser number of samples than specified then that split is cancelled.\n\n* max_leaf_node : this parameter controlls size of the tree, we'll be finding optimal value of this through cross validation\n\n* class_weight : this default to None in which case each class is given equal weightage. If the goal of the problem is good classification instead of accuracy then you should set this to \"balanced\", in which case class weights are assigned inversely proportional to class frequencies in the input data.\n\n* random_state : this is used to reproduce random result\n", "_____no_output_____" ] ], [ [ "from sklearn.model_selection import RandomizedSearchCV", "_____no_output_____" ], [ "params={ 'class_weight':[None,'balanced'], \n 'criterion':['entropy','gini'],\n 'max_depth':[None,5,10,15,20,30,50,70],\n 'min_samples_leaf':[1,2,5,10,15,20], \n 'min_samples_split':[2,5,10,15,20]\n }", "_____no_output_____" ], [ "2*2*8*6*5", "_____no_output_____" ], [ "from sklearn.tree import DecisionTreeClassifier", "_____no_output_____" ], [ "clf=DecisionTreeClassifier()", "_____no_output_____" ], [ "random_search=RandomizedSearchCV(clf,cv=10,\n param_distributions=params,\n scoring='roc_auc',\n n_iter=10\n )", "_____no_output_____" ], [ "", "_____no_output_____" ], [ "x_train[\"capital.gain\"]=x_train[\"capital.gain\"].fillna(0)\nx_train[\"capital.loss\"]=x_train[\"capital.loss\"].fillna(0)\nx_train[\"hours.per.week\"]=x_train[\"hours.per.week\"].fillna(40)\nx_train.isna().sum()", "_____no_output_____" ], [ "random_search.fit(x_train,y_train)", "_____no_output_____" ] ], [ [ "Printing the tree model is a little tricky in python. We'll have to output our tree to a .dot file using graphviz package. From there using graphviz.Source function we can print our tree for display. Here is how :", "_____no_output_____" ] ], [ [ "random_search.best_estimator_", "_____no_output_____" ], [ "def report(results, n_top=3):\n for i in range(1, n_top + 1):\n candidates = np.flatnonzero(results['rank_test_score'] == i)\n for candidate in candidates:\n print(\"Model with rank: {0}\".format(i))\n print(\"Mean validation score: {0:.3f} (std: {1:.5f})\".format(\n results['mean_test_score'][candidate],\n results['std_test_score'][candidate]))\n print(\"Parameters: {0}\".format(results['params'][candidate]))\n print(\"\")", "_____no_output_____" ], [ "report(random_search.cv_results_,5)", "Model with rank: 1\nMean validation score: 0.888 (std: 0.00728)\nParameters: {'min_samples_split': 5, 'min_samples_leaf': 5, 'max_depth': 10, 'criterion': 'entropy', 'class_weight': 'balanced'}\n\nModel with rank: 2\nMean validation score: 0.885 (std: 0.00802)\nParameters: {'min_samples_split': 15, 'min_samples_leaf': 20, 'max_depth': 20, 'criterion': 'gini', 'class_weight': 'balanced'}\n\nModel with rank: 3\nMean validation score: 0.884 (std: 0.00820)\nParameters: {'min_samples_split': 5, 'min_samples_leaf': 20, 'max_depth': None, 'criterion': 'entropy', 'class_weight': None}\n\nModel with rank: 4\nMean validation score: 0.884 (std: 0.00818)\nParameters: {'min_samples_split': 10, 'min_samples_leaf': 20, 'max_depth': 50, 'criterion': 'entropy', 'class_weight': None}\n\nModel with rank: 5\nMean validation score: 0.879 (std: 0.00580)\nParameters: {'min_samples_split': 10, 'min_samples_leaf': 15, 'max_depth': 70, 'criterion': 'gini', 'class_weight': None}\n\n" ], [ "dtree=random_search.best_estimator_", "_____no_output_____" ], [ "dtree.fit(x_train,y_train)", "_____no_output_____" ], [ "import pickle\nfilename = 'census_income'\noutfile = open(filename,'wb')\npickle.dump(dtree,outfile)\noutfile.close()", "_____no_output_____" ], [ "filename = 'census_income'\ninfile = open(filename,'rb')\nnew_census_model = pickle.load(infile)\ninfile.close()", "_____no_output_____" ], [ "predict=new_census_model.predict(x_train)\nfrom sklearn.metrics import accuracy_score\naccuracy_score(predict,y_train)", "_____no_output_____" ], [ "dotfile = open(\"mytree.dot\", 'w')\n\ntree.export_graphviz(dtree,out_file=dotfile,\n feature_names=x_train.columns,\n class_names=[\"0\",\"1\"],\n proportion=True)\ndotfile.close()", "_____no_output_____" ] ], [ [ "Open mytree.dot file in a simple text editor and copy and paste the code here to visualise your tree : http://webgraphviz.com", "_____no_output_____" ], [ "## Additional Hyper paprameters for RandomForests\n\n* n_estimators : number of trees in the forest . defaults to 10. good starting point will be 100. Its one of the hyper parameters. We'll see how to search through mutidimensional hyper parameter space in order to find optimal combination through randomised grid search\n\n* max_features : Number of features being considered for rule selection at each split. Look at the documentation for defaults\n\n* bootstrap : boolean values, Whether bootstrap samples are used when building trees.\n", "_____no_output_____" ] ], [ [ "\nfrom sklearn.ensemble import RandomForestClassifier\n", "_____no_output_____" ], [ "clf = RandomForestClassifier()", "_____no_output_____" ], [ "# this here is the base classifier we are going to try\n# we will be supplying different parameter ranges to our randomSearchCV which in turn\n# will pass it on to this classifier\n\n# Utility function to report best scores. This simply accepts grid scores from \n# our randomSearchCV/GridSearchCV and picks and gives top few combination according to \n# their scores\n\n# RandomSearchCV/GridSearchCV accept parameters values as dictionaries.\n# In example given below we have constructed dictionary for \n#different parameter values that we want to\n# try for randomForest model\n\nparam_dist = {\"n_estimators\":[100,200,300,500,700,1000],\n \"max_features\": [5,10,20,25,30,35],\n \"bootstrap\": [True, False],\n 'class_weight':[None,'balanced'], \n 'criterion':['entropy','gini'],\n 'max_depth':[None,5,10,15,20,30,50,70],\n 'min_samples_leaf':[1,2,5,10,15,20], \n 'min_samples_split':[2,5,10,15,20]\n }\n\n", "_____no_output_____" ], [ "x_train.shape", "_____no_output_____" ], [ "960*6*6*2", "_____no_output_____" ], [ "# run randomized search\nn_iter_search = 10\n# n_iter parameter of RandomizedSeacrhCV controls, how many \n# parameter combination will be tried; out of all possible given values\n\nrandom_search = RandomizedSearchCV(clf, param_distributions=param_dist,\n n_iter=n_iter_search,scoring='roc_auc',cv=5)\nrandom_search.fit(x_train, y_train)", "_____no_output_____" ], [ "random_search.best_estimator_", "_____no_output_____" ] ], [ [ "RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n max_depth=50, max_features=10, max_leaf_nodes=None,\n min_impurity_split=1e-07, min_samples_leaf=10,\n min_samples_split=20, min_weight_fraction_leaf=0.0,\n n_estimators=300, n_jobs=1, oob_score=False, random_state=None,\n verbose=0, warm_start=False)\n \n**Note: This is a result from one of the runs, you can very well get different results from a different run. Your results need not match with this.**", "_____no_output_____" ] ], [ [ "report(random_search.cv_results_,5)", "_____no_output_____" ], [ "# select the best values from results above, they will vary slightly with each run\nrf=RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini', max_depth=50, \n max_features=10, max_leaf_nodes=None, min_impurity_split=1e-07, \n min_samples_leaf=10, min_samples_split=20, min_weight_fraction_leaf=0.0, \n n_estimators=300, n_jobs=1, oob_score=False, random_state=None, verbose=0, warm_start=False)", "_____no_output_____" ], [ "rf.fit(x_train,y_train)", "_____no_output_____" ] ], [ [ "## Feature Importance", "_____no_output_____" ] ], [ [ "feat_imp_df=pd.DataFrame({'features':x_train.columns,'importance':rf.feature_importances_})\n\nfeat_imp_df.sort_values('importance',ascending=False)", "_____no_output_____" ] ], [ [ "## Partial Dependence Plot\n\n", "_____no_output_____" ] ], [ [ "var_name='education.num'\n\npreds=rf.predict_proba(x_train)[:,1]\n# part_dep_data", "_____no_output_____" ], [ "var_data=pd.DataFrame({'var':x_train[var_name],'response':preds})", "_____no_output_____" ], [ "import seaborn as sns\n\nsns.lmplot(x='var',y='response',data=var_data,fit_reg=False)", "_____no_output_____" ], [ "import statsmodels.api as sm\nsmooth_data=sm.nonparametric.lowess(var_data['response'],var_data['var'])\n\n# smooth_data", "_____no_output_____" ], [ "df=pd.DataFrame({'response':smooth_data[:,1],var_name:smooth_data[:,0]})\n\nsns.lmplot(x=var_name,y='response',data=df,fit_reg=False)", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown", "markdown" ], [ "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ] ]

[ "Unlicense" ]

[ "Unlicense" ]

[ "Unlicense" ]

[ [ [ "#EDA Packages\nimport pandas as pd\nimport numpy as np", "_____no_output_____" ], [ "# ML Packages For Vectorization of Text For Feature Extraction\nfrom sklearn.feature_extraction.text import CountVectorizer\nfrom sklearn.feature_extraction.text import TfidfVectorizer", "_____no_output_____" ], [ "# Visualization Packages\nimport matplotlib.pyplot as plt\nimport seaborn as sns", "_____no_output_____" ], [ "# Dataset from https://archive.ics.uci.edu/ml/datasets/YouTube+Spam+Collection#\ndf1 = pd.read_csv(\"Youtube01-Psy.csv\")", "_____no_output_____" ], [ "df1.head()", "_____no_output_____" ], [ "# Load all our dataset to merge them\ndf2 = pd.read_csv(\"Youtube02-KatyPerry.csv\")\ndf3 = pd.read_csv(\"Youtube03-LMFAO.csv\")\ndf4 = pd.read_csv(\"Youtube04-Eminem.csv\")\ndf5 = pd.read_csv(\"Youtube05-Shakira.csv\")", "_____no_output_____" ], [ "frames = [df1,df2,df3,df4,df5]", "_____no_output_____" ], [ "# Merging or Concatenating our DF\ndf_merged = pd.concat(frames)", "_____no_output_____" ], [ "# Total Size\ndf_merged.shape", "_____no_output_____" ], [ "# Merging with Keys\nkeys = [\"Psy\",\"KatyPerry\",\"LMFAO\",\"Eminem\",\"Shakira\"]", "_____no_output_____" ], [ "df_with_keys = pd.concat(frames,keys=keys)", "_____no_output_____" ], [ "df_with_keys", "_____no_output_____" ], [ "# Checking for Only Comments on Shakira\ndf_with_keys.loc['Shakira']", "_____no_output_____" ], [ "# Save and Write Merged Data to csv\ndf_with_keys.to_csv(\"YoutubeSpamMergeddata.csv\")", "_____no_output_____" ], [ "df = df_with_keys", "_____no_output_____" ], [ "df.size", "_____no_output_____" ] ], [ [ "## Data Cleaning", "_____no_output_____" ] ], [ [ "# Checking for Consistent Column Name\ndf.columns", "_____no_output_____" ], [ "# Checking for Datatypes\ndf.dtypes", "_____no_output_____" ], [ "# Check for missing nan\ndf.isnull().isnull().sum()", "_____no_output_____" ], [ "# Checking for Date\ndf[\"DATE\"]", "_____no_output_____" ], [ "df.AUTHOR\n# Convert the Author Name to First Name and Last Name\n#df[[\"FIRSTNAME\",\"LASTNAME\"]] = df['AUTHOR'].str.split(expand=True)", "_____no_output_____" ] ], [ [ "## Working With Text Content", "_____no_output_____" ] ], [ [ "df_data = df[[\"CONTENT\",\"CLASS\"]]", "_____no_output_____" ], [ "df_data.columns", "_____no_output_____" ], [ "df_x = df_data['CONTENT']\ndf_y = df_data['CLASS']", "_____no_output_____" ] ], [ [ "## Feature Extraction From Text\n## CountVectorizer\n## TfidfVectorizer", "_____no_output_____" ] ], [ [ "cv = CountVectorizer()\nex = cv.fit_transform([\"Great song but check this out\",\"What is this song?\"])", "_____no_output_____" ], [ "ex.toarray()", "_____no_output_____" ], [ "cv.get_feature_names()", "_____no_output_____" ], [ "# Extract Feature With CountVectorizer\ncorpus = df_x\ncv = CountVectorizer()\nX = cv.fit_transform(corpus) # Fit the Data", "_____no_output_____" ], [ "X.toarray()", "_____no_output_____" ], [ "# get the feature names\ncv.get_feature_names()", "_____no_output_____" ] ], [ [ "## Model Building", "_____no_output_____" ] ], [ [ "from sklearn.model_selection import train_test_split", "_____no_output_____" ], [ "X_train, X_test, y_train, y_test = train_test_split(X, df_y, test_size=0.33, random_state=42)", "_____no_output_____" ], [ "X_train", "_____no_output_____" ], [ "# Naive Bayes Classifier\nfrom sklearn.naive_bayes import MultinomialNB\nclf = MultinomialNB()\nclf.fit(X_train,y_train)\nclf.score(X_test,y_test)", "_____no_output_____" ], [ "# Accuracy of our Model\nprint(\"Accuracy of Model\",clf.score(X_test,y_test)*100,\"%\")", "Accuracy of Model 91.95046439628483 %\n" ], [ "## Predicting with our model\nclf.predict(X_test)", "_____no_output_____" ], [ "# Sample Prediciton\ncomment = [\"Check this out\"]\nvect = cv.transform(comment).toarray()", "_____no_output_____" ], [ "clf.predict(vect)", "_____no_output_____" ], [ "class_dict = {'ham':0,'spam':1}", "_____no_output_____" ], [ "class_dict.values()", "_____no_output_____" ], [ "if clf.predict(vect) == 1:\n print(\"Spam\")\nelse:\n print(\"Ham\")", "Spam\n" ], [ "# Sample Prediciton 2\ncomment1 = [\"Great song Friend\"]\nvect = cv.transform(comment1).toarray()\nclf.predict(vect)", "_____no_output_____" ] ], [ [ "## Save The Model", "_____no_output_____" ] ], [ [ "import pickle", "_____no_output_____" ], [ "naivebayesML = open(\"YtbSpam_model.pkl\",\"wb\")", "_____no_output_____" ], [ "pickle.dump(clf,naivebayesML)", "_____no_output_____" ], [ "naivebayesML.close()", "_____no_output_____" ], [ "# Load the model", "_____no_output_____" ], [ "ytb_model = open(\"YtbSpam_model.pkl\",\"rb\")", "_____no_output_____" ], [ "new_model = pickle.load(ytb_model)", "_____no_output_____" ], [ "new_model", "_____no_output_____" ], [ "# Sample Prediciton 3\ncomment2 = [\"Hey Music Fans I really appreciate all of you,but see this song too\"]\nvect = cv.transform(comment2).toarray()\nnew_model.predict(vect)", "_____no_output_____" ], [ "if new_model.predict(vect) == 1:\n print(\"Spam\")\nelse:\n print(\"Ham\")", "Spam\n" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Self-Driving Car Engineer Nanodegree\n\n\n## Project: **Finding Lane Lines on the Road** \n***\nIn this project, you will use the tools you learned about in the lesson to identify lane lines on the road. You can develop your pipeline on a series of individual images, and later apply the result to a video stream (really just a series of images). Check out the video clip \"raw-lines-example.mp4\" (also contained in this repository) to see what the output should look like after using the helper functions below. \n\nOnce you have a result that looks roughly like \"raw-lines-example.mp4\", you'll need to get creative and try to average and/or extrapolate the line segments you've detected to map out the full extent of the lane lines. You can see an example of the result you're going for in the video \"P1_example.mp4\". Ultimately, you would like to draw just one line for the left side of the lane, and one for the right.\n\nIn addition to implementing code, there is a brief writeup to complete. The writeup should be completed in a separate file, which can be either a markdown file or a pdf document. There is a [write up template](https://github.com/udacity/CarND-LaneLines-P1/blob/master/writeup_template.md) that can be used to guide the writing process. Completing both the code in the Ipython notebook and the writeup template will cover all of the [rubric points](https://review.udacity.com/#!/rubrics/322/view) for this project.\n\n---\nLet's have a look at our first image called 'test_images/solidWhiteRight.jpg'. Run the 2 cells below (hit Shift-Enter or the \"play\" button above) to display the image.\n\n**Note: If, at any point, you encounter frozen display windows or other confounding issues, you can always start again with a clean slate by going to the \"Kernel\" menu above and selecting \"Restart & Clear Output\".**\n\n---", "_____no_output_____" ], [ "**The tools you have are color selection, region of interest selection, grayscaling, Gaussian smoothing, Canny Edge Detection and Hough Tranform line detection. You are also free to explore and try other techniques that were not presented in the lesson. Your goal is piece together a pipeline to detect the line segments in the image, then average/extrapolate them and draw them onto the image for display (as below). Once you have a working pipeline, try it out on the video stream below.**\n\n---\n\n<figure>\n <img src=\"examples/line-segments-example.jpg\" width=\"380\" alt=\"Combined Image\" />\n <figcaption>\n <p></p> \n <p style=\"text-align: center;\"> Your output should look something like this (above) after detecting line segments using the helper functions below </p> \n </figcaption>\n</figure>\n <p></p> \n<figure>\n <img src=\"examples/laneLines_thirdPass.jpg\" width=\"380\" alt=\"Combined Image\" />\n <figcaption>\n <p></p> \n <p style=\"text-align: center;\"> Your goal is to connect/average/extrapolate line segments to get output like this</p> \n </figcaption>\n</figure>", "_____no_output_____" ], [ "**Run the cell below to import some packages. If you get an `import error` for a package you've already installed, try changing your kernel (select the Kernel menu above --> Change Kernel). Still have problems? Try relaunching Jupyter Notebook from the terminal prompt. Also, consult the forums for more troubleshooting tips.** ", "_____no_output_____" ], [ "## Import Packages", "_____no_output_____" ] ], [ [ "#importing some useful packages\nimport matplotlib.pyplot as plt\nimport matplotlib.image as mpimg\nimport numpy as np\nimport cv2\n%matplotlib inline", "_____no_output_____" ] ], [ [ "## Read in an Image", "_____no_output_____" ] ], [ [ "#reading in an image\nimage = mpimg.imread('test_images/solidWhiteRight.jpg')\n\n#printing out some stats and plotting\nprint('This image is:', type(image), 'with dimensions:', image.shape)\nplt.imshow(image) # if you wanted to show a single color channel image called 'gray', for example, call as plt.imshow(gray, cmap='gray')", "This image is: <class 'numpy.ndarray'> with dimensions: (540, 960, 3)\n" ] ], [ [ "## Ideas for Lane Detection Pipeline", "_____no_output_____" ], [ "**Some OpenCV functions (beyond those introduced in the lesson) that might be useful for this project are:**\n\n`cv2.inRange()` for color selection \n`cv2.fillPoly()` for regions selection \n`cv2.line()` to draw lines on an image given endpoints \n`cv2.addWeighted()` to coadd / overlay two images \n`cv2.cvtColor()` to grayscale or change color \n`cv2.imwrite()` to output images to file \n`cv2.bitwise_and()` to apply a mask to an image\n\n**Check out the OpenCV documentation to learn about these and discover even more awesome functionality!**", "_____no_output_____" ], [ "## Helper Functions", "_____no_output_____" ], [ "Below are some helper functions to help get you started. They should look familiar from the lesson!", "_____no_output_____" ] ], [ [ "import math\n\ndef grayscale(img):\n \"\"\"Applies the Grayscale transform\n This will return an image with only one color channel\n but NOTE: to see the returned image as grayscale\n (assuming your grayscaled image is called 'gray')\n you should call plt.imshow(gray, cmap='gray')\"\"\"\n return cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)\n # Or use BGR2GRAY if you read an image with cv2.imread()\n # return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n \ndef canny(img, low_threshold, high_threshold):\n \"\"\"Applies the Canny transform\"\"\"\n return cv2.Canny(img, low_threshold, high_threshold)\n\ndef gaussian_blur(img, kernel_size):\n \"\"\"Applies a Gaussian Noise kernel\"\"\"\n return cv2.GaussianBlur(img, (kernel_size, kernel_size), 0)\n\ndef region_of_interest(img, vertices):\n \"\"\"\n Applies an image mask.\n \n Only keeps the region of the image defined by the polygon\n formed from `vertices`. The rest of the image is set to black.\n `vertices` should be a numpy array of integer points.\n \"\"\"\n #defining a blank mask to start with\n mask = np.zeros_like(img) \n \n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n \n #filling pixels inside the polygon defined by \"vertices\" with the fill color \n cv2.fillPoly(mask, vertices, ignore_mask_color)\n \n #returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image\n\ndef draw_lines(img, lines, color=[255, 0, 0], thickness=8):\n\n #create variables to hold the x, y and slopes for all the lines, \n left_x=[]\n left_y=[]\n left_slopes=[]\n right_x=[]\n right_y=[]\n right_slopes=[]\n right_limits=[5,0.5]\n left_limits=[-5,-0.5]\n \n #variables to lane points\n left_lane=[0,0,0,0]#x1,y1,x2,y2\n right_lane=[0,0,0,0]\n #get image size to use the left and right corners for starting the line\n imshape = img.shape\n y_size = img.shape[0]\n\n #loop over all the lines to extract the ones in interest ( filter out the ones that are not expected)\n for line in lines:\n for x1,y1,x2,y2 in line:\n [slope, intercept] = np.polyfit((x1,x2), (y1,y2), 1)\n #filter only on the slopes that make sense to a lane\n if((slope<left_limits[1]) and (slope>left_limits[0])): # if line slope < 0 then it belongs to left lane (y=mx+b)\n left_x+=[x1,x2]\n left_y+=[y1,y2]\n left_slopes+=[slope]\n \n elif((slope<right_limits[0]) and (slope>right_limits[1])): # if line slope > 0 then it belongs to right lane (y=mx+b) where m is - \n right_x+=[x1,x2]\n right_y+=[y1,y2]\n right_slopes+=[slope]\n\n \n #average each line points to get the line equation which best describes the lane\n left_x_mean= np.mean(left_x)\n left_y_mean= np.mean(left_y)\n left_slope_mean=np.mean(left_slopes)\n left_intercept_mean =left_y_mean - (left_slope_mean * left_x_mean)\n \n right_x_mean= np.mean(right_x)\n right_y_mean= np.mean(right_y)\n right_slope_mean=np.mean(right_slopes)\n right_intercept_mean =right_y_mean - (right_slope_mean * right_x_mean)\n\n\n #get start and end of each line to draw the left lane and right lane using the equations above\n #only process incase size is > 0 (to fix challenge error )\n if((np.size(left_y))>0) :\n left_lane[0]=int((np.min(left_y)-left_intercept_mean)/left_slope_mean)# x=(y-b)/m\n left_lane[2]=int((y_size-left_intercept_mean)/left_slope_mean)#\n left_lane[1]=int(np.min(left_y))\n left_lane[3]=y_size\n #got errors seems that function only takes int \n cv2.line(img, (left_lane[0],left_lane[1] ), (left_lane[2],left_lane[3]), color, thickness)\n if((np.size(right_y))>0):\n right_lane[0]=int((np.min(right_y)-right_intercept_mean)/right_slope_mean)# x=(y-b)/m\n right_lane[2]=int((y_size-right_intercept_mean)/right_slope_mean)#\n right_lane[1]=int(np.min(right_y))\n right_lane[3]=y_size\n #got errors seems that function only takes int \n cv2.line(img, (right_lane[0],right_lane[1]), (right_lane[2],right_lane[3]), color, thickness)\n \n\n \ndef hough_lines(img, rho, theta, threshold, min_line_len, max_line_gap):\n \"\"\"\n `img` should be the output of a Canny transform.\n \n Returns an image with hough lines drawn.\n \"\"\"\n lines = cv2.HoughLinesP(img, rho, theta, threshold, np.array([]), minLineLength=min_line_len, maxLineGap=max_line_gap)\n line_img = np.zeros((img.shape[0], img.shape[1], 3), dtype=np.uint8)\n draw_lines(line_img, lines)\n return line_img\n\n# Python 3 has support for cool math symbols.\n\ndef weighted_img(img, initial_img, α=0.8, β=1., γ=0.):\n \"\"\"\n `img` is the output of the hough_lines(), An image with lines drawn on it.\n Should be a blank image (all black) with lines drawn on it.\n \n `initial_img` should be the image before any processing.\n \n The result image is computed as follows:\n \n initial_img * α + img * β + γ\n NOTE: initial_img and img must be the same shape!\n \"\"\"\n return cv2.addWeighted(initial_img, α, img, β, γ)\n\ndef convert_hls(image):\n return cv2.cvtColor(image, cv2.COLOR_RGB2HLS)\n\ndef select_color(image ):\n \n # find colors that are in provided range and highlight it in red\n \n white_lo= np.array([100,100,200])\n white_hi= np.array([255,255,255])\n \n yellow_lo_RGB= np.array([225,180,0])\n yellow_hi_RGB= np.array([255,255,170]) \n \n yellow_lo_HLS= np.array([20,120,80])\n yellow_hi_HLS= np.array([45,200,255]) \n\n rgb_image = np.copy(image)\n hls_image = convert_hls(image)\n \n #plt.figure()\n #plt.imshow(rgb_image)\n \n #plt.figure()\n #plt.imshow(hls_image)\n \n mask_1=cv2.inRange(rgb_image,white_lo,white_hi) #filter on rgb white\n mask_2=cv2.inRange(hls_image,yellow_lo_RGB,yellow_hi_RGB) #filter on rgb yellow \n mask_3=cv2.inRange(hls_image,yellow_lo_HLS,yellow_hi_HLS) #filter on hls yellow \n \n mask = mask_1+mask_2+mask_3\n \n #plt.figure()\n #plt.imshow(mask)\n \n result = cv2.bitwise_and(image,image, mask= mask)\n #plt.figure()\n #plt.imshow(result)\n \n \n return result\n", "_____no_output_____" ] ], [ [ "## Test Images\n\nBuild your pipeline to work on the images in the directory \"test_images\" \n**You should make sure your pipeline works well on these images before you try the videos.**", "_____no_output_____" ] ], [ [ "import os\nos.listdir(\"test_images/\")", "_____no_output_____" ] ], [ [ "## Build a Lane Finding Pipeline\n\n", "_____no_output_____" ], [ "Build the pipeline and run your solution on all test_images. Make copies into the `test_images_output` directory, and you can use the images in your writeup report.\n\nTry tuning the various parameters, especially the low and high Canny thresholds as well as the Hough lines parameters.", "_____no_output_____" ] ], [ [ "# TODO: Build your pipeline that will draw lane lines on the test_images\n# then save them to the test_images_output directory.\n#output all processed images for documentation\nimages=os.listdir(\"test_images/\")\n\nfor filename in images: \n #first read image and change to gray scale \n image = mpimg.imread(\"test_images/\"+filename)\n \n #color select for lane to improve performance but didn't work \n #highlight white and yellow colors for better late detection\n highlighted_color=select_color(image)\n\n \n #change to gray scale\n image_gray = cv2.cvtColor(highlighted_color,cv2.COLOR_RGB2GRAY)\n cv2.imwrite(\"test_images_output/\"+filename[:-4]+\"_gray.jpg\",image_gray)\n\n #Apply guassian filter \n image_blur_gray= gaussian_blur(image_gray, 5)\n cv2.imwrite(\"test_images_output/\"+filename[:-4]+\"_blur.jpg\",image_blur_gray)\n\n # Using canny edges ( used threshoulds achieved from the exercise )\n image_edge = canny(image_blur_gray, 100, 200)\n cv2.imwrite(\"test_images_output/\"+filename[:-4]+\"_edge.jpg\",image_edge)\n\n # Add filter region (added vehicle hood area)\n imshape = image.shape\n vertices = np.array([[(200,imshape[0]-50),(420, 330), (580, 330), (imshape[1]-200,imshape[0]-50)]], dtype=np.int32)\n image_masked_edges = region_of_interest(image_edge,vertices)\n cv2.imwrite(\"test_images_output/\"+filename[:-4]+\"_masked_edge.jpg\",image_masked_edges)\n\n\n # Define the Hough transform parameters\n # Make a blank the same size as our image to draw on\n rho = 1 # distance resolution in pixels of the Hough grid\n theta = np.pi/180 # angular resolution in radians of the Hough grid\n threshold = 40 # minimum number of votes (intersections in Hough grid cell)\n min_line_length = 20 #minimum number of pixels making up a line\n max_line_gap = 100 # maximum gap in pixels between connectable line \n\n image_hough_lines = hough_lines(image_masked_edges, rho, theta, threshold, min_line_length, max_line_gap)\n image_hough_lines = cv2.cvtColor(image_hough_lines, cv2.COLOR_RGB2BGR)\n cv2.imwrite(\"test_images_output/\"+filename[:-4]+\"_Hough.jpg\",image_hough_lines)\n \n #create image with overlay lines\n overlayed_image = weighted_img(image_hough_lines,image)\n cv2.imwrite(\"test_images_output/\"+filename[:-4]+\"_Final_overlay.jpg\",overlayed_image)\n ", "C:\\Users\\Redaaaaaa\\Anaconda3\\lib\\site-packages\\numpy\\core\\fromnumeric.py:3373: RuntimeWarning: Mean of empty slice.\n out=out, **kwargs)\nC:\\Users\\Redaaaaaa\\Anaconda3\\lib\\site-packages\\numpy\\core\\_methods.py:170: RuntimeWarning: invalid value encountered in double_scalars\n ret = ret.dtype.type(ret / rcount)\n" ] ], [ [ "## Test on Videos\n\nYou know what's cooler than drawing lanes over images? Drawing lanes over video!\n\nWe can test our solution on two provided videos:\n\n`solidWhiteRight.mp4`\n\n`solidYellowLeft.mp4`\n\n**Note: if you get an import error when you run the next cell, try changing your kernel (select the Kernel menu above --> Change Kernel). Still have problems? Try relaunching Jupyter Notebook from the terminal prompt. Also, consult the forums for more troubleshooting tips.**\n\n**If you get an error that looks like this:**\n```\nNeedDownloadError: Need ffmpeg exe. \nYou can download it by calling: \nimageio.plugins.ffmpeg.download()\n```\n**Follow the instructions in the error message and check out [this forum post](https://discussions.udacity.com/t/project-error-of-test-on-videos/274082) for more troubleshooting tips across operating systems.**", "_____no_output_____" ] ], [ [ "# Import everything needed to edit/save/watch video clips\nfrom moviepy.editor import VideoFileClip\nfrom IPython.display import HTML", "_____no_output_____" ], [ "def process_image(image):\n # NOTE: The output you return should be a color image (3 channel) for processing video below\n # TODO: put your pipeline here,\n #color select for lane to improve performance but didn't work \n #highlight white and yellow colors for better late detection\n highlighted_color=select_color(image)\n\n #Change image to Gray\n image_gray = cv2.cvtColor(highlighted_color,cv2.COLOR_RGB2GRAY)\n\n #Apply guassian filter \n image_blur_gray= gaussian_blur(image_gray, 5)\n\n # Using canny edges ( used threshoulds achieved from the exercise )\n image_edge = canny(image_blur_gray, 100, 200)\n\n # Add filter region \n imshape = image.shape\n vertices = np.array([[(200,imshape[0]-50),(420, 330), (580, 330), (imshape[1]-200,imshape[0]-50)]], dtype=np.int32)\n image_masked_edges = region_of_interest(image_edge,vertices)\n\n\n # Define the Hough transform parameters\n # Make a blank the same size as our image to draw on\n rho = 1 # distance resolution in pixels of the Hough grid\n theta = np.pi/180 # angular resolution in radians of the Hough grid\n threshold = 40 # minimum number of votes (intersections in Hough grid cell)\n min_line_length = 20 #minimum number of pixels making up a line\n max_line_gap = 100 # maximum gap in pixels between connectable line \n\n image_hough_lines = hough_lines(image_masked_edges, rho, theta, threshold, min_line_length, max_line_gap)\n \n #create image with overlay lines\n overlayed_image = weighted_img(image_hough_lines,image)\n \n # you should return the final output (image where lines are drawn on lanes)\n\n return overlayed_image\n\n", "_____no_output_____" ] ], [ [ "Let's try the one with the solid white lane on the right first ...", "_____no_output_____" ] ], [ [ "white_output = 'test_videos_output/solidWhiteRight.mp4'\n## To speed up the testing process you may want to try your pipeline on a shorter subclip of the video\n## To do so add .subclip(start_second,end_second) to the end of the line below\n## Where start_second and end_second are integer values representing the start and end of the subclip\n## You may also uncomment the following line for a subclip of the first 5 seconds\n##clip1 = VideoFileClip(\"test_videos/solidWhiteRight.mp4\").subclip(0,5)\nclip1 = VideoFileClip(\"test_videos/solidWhiteRight.mp4\")\nwhite_clip = clip1.fl_image(process_image) #NOTE: this function expects color images!!\n%time white_clip.write_videofile(white_output, audio=False)", "\rt: 0%| | 0/221 [00:00<?, ?it/s, now=None]" ] ], [ [ "Play the video inline, or if you prefer find the video in your filesystem (should be in the same directory) and play it in your video player of choice.", "_____no_output_____" ] ], [ [ "HTML(\"\"\"\n<video width=\"960\" height=\"540\" controls>\n <source src=\"{0}\">\n</video>\n\"\"\".format(white_output))", "_____no_output_____" ] ], [ [ "## Improve the draw_lines() function\n\n**At this point, if you were successful with making the pipeline and tuning parameters, you probably have the Hough line segments drawn onto the road, but what about identifying the full extent of the lane and marking it clearly as in the example video (P1_example.mp4)? Think about defining a line to run the full length of the visible lane based on the line segments you identified with the Hough Transform. As mentioned previously, try to average and/or extrapolate the line segments you've detected to map out the full extent of the lane lines. You can see an example of the result you're going for in the video \"P1_example.mp4\".**\n\n**Go back and modify your draw_lines function accordingly and try re-running your pipeline. The new output should draw a single, solid line over the left lane line and a single, solid line over the right lane line. The lines should start from the bottom of the image and extend out to the top of the region of interest.**", "_____no_output_____" ], [ "Now for the one with the solid yellow lane on the left. This one's more tricky!", "_____no_output_____" ] ], [ [ "yellow_output = 'test_videos_output/solidYellowLeft.mp4'\n## To speed up the testing process you may want to try your pipeline on a shorter subclip of the video\n## To do so add .subclip(start_second,end_second) to the end of the line below\n## Where start_second and end_second are integer values representing the start and end of the subclip\n## You may also uncomment the following line for a subclip of the first 5 seconds\n##clip2 = VideoFileClip('test_videos/solidYellowLeft.mp4').subclip(0,5)\nclip2 = VideoFileClip('test_videos/solidYellowLeft.mp4')\nyellow_clip = clip2.fl_image(process_image)\n%time yellow_clip.write_videofile(yellow_output, audio=False)", "t: 0%| | 2/681 [00:00<01:00, 11.14it/s, now=None]" ], [ "HTML(\"\"\"\n<video width=\"960\" height=\"540\" controls>\n <source src=\"{0}\">\n</video>\n\"\"\".format(yellow_output))", "_____no_output_____" ] ], [ [ "## Writeup and Submission\n\nIf you're satisfied with your video outputs, it's time to make the report writeup in a pdf or markdown file. Once you have this Ipython notebook ready along with the writeup, it's time to submit for review! Here is a [link](https://github.com/udacity/CarND-LaneLines-P1/blob/master/writeup_template.md) to the writeup template file.\n", "_____no_output_____" ], [ "## Optional Challenge\n\nTry your lane finding pipeline on the video below. Does it still work? Can you figure out a way to make it more robust? If you're up for the challenge, modify your pipeline so it works with this video and submit it along with the rest of your project!", "_____no_output_____" ] ], [ [ "challenge_output = 'test_videos_output/challenge.mp4'\n## To speed up the testing process you may want to try your pipeline on a shorter subclip of the video\n## To do so add .subclip(start_second,end_second) to the end of the line below\n## Where start_second and end_second are integer values representing the start and end of the subclip\n## You may also uncomment the following line for a subclip of the first 5 seconds\n##clip3 = VideoFileClip('test_videos/challenge.mp4').subclip(0,5)\nclip3 = VideoFileClip('test_videos/challenge.mp4')\nchallenge_clip = clip3.fl_image(process_image)\n%time challenge_clip.write_videofile(challenge_output, audio=False)", "\rt: 0%| | 0/251 [00:00<?, ?it/s, now=None]" ], [ "HTML(\"\"\"\n<video width=\"960\" height=\"540\" controls>\n <source src=\"{0}\">\n</video>\n\"\"\".format(challenge_output))", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "<a href=\"https://colab.research.google.com/github/bkrant/DS-Unit-1-Sprint-1-Dealing-With-Data/blob/master/Boris_Krant_DS_Unit_1_Sprint_Challenge_1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>", "_____no_output_____" ], [ "# Data Science Unit 1 Sprint Challenge 1\n\n## Loading, cleaning, visualizing, and analyzing data\n\nIn this sprint challenge you will look at a dataset of the survival of patients who underwent surgery for breast cancer.\n\nhttp://archive.ics.uci.edu/ml/datasets/Haberman%27s+Survival\n\nData Set Information:\nThe dataset contains cases from a study that was conducted between 1958 and 1970 at the University of Chicago's Billings Hospital on the survival of patients who had undergone surgery for breast cancer.\n\nAttribute Information:\n1. Age of patient at time of operation (numerical)\n2. Patient's year of operation (year - 1900, numerical)\n3. Number of positive axillary nodes detected (numerical)\n4. Survival status (class attribute)\n-- 1 = the patient survived 5 years or longer\n-- 2 = the patient died within 5 year\n\nSprint challenges are evaluated based on satisfactory completion of each part. It is suggested you work through it in order, getting each aspect reasonably working, before trying to deeply explore, iterate, or refine any given step. Once you get to the end, if you want to go back and improve things, go for it!", "_____no_output_____" ], [ "## Part 1 - Load and validate the data\n\n- Load the data as a `pandas` data frame.\n- Validate that it has the appropriate number of observations (you can check the raw file, and also read the dataset description from UCI).\n- Validate that you have no missing values.\n- Add informative names to the features.\n- The survival variable is encoded as 1 for surviving >5 years and 2 for not - change this to be 0 for not surviving and 1 for surviving >5 years (0/1 is a more traditional encoding of binary variables)\n\nAt the end, print the first five rows of the dataset to demonstrate the above.", "_____no_output_____" ] ], [ [ "import pandas as pd", "_____no_output_____" ], [ "breast = pd.read_csv('http://archive.ics.uci.edu/ml/machine-learning-databases/haberman/haberman.data',names=['age','year_operation','nodes','survived'])\nprint(breast.shape)\nprint(breast.isna().sum())", "(306, 4)\nage 0\nyear_operation 0\nnodes 0\nsurvived 0\ndtype: int64\n" ], [ "labels = {'survived': {2:0}}\nbreast.replace(labels, inplace=True)\nbreast.survived.value_counts()", "_____no_output_____" ], [ "print(breast.head())", " age year_operation nodes survived\n0 30 64 1 1\n1 30 62 3 1\n2 30 65 0 1\n3 31 59 2 1\n4 31 65 4 1\n" ] ], [ [ "## Part 2 - Examine the distribution and relationships of the features\n\nExplore the data - create at least *2* tables (can be summary statistics or crosstabulations) and *2* plots illustrating the nature of the data.\n\nThis is open-ended, so to remind - first *complete* this task as a baseline, then go on to the remaining sections, and *then* as time allows revisit and explore further.\n\nHint - you may need to bin some variables depending on your chosen tables/plots.", "_____no_output_____" ] ], [ [ "print(breast.corr())\nprint(breast.describe())", " age year_operation nodes survived\nage 1.000000 0.089529 -0.063176 -0.067950\nyear_operation 0.089529 1.000000 -0.003764 0.004768\nnodes -0.063176 -0.003764 1.000000 -0.286768\nsurvived -0.067950 0.004768 -0.286768 1.000000\n age year_operation nodes survived\ncount 306.000000 306.000000 306.000000 306.000000\nmean 52.457516 62.852941 4.026144 0.735294\nstd 10.803452 3.249405 7.189654 0.441899\nmin 30.000000 58.000000 0.000000 0.000000\n25% 44.000000 60.000000 0.000000 0.000000\n50% 52.000000 63.000000 1.000000 1.000000\n75% 60.750000 65.750000 4.000000 1.000000\nmax 83.000000 69.000000 52.000000 1.000000\n" ], [ "sns.heatmap(breast.corr());", "_____no_output_____" ], [ "import seaborn as sns\nimport matplotlib.pyplot as plt\nimport numpy as np\nsns.pairplot(breast);", "_____no_output_____" ], [ "g = sns.FacetGrid(breast, row=\"survived\", margin_titles=True)\nbins = np.linspace(0, breast.age.max())\ng.map(plt.hist, \"age\", color=\"steelblue\", bins=bins);", "_____no_output_____" ], [ "breast.boxplot();", "_____no_output_____" ] ], [ [ "## Part 3 - Analysis and Interpretation\n\nNow that you've looked at the data, answer the following questions:\n\n- What is at least one feature that looks to have a positive relationship with survival?\n- What is at least one feature that looks to have a negative relationship with survival?\n- How are those two features related with each other, and what might that mean?\n\nAnswer with text, but feel free to intersperse example code/results or refer to it from earlier.", "_____no_output_____" ], [ "According to the correlation matrix 'nodes' has a positive correlation of 0.287 with survival. 'years_operation' has a weak negative correlation with survival of -0.004768; probably statistically insignificant. 'nodes' and 'years_operation' have a correlation of -0.003764. This means there's no linear relationship between them - which is not the same as being independent because there might be a non-linear relationship. Have to look at scatter plot before drawing conclusions.", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown", "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ], [ "markdown", "markdown" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# HVAC with Amazon SageMaker RL\n\n---\n## Introduction\n\n\nHVAC stands for Heating, Ventilation and Air Conditioning and is responsible for keeping us warm and comfortable indoors. HVAC takes up a whopping 50% of the energy in a building and accounts for 40% of energy use in the US [1, 2]. Several control system optimizations have been proposed to reduce energy usage while ensuring thermal comfort.\n\nModern buildings collect data about the weather, occupancy and equipment use. All of this can be used to optimize HVAC energy usage. Reinforcement Learning (RL) is a good fit because it can learn how to interact with the environment and identify strategies to limit wasted energy. Several recent research efforts have shown that RL can reduce HVAC energy consumption by 15-20% [3, 4].\n\nAs training an RL algorithm in a real HVAC system can take time to converge as well as potentially lead to hazardous settings as the agent explores its state space, we turn to a simulator to train the agent. [EnergyPlus](https://energyplus.net/) is an open source, state of the art HVAC simulator from the US Department of Energy. We use a simple example with this simulator to showcase how we can train an RL model easily with Amazon SageMaker RL.\n\n<br>\n\n<img width=\"85%\" src=\"images/datacenter_env.png\" />\n\n<br>\n\n1. Objective: Control the data center HVAC system to reduce energy consumption while ensuring the room temperature stays within specified limits.\n2. Environment: We have a small single room datacenter that the HVAC system is cooling to ensure the compute equipment works properly. We will train our RL agent to control this HVAC system for one day subject to weather conditions in San Francisco. The agent takes actions every 5 minutes for a 24 hour period. Hence, the episode is a fixed 120 steps. \n3. State: The outdoor temperature, outdoor humidity and indoor room temperature.\n4. Action: The agent can set the heating and cooling setpoints. The cooling setpoint tells the HVAC system that it should start cooling the room if the room temperature goes above this setpoint. Likewise, the HVAC systems starts heating if the room temperature goes below the heating setpoint.\n5. Reward: The rewards has two components which are added together with coefficients: \n 1. It is proportional to the energy consumed by the HVAC system.\n 2. It gets a large penalty when the room temperature exceeds pre-specified lower or upper limits (as defined in `data_center_env.py`).\n\nReferences\n\n1. [sciencedirect.com](https://www.sciencedirect.com/science/article/pii/S0378778807001016)\n2. [environment.gov.au](https://www.environment.gov.au/system/files/energy/files/hvac-factsheet-energy-breakdown.pdf)\n3. Wei, Tianshu, Yanzhi Wang, and Qi Zhu. \"Deep reinforcement learning for building hvac control.\" In Proceedings of the 54th Annual Design Automation Conference 2017, p. 22. ACM, 2017.\n4. Zhang, Zhiang, and Khee Poh Lam. \"Practical implementation and evaluation of deep reinforcement learning control for a radiant heating system.\" In Proceedings of the 5th Conference on Systems for Built Environments, pp. 148-157. ACM, 2018.", "_____no_output_____" ], [ "## Pre-requisites \n\n### Imports\n\nTo get started, we'll import the Python libraries we need, set up the environment with a few prerequisites for permissions and configurations.", "_____no_output_____" ] ], [ [ "import sagemaker\nimport boto3\nimport sys\nimport os\nimport glob\nimport re\nimport subprocess\nimport numpy as np\nfrom IPython.display import HTML\nimport time\nfrom time import gmtime, strftime\nsys.path.append(\"common\")\nfrom misc import get_execution_role, wait_for_s3_object\nfrom docker_utils import build_and_push_docker_image\nfrom sagemaker.rl import RLEstimator, RLToolkit, RLFramework", "_____no_output_____" ] ], [ [ "### Setup S3 bucket\n\nCreate a reference to the default S3 bucket that will be used for model outputs.", "_____no_output_____" ] ], [ [ "sage_session = sagemaker.session.Session()\ns3_bucket = sage_session.default_bucket() \ns3_output_path = 's3://{}/'.format(s3_bucket)\nprint(\"S3 bucket path: {}\".format(s3_output_path))", "_____no_output_____" ] ], [ [ "### Define Variables \n\nWe define a job below that's used to identify our jobs.", "_____no_output_____" ] ], [ [ "# create unique job name \njob_name_prefix = 'rl-hvac'", "_____no_output_____" ] ], [ [ "### Configure settings\n\nYou can run your RL training jobs locally on the SageMaker notebook instance or on SageMaker training. In both of these scenarios, you can run in either 'local' (where you run the commands) or 'SageMaker' mode (on SageMaker training instances). 'local' mode uses the SageMaker Python SDK to run your code in Docker containers locally. It can speed up iterative testing and debugging while using the same familiar Python SDK interface. Just set `local_mode = True`. And when you're ready move to 'SageMaker' mode to scale things up.", "_____no_output_____" ] ], [ [ "# run local (on this machine)?\n# or on sagemaker training instances?\nlocal_mode = False\n\nif local_mode:\n instance_type = 'local'\nelse:\n # choose a larger instance to avoid running out of memory\n instance_type = \"ml.m4.4xlarge\"", "_____no_output_____" ] ], [ [ "### Create an IAM role\n\nEither get the execution role when running from a SageMaker notebook instance `role = sagemaker.get_execution_role()` or, when running from local notebook instance, use utils method `role = get_execution_role()` to create an execution role.", "_____no_output_____" ] ], [ [ "try:\n role = sagemaker.get_execution_role()\nexcept:\n role = get_execution_role()\n\nprint(\"Using IAM role arn: {}\".format(role))", "_____no_output_____" ] ], [ [ "### Install docker for `local` mode\n\nIn order to work in `local` mode, you need to have docker installed. When running from your local machine, please make sure that you have docker or docker-compose (for local CPU machines) and nvidia-docker (for local GPU machines) installed. Alternatively, when running from a SageMaker notebook instance, you can simply run the following script to install dependencies.\n\nNote, you can only run a single local notebook at one time.", "_____no_output_____" ] ], [ [ "# Only run from SageMaker notebook instance\nif local_mode:\n !/bin/bash ./common/setup.sh", "_____no_output_____" ] ], [ [ "## Build docker container\n\nSince we're working with a custom environment with custom dependencies, we create our own container for training. We:\n\n1. Fetch the base MXNet and Coach container image,\n2. Install EnergyPlus and its dependencies on top,\n3. Upload the new container image to AWS ECR.", "_____no_output_____" ] ], [ [ "cpu_or_gpu = 'gpu' if instance_type.startswith('ml.p') else 'cpu'\nrepository_short_name = \"sagemaker-hvac-coach-%s\" % cpu_or_gpu\ndocker_build_args = {\n 'CPU_OR_GPU': cpu_or_gpu, \n 'AWS_REGION': boto3.Session().region_name,\n}\ncustom_image_name = build_and_push_docker_image(repository_short_name, build_args=docker_build_args)\nprint(\"Using ECR image %s\" % custom_image_name)", "_____no_output_____" ] ], [ [ "## Setup the environment\n\nThe environment is defined in a Python file called `data_center_env.py` and for SageMaker training jobs, the file will be uploaded inside the `/src` directory.\n\nThe environment implements the init(), step() and reset() functions that describe how the environment behaves. This is consistent with Open AI Gym interfaces for defining an environment.\n\n1. `init()` - initialize the environment in a pre-defined state\n2. `step()` - take an action on the environment\n3. `reset()` - restart the environment on a new episode", "_____no_output_____" ], [ "## Configure the presets for RL algorithm \n\nThe presets that configure the RL training jobs are defined in the “preset-energy-plus-clipped-ppo.py” file which is also uploaded as part of the `/src` directory. Using the preset file, you can define agent parameters to select the specific agent algorithm. You can also set the environment parameters, define the schedule and visualization parameters, and define the graph manager. The schedule presets will define the number of heat up steps, periodic evaluation steps, training steps between evaluations, etc.\n\nAll of these can be overridden at run-time by specifying the `RLCOACH_PRESET` hyperparameter. Additionally, it can be used to define custom hyperparameters.", "_____no_output_____" ] ], [ [ "!pygmentize src/preset-energy-plus-clipped-ppo.py", "_____no_output_____" ] ], [ [ "## Write the Training Code \n\nThe training code is written in the file “train-coach.py” which is uploaded in the /src directory. \nFirst import the environment files and the preset files, and then define the main() function. ", "_____no_output_____" ] ], [ [ "!pygmentize src/train-coach.py", "_____no_output_____" ] ], [ [ "## Train the RL model using the Python SDK Script mode\n\nIf you are using local mode, the training will run on the notebook instance. When using SageMaker for training, you can select a GPU or CPU instance. The RLEstimator is used for training RL jobs. \n\n1. Specify the source directory where the environment, presets and training code is uploaded.\n2. Specify the entry point as the training code \n3. Specify the choice of RL toolkit and framework. This automatically resolves to the ECR path for the RL Container. \n4. Define the training parameters such as the instance count, job name, S3 path for output and job name. \n5. Specify the hyperparameters for the RL agent algorithm. The RLCOACH_PRESET can be used to specify the RL agent algorithm you want to use. \n6. [optional] Define the metrics definitions that you are interested in capturing in your logs. These can also be visualized in CloudWatch and SageMaker Notebooks. ", "_____no_output_____" ] ], [ [ "%%time\nestimator = RLEstimator(entry_point=\"train-coach.py\",\n source_dir='src',\n dependencies=[\"common/sagemaker_rl\"],\n image_uri=custom_image_name,\n role=role,\n instance_type=instance_type,\n instance_count=1,\n output_path=s3_output_path,\n base_job_name=job_name_prefix,\n hyperparameters = {\n 'save_model': 1\n }\n )\n\nestimator.fit(wait=local_mode)\njob_name = estimator.latest_training_job.job_name\nprint(\"Training job: %s\" % job_name)", "_____no_output_____" ] ], [ [ "## Store intermediate training output and model checkpoints \n\nThe output from the training job above is stored on S3. The intermediate folder contains gifs and metadata of the training.", "_____no_output_____" ] ], [ [ "s3_url = \"s3://{}/{}\".format(s3_bucket,job_name)\n\nif local_mode:\n output_tar_key = \"{}/output.tar.gz\".format(job_name)\nelse:\n output_tar_key = \"{}/output/output.tar.gz\".format(job_name)\n\nintermediate_folder_key = \"{}/output/intermediate/\".format(job_name)\noutput_url = \"s3://{}/{}\".format(s3_bucket, output_tar_key)\nintermediate_url = \"s3://{}/{}\".format(s3_bucket, intermediate_folder_key)\n\nprint(\"S3 job path: {}\".format(s3_url))\nprint(\"Output.tar.gz location: {}\".format(output_url))\nprint(\"Intermediate folder path: {}\".format(intermediate_url))\n \ntmp_dir = \"/tmp/{}\".format(job_name)\nos.system(\"mkdir {}\".format(tmp_dir))\nprint(\"Create local folder {}\".format(tmp_dir))", "_____no_output_____" ] ], [ [ "## Visualization", "_____no_output_____" ], [ "### Plot metrics for training job\nWe can pull the reward metric of the training and plot it to see the performance of the model over time.", "_____no_output_____" ] ], [ [ "%matplotlib inline\nimport pandas as pd\n\ncsv_file_name = \"worker_0.simple_rl_graph.main_level.main_level.agent_0.csv\"\nkey = os.path.join(intermediate_folder_key, csv_file_name)\nwait_for_s3_object(s3_bucket, key, tmp_dir)\n\ncsv_file = \"{}/{}\".format(tmp_dir, csv_file_name)\ndf = pd.read_csv(csv_file)\ndf = df.dropna(subset=['Training Reward'])\nx_axis = 'Episode #'\ny_axis = 'Training Reward'\n\nplt = df.plot(x=x_axis,y=y_axis, figsize=(12,5), legend=True, style='b-')\nplt.set_ylabel(y_axis);\nplt.set_xlabel(x_axis);", "_____no_output_____" ] ], [ [ "## Evaluation of RL models\n\nWe use the last checkpointed model to run evaluation for the RL Agent. \n\n### Load checkpointed model\n\nCheckpointed data from the previously trained models will be passed on for evaluation / inference in the checkpoint channel. In local mode, we can simply use the local directory, whereas in the SageMaker mode, it needs to be moved to S3 first.", "_____no_output_____" ] ], [ [ "wait_for_s3_object(s3_bucket, output_tar_key, tmp_dir) \n\nif not os.path.isfile(\"{}/output.tar.gz\".format(tmp_dir)):\n raise FileNotFoundError(\"File output.tar.gz not found\")\nos.system(\"tar -xvzf {}/output.tar.gz -C {}\".format(tmp_dir, tmp_dir))\n\nif local_mode:\n checkpoint_dir = \"{}/data/checkpoint\".format(tmp_dir)\nelse:\n checkpoint_dir = \"{}/checkpoint\".format(tmp_dir)\n\nprint(\"Checkpoint directory {}\".format(checkpoint_dir))", "_____no_output_____" ], [ "if local_mode:\n checkpoint_path = 'file://{}'.format(checkpoint_dir)\n print(\"Local checkpoint file path: {}\".format(checkpoint_path))\nelse:\n checkpoint_path = \"s3://{}/{}/checkpoint/\".format(s3_bucket, job_name)\n if not os.listdir(checkpoint_dir):\n raise FileNotFoundError(\"Checkpoint files not found under the path\")\n os.system(\"aws s3 cp --recursive {} {}\".format(checkpoint_dir, checkpoint_path))\n print(\"S3 checkpoint file path: {}\".format(checkpoint_path))", "_____no_output_____" ] ], [ [ "### Run the evaluation step\n\nUse the checkpointed model to run the evaluation step. ", "_____no_output_____" ] ], [ [ "estimator_eval = RLEstimator(entry_point=\"evaluate-coach.py\",\n source_dir='src',\n dependencies=[\"common/sagemaker_rl\"],\n image_uri=custom_image_name,\n role=role,\n instance_type=instance_type,\n instance_count=1,\n output_path=s3_output_path,\n base_job_name=job_name_prefix+\"-evaluation\",\n hyperparameters = {\n \"RLCOACH_PRESET\": \"preset-energy-plus-clipped-ppo\",\n \"evaluate_steps\": 288*2, #2 episodes, i.e. 2 days\n }\n )\n\nestimator_eval.fit({'checkpoint': checkpoint_path})", "_____no_output_____" ] ], [ [ "# Model deployment", "_____no_output_____" ], [ "Since we specified MXNet when configuring the RLEstimator, the MXNet deployment container will be used for hosting.", "_____no_output_____" ] ], [ [ "from sagemaker.mxnet.model import MXNetModel\n\nmodel = MXNetModel(model_data=estimator.model_data,\n entry_point='src/deploy-mxnet-coach.py',\n framework_version='1.8.0',\n py_version=\"py37\",\n role=role)\n\npredictor = model.deploy(initial_instance_count=1,\n instance_type=instance_type)", "_____no_output_____" ] ], [ [ "We can test the endpoint with a samples observation, where the current room temperature is high. Since the environment vector was of the form `[outdoor_temperature, outdoor_humidity, indoor_humidity]` and we used observation normalization in our preset, we choose an observation of `[0, 0, 2]`. Since we're deploying a PPO model, our model returns both state value and actions.", "_____no_output_____" ] ], [ [ "action, action_mean, action_std = predictor.predict(np.array([0., 0., 2.,]))\naction_mean", "_____no_output_____" ] ], [ [ "We can see heating and cooling setpoints are returned from the model, and these can be used to control the HVAC system for efficient energy usage. More training iterations will help improve the model further.", "_____no_output_____" ], [ "### Clean up endpoint", "_____no_output_____" ] ], [ [ "predictor.delete_endpoint()", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ] ]

[ "BSD-2-Clause" ]

[ "BSD-2-Clause" ]

[ "BSD-2-Clause" ]

[ [ [ "import pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport matplotlib as mpl\nimport sys\nimport os\nimport cmocean\nimport cmocean.cm as cmo", "_____no_output_____" ], [ "os.path.exists", "_____no_output_____" ], [ "full_df = pd.DataFrame()\ncols = ['Trial', \"tr_mse\", 'te_mse']", "_____no_output_____" ], [ "fname = \"./saved-outputs/inertia_log_mixedemlp_basic1e-05_equiv1e-05.pkl\"\nrpp_df = pd.read_pickle(fname)\nrpp_df.columns = cols\nrpp_df['type'] = 'RPP'\nfull_df = pd.concat((full_df, rpp_df))\n\n\nfname = \"./saved-outputs/inertia_log_mlp_basic100.0_equiv0.001.pkl\"\nmlp_df = pd.read_pickle(fname)\nmlp_df.columns = cols\nmlp_df['type'] = \"MLP\"\nfull_df = pd.concat((full_df, mlp_df))\n\n\nfname = \"./saved-outputs/inertia_log_emlp_basic100.0_equiv0.001.pkl\"\nemlp_df = pd.read_pickle(fname)\nemlp_df.columns = cols\nemlp_df['type'] = \"EMLP\"\nfull_df = pd.concat((full_df, emlp_df))", "_____no_output_____" ], [ "full_df['log_te_mse'] = np.log(full_df['te_mse'])", "_____no_output_____" ], [ "cpal = sns.color_palette(\"cmo.matter\", n_colors=3)\n\nfs = 30\nalpha = 0.75\nfig, ax = plt.subplots(1,1, dpi=150, figsize=(8, 3))\nvlns = sns.boxplot(x='type', y='log_te_mse', data=full_df, palette=\"Blues\", ax=ax)\n# for violin in vlns.collections[::2]:\n# violin.set_alpha(alpha)\nax.set_xlabel(\"\", fontsize=fs)\nax.set_ylabel(\"Log MSE\", fontsize=fs)\nax.tick_params(\"both\", labelsize=fs-2)\nax.set_title(\"Inertia; SL(3)\", fontsize=fs+2)\nsns.despine()\nplt.savefig(\"./misspec_inertia.pdf\", bbox_inches='tight')\nplt.show()", "_____no_output_____" ] ], [ [ "## Pendulum Data", "_____no_output_____" ] ], [ [ "full_df = pd.DataFrame()\ncols = ['Trial', \"tr_mse\", 'te_mse']\n\nfname = \"./saved-outputs/log_mixedemlp_basic1e-05_equiv1e-05.pkl\"\nrpp_df = pd.read_pickle(fname)\nrpp_df.columns = cols\nrpp_df['type'] = 'RPP'\nfull_df = pd.concat((full_df, rpp_df))\n\n\nfname = \"./saved-outputs/log_mlp_basic0.01_equiv0.0001.pkl\"\nmlp_df = pd.read_pickle(fname)\nmlp_df.columns = cols\nmlp_df['type'] = \"MLP\"\nfull_df = pd.concat((full_df, mlp_df))\n\n\nfname = \"./saved-outputs/log_emlp_basic0.01_equiv0.0001.pkl\"\nemlp_df = pd.read_pickle(fname)\nemlp_df.columns = cols\nemlp_df['type'] = \"EMLP\"\nfull_df = pd.concat((full_df, emlp_df))", "_____no_output_____" ], [ "full_df['log_te_mse'] = np.log(full_df['te_mse'])", "_____no_output_____" ], [ "cpal = sns.color_palette(\"cmo.matter\", n_colors=3)\n\nfs = 30\nalpha = 0.75\nfig, ax = plt.subplots(1,1, dpi=150, figsize=(8, 3))\nvlns = sns.boxplot(x='type', y='log_te_mse', data=full_df, palette=\"Blues\", ax=ax)\n# for violin in vlns.collections[::2]:\n# violin.set_alpha(alpha)\nax.set_xlabel(\"\", fontsize=fs)\nax.set_ylabel(\"Log MSE\", fontsize=fs)\nax.tick_params(\"both\", labelsize=fs-2)\nax.set_title(\"Pendulum; SO(3)\", fontsize=fs+2)\nsns.despine()\nplt.savefig(\"./misspec_pendulum.pdf\", bbox_inches='tight')\nplt.show()", "_____no_output_____" ] ] ]

[ "code", "markdown", "code" ]

[ [ "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Music Generation Using Deep Learning", "_____no_output_____" ], [ "## Real World Problem\n\nThis case-study focuses on generating music automatically using Recurrent Neural Network(RNN).<br> \nWe do not necessarily have to be a music expert in order to generate music. Even a non expert can generate a decent quality music using RNN.<br>\nWe all like to listen interesting music and if there is some way to generate music automatically, particularly decent quality music then it's a big leap in the world of music industry.<br><br>\n<b>Task:</b> Our task here is to take some existing music data then train a model using this existing data. The model has to learn the patterns in music that we humans enjoy. Once it learns this, the model should be able to generate new music for us. It cannot simply copy-paste from the training data. It has to understand the patterns of music to generate new music. We here are not expecting our model to generate new music which is of professional quality, but we want it to generate a decent quality music which should be melodious and good to hear.<br><br>\nNow, what is music? In short music is nothing but a sequence of musical notes. Our input to the model is a sequence of musical events/notes. Our output will be new sequence of musical events/notes. In this case-study we have limited our self to single instrument music as this is our first cut model. In future, we will extend this to multiple instrument music. ", "_____no_output_____" ], [ "## Data Source:\n1. http://abc.sourceforge.net/NMD/\n2. http://trillian.mit.edu/~jc/music/book/oneills/1850/X/\n\n### From first data-source, we have downloaded first two files:\n* Jigs (340 tunes)\n* Hornpipes (65 tunes)", "_____no_output_____" ] ], [ [ "import os\nimport json\nimport numpy as np\nimport pandas as pd\nfrom keras.models import Sequential\nfrom keras.layers import LSTM, Dropout, TimeDistributed, Dense, Activation, Embedding", "C:\\Users\\GauravP\\Anaconda3\\lib\\site-packages\\h5py\\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n from ._conv import register_converters as _register_converters\nUsing TensorFlow backend.\n" ], [ "data_directory = \"../Data/\"\ndata_file = \"Data_Tunes.txt\"\ncharIndex_json = \"char_to_index.json\"\nmodel_weights_directory = '../Data/Model_Weights/'\nBATCH_SIZE = 16\nSEQ_LENGTH = 64", "_____no_output_____" ], [ "def read_batches(all_chars, unique_chars):\n length = all_chars.shape[0]\n batch_chars = int(length / BATCH_SIZE) #155222/16 = 9701\n \n for start in range(0, batch_chars - SEQ_LENGTH, 64): #(0, 9637, 64) #it denotes number of batches. It runs everytime when\n #new batch is created. We have a total of 151 batches.\n X = np.zeros((BATCH_SIZE, SEQ_LENGTH)) #(16, 64)\n Y = np.zeros((BATCH_SIZE, SEQ_LENGTH, unique_chars)) #(16, 64, 87)\n for batch_index in range(0, 16): #it denotes each row in a batch. \n for i in range(0, 64): #it denotes each column in a batch. Each column represents each character means \n #each time-step character in a sequence.\n X[batch_index, i] = all_chars[batch_index * batch_chars + start + i]\n Y[batch_index, i, all_chars[batch_index * batch_chars + start + i + 1]] = 1 #here we have added '1' because the\n #correct label will be the next character in the sequence. So, the next character will be denoted by\n #all_chars[batch_index * batch_chars + start + i + 1]\n yield X, Y", "_____no_output_____" ], [ "def built_model(batch_size, seq_length, unique_chars):\n model = Sequential()\n \n model.add(Embedding(input_dim = unique_chars, output_dim = 512, batch_input_shape = (batch_size, seq_length))) \n \n model.add(LSTM(256, return_sequences = True, stateful = True))\n model.add(Dropout(0.2))\n \n model.add(LSTM(128, return_sequences = True, stateful = True))\n model.add(Dropout(0.2))\n \n model.add(TimeDistributed(Dense(unique_chars)))\n\n model.add(Activation(\"softmax\"))\n \n return model", "_____no_output_____" ], [ "def training_model(data, epochs = 80):\n #mapping character to index\n char_to_index = {ch: i for (i, ch) in enumerate(sorted(list(set(data))))}\n print(\"Number of unique characters in our whole tunes database = {}\".format(len(char_to_index))) #87\n \n with open(os.path.join(data_directory, charIndex_json), mode = \"w\") as f:\n json.dump(char_to_index, f)\n \n index_to_char = {i: ch for (ch, i) in char_to_index.items()}\n unique_chars = len(char_to_index)\n \n model = built_model(BATCH_SIZE, SEQ_LENGTH, unique_chars)\n model.summary()\n model.compile(loss = \"categorical_crossentropy\", optimizer = \"adam\", metrics = [\"accuracy\"])\n \n all_characters = np.asarray([char_to_index[c] for c in data], dtype = np.int32)\n print(\"Total number of characters = \"+str(all_characters.shape[0])) #155222\n \n epoch_number, loss, accuracy = [], [], []\n \n for epoch in range(epochs):\n print(\"Epoch {}/{}\".format(epoch+1, epochs))\n final_epoch_loss, final_epoch_accuracy = 0, 0\n epoch_number.append(epoch+1)\n \n for i, (x, y) in enumerate(read_batches(all_characters, unique_chars)):\n final_epoch_loss, final_epoch_accuracy = model.train_on_batch(x, y) #check documentation of train_on_batch here: https://keras.io/models/sequential/\n print(\"Batch: {}, Loss: {}, Accuracy: {}\".format(i+1, final_epoch_loss, final_epoch_accuracy))\n #here, above we are reading the batches one-by-one and train our model on each batch one-by-one.\n loss.append(final_epoch_loss)\n accuracy.append(final_epoch_accuracy)\n \n #saving weights after every 10 epochs\n if (epoch + 1) % 10 == 0:\n if not os.path.exists(model_weights_directory):\n os.makedirs(model_weights_directory)\n model.save_weights(os.path.join(model_weights_directory, \"Weights_{}.h5\".format(epoch+1)))\n print('Saved Weights at epoch {} to file Weights_{}.h5'.format(epoch+1, epoch+1))\n \n #creating dataframe and record all the losses and accuracies at each epoch\n log_frame = pd.DataFrame(columns = [\"Epoch\", \"Loss\", \"Accuracy\"])\n log_frame[\"Epoch\"] = epoch_number\n log_frame[\"Loss\"] = loss\n log_frame[\"Accuracy\"] = accuracy\n log_frame.to_csv(\"../Data/log.csv\", index = False)", "_____no_output_____" ], [ "file = open(os.path.join(data_directory, data_file), mode = 'r')\ndata = file.read()\nfile.close()\nif __name__ == \"__main__\":\n training_model(data)", "_____no_output_____" ], [ "log = pd.read_csv(os.path.join(data_directory, \"log.csv\"))\nlog", "_____no_output_____" ] ] ]

[ "markdown", "code" ]

[ [ "markdown", "markdown", "markdown" ], [ "code", "code", "code", "code", "code", "code", "code" ] ]

[ "BSD-2-Clause" ]

[ "BSD-2-Clause" ]

[ "BSD-2-Clause" ]

[ [ [ "import pandas as pd", "_____no_output_____" ], [ "df = pd.read_csv('./test_men.csv', header=None, sep=',', names=['lbl']+[i for i in range(13)])", "_____no_output_____" ], [ "df.head()", "_____no_output_____" ], [ "df.groupby('lbl').size()", "_____no_output_____" ], [ "df.loc[df.lbl==0, 'lbl'] = 1\ndf.loc[df.lbl==1, 'lbl'] = 1\ndf.loc[df.lbl==2, 'lbl'] = -1\ndf.loc[df.lbl==3, 'lbl'] = -1", "_____no_output_____" ], [ "df.head()", "_____no_output_____" ], [ "df.groupby('lbl').size()", "_____no_output_____" ] ], [ [ "## Make sure the number of minority class (lbl==1) is smaller than number of majority class (lbl==-1)", "_____no_output_____" ] ], [ [ "sum(df.lbl)", "_____no_output_____" ], [ "len(df)", "_____no_output_____" ], [ "df.to_csv('test_men_binary.csv',header=None, sep=',', index=None)", "_____no_output_____" ] ] ]

[ "code", "markdown", "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "import sys\nfrom PyQt5 import QtCore, QtWidgets, QtWebEngineWidgets\nfrom lxml import html as htmlRenderer\nimport requests\nimport json\nfrom datetime import date\nimport datetime\nfrom random import *", "_____no_output_____" ], [ "def render(source_url):\n \"\"\"Fully render HTML, JavaScript and all.\"\"\"\n\n import sys\n from PyQt5.QtWidgets import QApplication\n from PyQt5.QtCore import QUrl\n from PyQt5.QtWebEngineWidgets import QWebEngineView\n\n class Render(QWebEngineView):\n def __init__(self, url):\n self.html = None\n self.app = QApplication(sys.argv)\n QWebEngineView.__init__(self)\n self.loadFinished.connect(self._loadFinished)\n #self.setHtml(html)\n self.load(QUrl(url))\n self.app.exec_()\n\n def _loadFinished(self, result):\n # This is an async call, you need to wait for this\n # to be called before closing the app\n self.page().toHtml(self._callable)\n\n def _callable(self, data):\n self.html = data\n # Data has been stored, it's safe to quit the app\n self.app.quit()\n\n return Render(source_url).html", "_____no_output_____" ], [ "url=\"https://www.20minutos.es/deportes/noticia/casillas-critico-tuit-arbitro-champions-liverpool-3611469/0/\"\nrenderUrl = render(url)\nrenderedPage = htmlRenderer.fromstring(renderUrl)", "_____no_output_____" ], [ "auxLinks = renderedPage.xpath(\"//div[@class='gtm-article-text']//p\")", "_____no_output_____" ], [ "a = auxLinks[0]", "_____no_output_____" ], [ "a.text_content()", "_____no_output_____" ], [ "contentArr = []\nfor p in auxLinks:\n contentArr.append(p.text_content())\ncontentArr", "_____no_output_____" ], [ "\"\".join([ parrafo for parrafo in contentArr])", "_____no_output_____" ], [ "commentEl = auxLinks[0]\ncommentElVal = commentEl.get(\"id\").split(\"_\")\nidNoticia = commentElVal[len(commentElVal)-1]\nperfiloHiloId = \"_{}\".format(idNoticia)", "_____no_output_____" ], [ "# Get Comments Info\n\nurlInfoComments = \"https://elpais.com/ThreadeskupSimple\"\nrnd = random()\n\ninfoArg = {\n \"action\": \"info\",\n \"th\": idNoticia,\n \"rnd\": rnd\n}", "_____no_output_____" ], [ "responseInfoComments = requests.get(urlInfoComments, infoArg)", "_____no_output_____" ], [ "responseInfoComments", "_____no_output_____" ], [ "infoComments = json.loads(responseInfoComments.text)", "_____no_output_____" ], [ "infoComments", "_____no_output_____" ], [ "pages = infoComments[\"perfilesHilos\"][perfiloHiloId][\"numero_mensajes\"]//50\nif (infoComments[\"perfilesHilos\"][perfiloHiloId][\"numero_mensajes\"]%50 > 0) :\n pages = pages + 1\n\npages", "_____no_output_____" ], [ "# https://elpais.com/OuteskupSimple?s=&rnd=0.5448952094970048&th=2&msg=1564664936-bca025601586bc5a00ef0c26fdd878f6&p=2&nummsg=120&tt=1\n# s=\n# &rnd=0.5448952094970048\n# &th=2\n# &msg=1564664936-bca025601586bc5a00ef0c26fdd878f6\n# &p=2\n# &nummsg=120\n# &tt=1\nrnd = random()\ncommentsArgs = {\n \"s\": \"\",\n \"rnd\": rnd,\n \"th\": 1,\n \"msg\": idNoticia,\n \"nummsg\": infoComments[\"perfilesHilos\"][perfiloHiloId][\"numero_mensajes\"],\n \"tt\": 1\n}", "_____no_output_____" ], [ "urlGetComments = \"https://elpais.com/OuteskupSimple\"\nresponseComments = requests.get(urlGetComments, commentsArgs)", "_____no_output_____" ], [ "commentsResponse = json.loads(responseComments.text)", "_____no_output_____" ], [ "commentsResponse", "_____no_output_____" ], [ "\ndef extractComments(commentsObjectList, urlNoticia=\"\", specialCase = False):\n print(\" \\t -> parsing comments list with -{}- elements:\".format(len(commentsObjectList)))\n parsedComments = []\n listToParse = commentsObjectList[1] if specialCase else commentsObjectList\n for commentObj in listToParse:\n fechaObj = datetime.datetime.fromtimestamp(commentObj[\"tsMensaje\"])\n fechaStr = fechaObj.strftime(\"%d/%m/%Y-%H:%M:%S\")\n fechaArr = fechaStr.split(\"-\")\n parsedComment = {\n \"urlNoticia\": urlNoticia,\n \"fecha\": fechaArr[0],\n \"hora\": fechaArr[1],\n \"user\": commentObj['usuarioOrigen'],\n \"commentario\": commentObj['contenido']\n }\n parsedComments.append(parsedComment)\n return parsedComments", "_____no_output_____" ], [ "parsedComments = extractComments(commentsResponse[\"mensajes\"], url)", " \t -> parsing comments list with -121- elements:\n" ], [ "parsedComments", "_____no_output_____" ], [ "len(parsedComments)", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Dask jobqueue example for NEC Linux cluster\ncovers the following aspects, i.e. how to\n* load project and machine specific Dask jobqueue configurations\n* open, scale and close a default jobqueue cluster\n* do an example calculation on larger than memory data", "_____no_output_____" ], [ "## Load jobqueue configuration defaults", "_____no_output_____" ] ], [ [ "import os \nos.environ['DASK_CONFIG']='.' # use local directory to look up Dask configurations", "_____no_output_____" ], [ "import dask.config\ndask.config.get('jobqueue') # prints available jobqueue configurations", "_____no_output_____" ] ], [ [ "## Set up jobqueue cluster ...", "_____no_output_____" ] ], [ [ "import dask_jobqueue\ndefault_cluster = dask_jobqueue.PBSCluster(config_name='nesh-jobqueue-config')", "_____no_output_____" ], [ "print(default_cluster.job_script())", "#!/bin/bash\n\n#PBS -N dask-worker\n#PBS -q clmedium\n#PBS -l elapstim_req=00:45:00,cpunum_job=4,memsz_job=24gb\n#PBS -o dask_jobqueue_logs/dask-worker.o%s\n#PBS -e dask_jobqueue_logs/dask-worker.e%s\nJOB_ID=${PBS_JOBID%%.*}\n\n/sfs/fs6/home-geomar/smomw260/miniconda3/envs/dask-minimal-20191218/bin/python -m distributed.cli.dask_worker tcp://192.168.31.10:32956 --nthreads 4 --memory-limit 24.00GB --name name --nanny --death-timeout 60 --local-directory /scratch --interface ib0\n\n" ] ], [ [ "## ... and the client process", "_____no_output_____" ] ], [ [ "import dask.distributed as dask_distributed\ndefault_cluster_client = dask_distributed.Client(default_cluster)", "_____no_output_____" ] ], [ [ "## Start jobqueue workers", "_____no_output_____" ] ], [ [ "default_cluster.scale(jobs=2)", "_____no_output_____" ], [ "!qstat", "RequestID ReqName UserName Queue Pri STT S Memory CPU Elapse R H M Jobs\n--------------- -------- -------- -------- ---- --- - -------- -------- -------- - - - ----\n182478.nesh-bat dask-wor smomw260 clmedium 0 RUN - 0.00B 0.00 8 Y Y Y 1 \n182479.nesh-bat dask-wor smomw260 clmedium 0 RUN - 0.00B 0.00 8 Y Y Y 1 \n" ], [ "default_cluster_client", "_____no_output_____" ] ], [ [ "## Do calculation on larger than memory data", "_____no_output_____" ] ], [ [ "import dask.array as da", "_____no_output_____" ], [ "fake_data = da.random.uniform(0, 1, size=(365, 1e4, 1e4), chunks=(365,500,500)) # problem specific chunking\nfake_data", "_____no_output_____" ], [ "import time", "_____no_output_____" ], [ "start_time = time.time()\nfake_data.mean(axis=0).compute()\nelapsed = time.time() - start_time", "_____no_output_____" ], [ "print('elapse time ',elapsed,' in seconds')", "elapse time 46.89112448692322 in seconds\n" ] ], [ [ "## Close jobqueue cluster and client process", "_____no_output_____" ] ], [ [ "!qstat", "RequestID ReqName UserName Queue Pri STT S Memory CPU Elapse R H M Jobs\n--------------- -------- -------- -------- ---- --- - -------- -------- -------- - - - ----\n182478.nesh-bat dask-wor smomw260 clmedium 0 RUN - 2.58G 157.12 94 Y Y Y 1 \n182479.nesh-bat dask-wor smomw260 clmedium 0 RUN - 804.87M 157.49 94 Y Y Y 1 \n" ], [ "default_cluster.close()\ndefault_cluster_client.close()", "_____no_output_____" ], [ "!qstat", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "", "_____no_output_____" ], [ "# _*Qiskit Aqua: Experimenting with Max-Cut problem and Traveling Salesman problem with variational quantum eigensolver*_ \n\nThe latest version of this notebook is available on https://github.com/Qiskit/qiskit-tutorial.\n\n***\n### Contributors\nAntonio Mezzacapo^[1], Jay Gambetta^[1], Kristan Temme^[1], Ramis Movassagh^[1], Albert Frisch^[1], Takashi Imamichi^[1], Giacomo Nannicni^[1], Richard Chen^[1], Marco Pistoia^[1], Stephen Wood^[1]\n### Affiliation\n- ^[1]IBMQ", "_____no_output_____" ], [ "## Introduction\n\nMany problems in quantitative fields such as finance and engineering are optimization problems. Optimization problems lie at the core of complex decision-making and definition of strategies. \n\nOptimization (or combinatorial optimization) means searching for an optimal solution in a finite or countably infinite set of potential solutions. Optimality is defined with respect to some criterion function, which is to be minimized or maximized. This is typically called cost function or objective function. \n\n**Typical optimization problems**\n\nMinimization: cost, distance, length of a traversal, weight, processing time, material, energy consumption, number of objects\n\nMaximization: profit, value, output, return, yield, utility, efficiency, capacity, number of objects \n\nWe consider here max-cut problems of practical interest in many fields, and show how they can be nmapped on quantum computers.\n\n\n### Weighted Max-Cut\n\nMax-Cut is an NP-complete problem, with applications in clustering, network science, and statistical physics. To grasp how practical applications are mapped into given Max-Cut instances, consider a system of many people that can interact and influence each other. Individuals can be represented by vertices of a graph, and their interactions seen as pairwise connections between vertices of the graph, or edges. With this representation in mind, it is easy to model typical marketing problems. For example, suppose that it is assumed that individuals will influence each other's buying decisions, and knowledge is given about how strong they will influence each other. The influence can be modeled by weights assigned on each edge of the graph. It is possible then to predict the outcome of a marketing strategy in which products are offered for free to some individuals, and then ask which is the optimal subset of individuals that should get the free products, in order to maximize revenues.\n\nThe formal definition of this problem is the following:\n\nConsider an $n$-node undirected graph *G = (V, E)* where *|V| = n* with edge weights $w_{ij}>0$, $w_{ij}=w_{ji}$, for $(i, j)\\in E$. A cut is defined as a partition of the original set V into two subsets. The cost function to be optimized is in this case the sum of weights of edges connecting points in the two different subsets, *crossing* the cut. By assigning $x_i=0$ or $x_i=1$ to each node $i$, one tries to maximize the global profit function (here and in the following summations run over indices 0,1,...n-1)\n\n$$\\tilde{C}(\\textbf{x}) = \\sum_{i,j} w_{ij} x_i (1-x_j).$$\n\nIn our simple marketing model, $w_{ij}$ represents the probability that the person $j$ will buy a product after $i$ gets a free one. Note that the weights $w_{ij}$ can in principle be greater than $1$, corresponding to the case where the individual $j$ will buy more than one product. Maximizing the total buying probability corresponds to maximizing the total future revenues. In the case where the profit probability will be greater than the cost of the initial free samples, the strategy is a convenient one. An extension to this model has the nodes themselves carry weights, which can be regarded, in our marketing model, as the likelihood that a person granted with a free sample of the product will buy it again in the future. With this additional information in our model, the objective function to maximize becomes \n\n$$C(\\textbf{x}) = \\sum_{i,j} w_{ij} x_i (1-x_j)+\\sum_i w_i x_i. $$\n \nIn order to find a solution to this problem on a quantum computer, one needs first to map it to an Ising Hamiltonian. This can be done with the assignment $x_i\\rightarrow (1-Z_i)/2$, where $Z_i$ is the Pauli Z operator that has eigenvalues $\\pm 1$. Doing this we find that \n\n$$C(\\textbf{Z}) = \\sum_{i,j} \\frac{w_{ij}}{4} (1-Z_i)(1+Z_j) + \\sum_i \\frac{w_i}{2} (1-Z_i) = -\\frac{1}{2}\\left( \\sum_{i<j} w_{ij} Z_i Z_j +\\sum_i w_i Z_i\\right)+\\mathrm{const},$$\n\nwhere const = $\\sum_{i<j}w_{ij}/2+\\sum_i w_i/2 $. In other terms, the weighted Max-Cut problem is equivalent to minimizing the Ising Hamiltonian \n\n$$ H = \\sum_i w_i Z_i + \\sum_{i<j} w_{ij} Z_iZ_j.$$\n\nAqua can generate the Ising Hamiltonian for the first profit function $\\tilde{C}$.\n\n\n### Approximate Universal Quantum Computing for Optimization Problems\n\nThere has been a considerable amount of interest in recent times about the use of quantum computers to find a solution to combinatorial problems. It is important to say that, given the classical nature of combinatorial problems, exponential speedup in using quantum computers compared to the best classical algorithms is not guaranteed. However, due to the nature and importance of the target problems, it is worth investigating heuristic approaches on a quantum computer that could indeed speed up some problem instances. Here we demonstrate an approach that is based on the Quantum Approximate Optimization Algorithm by Farhi, Goldstone, and Gutman (2014). We frame the algorithm in the context of *approximate quantum computing*, given its heuristic nature. \n\nThe Algorithm works as follows:\n1. Choose the $w_i$ and $w_{ij}$ in the target Ising problem. In principle, even higher powers of Z are allowed.\n2. Choose the depth of the quantum circuit $m$. Note that the depth can be modified adaptively.\n3. Choose a set of controls $\\theta$ and make a trial function $|\\psi(\\boldsymbol\\theta)\\rangle$, built using a quantum circuit made of C-Phase gates and single-qubit Y rotations, parameterized by the components of $\\boldsymbol\\theta$. \n4. Evaluate $C(\\boldsymbol\\theta) = \\langle\\psi(\\boldsymbol\\theta)~|H|~\\psi(\\boldsymbol\\theta)\\rangle = \\sum_i w_i \\langle\\psi(\\boldsymbol\\theta)~|Z_i|~\\psi(\\boldsymbol\\theta)\\rangle+ \\sum_{i<j} w_{ij} \\langle\\psi(\\boldsymbol\\theta)~|Z_iZ_j|~\\psi(\\boldsymbol\\theta)\\rangle$ by sampling the outcome of the circuit in the Z-basis and adding the expectation values of the individual Ising terms together. In general, different control points around $\\boldsymbol\\theta$ have to be estimated, depending on the classical optimizer chosen. \n5. Use a classical optimizer to choose a new set of controls.\n6. Continue until $C(\\boldsymbol\\theta)$ reaches a minimum, close enough to the solution $\\boldsymbol\\theta^*$.\n7. Use the last $\\boldsymbol\\theta$ to generate a final set of samples from the distribution $|\\langle z_i~|\\psi(\\boldsymbol\\theta)\\rangle|^2\\;\\forall i$ to obtain the answer.\n \nIt is our belief the difficulty of finding good heuristic algorithms will come down to the choice of an appropriate trial wavefunction. For example, one could consider a trial function whose entanglement best aligns with the target problem, or simply make the amount of entanglement a variable. In this tutorial, we will consider a simple trial function of the form\n\n$$|\\psi(\\theta)\\rangle = [U_\\mathrm{single}(\\boldsymbol\\theta) U_\\mathrm{entangler}]^m |+\\rangle$$\n\nwhere $U_\\mathrm{entangler}$ is a collection of C-Phase gates (fully entangling gates), and $U_\\mathrm{single}(\\theta) = \\prod_{i=1}^n Y(\\theta_{i})$, where $n$ is the number of qubits and $m$ is the depth of the quantum circuit. The motivation for this choice is that for these classical problems this choice allows us to search over the space of quantum states that have only real coefficients, still exploiting the entanglement to potentially converge faster to the solution.\n\nOne advantage of using this sampling method compared to adiabatic approaches is that the target Ising Hamiltonian does not have to be implemented directly on hardware, allowing this algorithm not to be limited to the connectivity of the device. Furthermore, higher-order terms in the cost function, such as $Z_iZ_jZ_k$, can also be sampled efficiently, whereas in adiabatic or annealing approaches they are generally impractical to deal with. \n\n\nReferences:\n- A. Lucas, Frontiers in Physics 2, 5 (2014)\n- E. Farhi, J. Goldstone, S. Gutmann e-print arXiv 1411.4028 (2014)\n- D. Wecker, M. B. Hastings, M. Troyer Phys. Rev. A 94, 022309 (2016)\n- E. Farhi, J. Goldstone, S. Gutmann, H. Neven e-print arXiv 1703.06199 (2017)", "_____no_output_____" ] ], [ [ "# useful additional packages \nimport matplotlib.pyplot as plt\nimport matplotlib.axes as axes\n%matplotlib inline\nimport numpy as np\nimport networkx as nx\n\nfrom qiskit import BasicAer\nfrom qiskit.tools.visualization import plot_histogram\nfrom qiskit.optimization.ising import max_cut, tsp\nfrom qiskit.aqua.algorithms import VQE, ExactEigensolver\nfrom qiskit.aqua.components.optimizers import SPSA\nfrom qiskit.aqua.components.variational_forms import RY\nfrom qiskit.aqua import QuantumInstance\nfrom qiskit.optimization.ising.common import sample_most_likely\n\n# setup aqua logging\nimport logging\nfrom qiskit.aqua import set_qiskit_aqua_logging\n# set_qiskit_aqua_logging(logging.DEBUG) # choose INFO, DEBUG to see the log", "_____no_output_____" ] ], [ [ "### [Optional] Setup token to run the experiment on a real device\nIf you would like to run the experiment on a real device, you need to setup your account first.\n\nNote: If you do not store your token yet, use `IBMQ.save_account('MY_API_TOKEN')` to store it first.", "_____no_output_____" ] ], [ [ "from qiskit import IBMQ\n# provider = IBMQ.load_account()", "_____no_output_____" ] ], [ [ "## Max-Cut problem", "_____no_output_____" ] ], [ [ "# Generating a graph of 4 nodes \n\nn=4 # Number of nodes in graph\nG=nx.Graph()\nG.add_nodes_from(np.arange(0,n,1))\nelist=[(0,1,1.0),(0,2,1.0),(0,3,1.0),(1,2,1.0),(2,3,1.0)]\n# tuple is (i,j,weight) where (i,j) is the edge\nG.add_weighted_edges_from(elist)\n\ncolors = ['r' for node in G.nodes()]\npos = nx.spring_layout(G)\ndefault_axes = plt.axes(frameon=True)\nnx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, ax=default_axes, pos=pos)", "_____no_output_____" ], [ "# Computing the weight matrix from the random graph\nw = np.zeros([n,n])\nfor i in range(n):\n for j in range(n):\n temp = G.get_edge_data(i,j,default=0)\n if temp != 0:\n w[i,j] = temp['weight'] \nprint(w)", "[[0. 1. 1. 1.]\n [1. 0. 1. 0.]\n [1. 1. 0. 1.]\n [1. 0. 1. 0.]]\n" ] ], [ [ "### Brute force approach\n\nTry all possible $2^n$ combinations. For $n = 4$, as in this example, one deals with only 16 combinations, but for n = 1000, one has 1.071509e+30 combinations, which is impractical to deal with by using a brute force approach. ", "_____no_output_____" ] ], [ [ "best_cost_brute = 0\nfor b in range(2**n):\n x = [int(t) for t in reversed(list(bin(b)[2:].zfill(n)))]\n cost = 0\n for i in range(n):\n for j in range(n):\n cost = cost + w[i,j]*x[i]*(1-x[j])\n if best_cost_brute < cost:\n best_cost_brute = cost\n xbest_brute = x \n print('case = ' + str(x)+ ' cost = ' + str(cost))\n\ncolors = ['r' if xbest_brute[i] == 0 else 'b' for i in range(n)]\nnx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, pos=pos)\nprint('\\nBest solution = ' + str(xbest_brute) + ' cost = ' + str(best_cost_brute)) ", "case = [0, 0, 0, 0] cost = 0.0\ncase = [1, 0, 0, 0] cost = 3.0\ncase = [0, 1, 0, 0] cost = 2.0\ncase = [1, 1, 0, 0] cost = 3.0\ncase = [0, 0, 1, 0] cost = 3.0\ncase = [1, 0, 1, 0] cost = 4.0\ncase = [0, 1, 1, 0] cost = 3.0\ncase = [1, 1, 1, 0] cost = 2.0\ncase = [0, 0, 0, 1] cost = 2.0\ncase = [1, 0, 0, 1] cost = 3.0\ncase = [0, 1, 0, 1] cost = 4.0\ncase = [1, 1, 0, 1] cost = 3.0\ncase = [0, 0, 1, 1] cost = 3.0\ncase = [1, 0, 1, 1] cost = 2.0\ncase = [0, 1, 1, 1] cost = 3.0\ncase = [1, 1, 1, 1] cost = 0.0\n\nBest solution = [1, 0, 1, 0] cost = 4.0\n" ] ], [ [ "### Mapping to the Ising problem", "_____no_output_____" ] ], [ [ "qubitOp, offset = max_cut.get_operator(w)", "_____no_output_____" ] ], [ [ "### [Optional] Using DOcplex for mapping to the Ising problem\nUsing ```docplex.get_qubitops``` is a different way to create an Ising Hamiltonian of Max-Cut. ```docplex.get_qubitops``` can create a corresponding Ising Hamiltonian from an optimization model of Max-Cut. An example of using ```docplex.get_qubitops``` is as below. ", "_____no_output_____" ] ], [ [ "from docplex.mp.model import Model\nfrom qiskit.optimization.ising import docplex\n\n# Create an instance of a model and variables.\nmdl = Model(name='max_cut')\nx = {i: mdl.binary_var(name='x_{0}'.format(i)) for i in range(n)}\n\n# Object function\nmax_cut_func = mdl.sum(w[i,j]* x[i] * ( 1 - x[j] ) for i in range(n) for j in range(n))\nmdl.maximize(max_cut_func)\n\n# No constraints for Max-Cut problems.", "_____no_output_____" ], [ "qubitOp_docplex, offset_docplex = docplex.get_operator(mdl)", "_____no_output_____" ] ], [ [ "### Checking that the full Hamiltonian gives the right cost ", "_____no_output_____" ] ], [ [ "#Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector\nee = ExactEigensolver(qubitOp, k=1)\nresult = ee.run()\n\nx = sample_most_likely(result['eigvecs'][0])\nprint('energy:', result['energy'])\nprint('max-cut objective:', result['energy'] + offset)\nprint('solution:', max_cut.get_graph_solution(x))\nprint('solution objective:', max_cut.max_cut_value(x, w))\n\ncolors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]\nnx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)", "energy: -1.5\nmax-cut objective: -4.0\nsolution: [0. 1. 0. 1.]\nsolution objective: 4.0\n" ] ], [ [ "### Running it on quantum computer\nWe run the optimization routine using a feedback loop with a quantum computer that uses trial functions built with Y single-qubit rotations, $U_\\mathrm{single}(\\theta) = \\prod_{i=1}^n Y(\\theta_{i})$, and entangler steps $U_\\mathrm{entangler}$.", "_____no_output_____" ] ], [ [ "seed = 10598\n\nspsa = SPSA(max_trials=300)\nry = RY(qubitOp.num_qubits, depth=5, entanglement='linear')\nvqe = VQE(qubitOp, ry, spsa)\n\nbackend = BasicAer.get_backend('statevector_simulator')\nquantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed)\n\nresult = vqe.run(quantum_instance)\n\nx = sample_most_likely(result['eigvecs'][0])\nprint('energy:', result['energy'])\nprint('time:', result['eval_time'])\nprint('max-cut objective:', result['energy'] + offset)\nprint('solution:', max_cut.get_graph_solution(x))\nprint('solution objective:', max_cut.max_cut_value(x, w))\n\ncolors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]\nnx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)", "energy: -1.4999575960856462\ntime: 6.378453969955444\nmax-cut objective: -3.999957596085646\nsolution: [1. 0. 1. 0.]\nsolution objective: 4.0\n" ], [ "# run quantum algorithm with shots\nseed = 10598\n\nspsa = SPSA(max_trials=300)\nry = RY(qubitOp.num_qubits, depth=5, entanglement='linear')\nvqe = VQE(qubitOp, ry, spsa)\n\nbackend = BasicAer.get_backend('qasm_simulator')\nquantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=seed, seed_transpiler=seed)\n\nresult = vqe.run(quantum_instance)\n\nx = sample_most_likely(result['eigvecs'][0])\nprint('energy:', result['energy'])\nprint('time:', result['eval_time'])\nprint('max-cut objective:', result['energy'] + offset)\nprint('solution:', max_cut.get_graph_solution(x))\nprint('solution objective:', max_cut.max_cut_value(x, w))\nplot_histogram(result['eigvecs'][0])\n\ncolors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]\nnx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)", "energy: -1.5\ntime: 11.74726128578186\nmax-cut objective: -4.0\nsolution: [0 1 0 1]\nsolution objective: 4.0\n" ] ], [ [ "### [Optional] Checking that the full Hamiltonian made by ```docplex.get_operator``` gives the right cost", "_____no_output_____" ] ], [ [ "#Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector\nee = ExactEigensolver(qubitOp_docplex, k=1)\nresult = ee.run()\n\nx = sample_most_likely(result['eigvecs'][0])\nprint('energy:', result['energy'])\nprint('max-cut objective:', result['energy'] + offset_docplex)\nprint('solution:', max_cut.get_graph_solution(x))\nprint('solution objective:', max_cut.max_cut_value(x, w))\n\ncolors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]\nnx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)", "energy: -1.5\nmax-cut objective: -4.0\nsolution: [0. 1. 0. 1.]\nsolution objective: 4.0\n" ] ], [ [ "## Traveling Salesman Problem\n\nIn addition to being a notorious NP-complete problem that has drawn the attention of computer scientists and mathematicians for over two centuries, the Traveling Salesman Problem (TSP) has important bearings on finance and marketing, as its name suggests. Colloquially speaking, the traveling salesman is a person that goes from city to city to sell merchandise. The objective in this case is to find the shortest path that would enable the salesman to visit all the cities and return to its hometown, i.e. the city where he started traveling. By doing this, the salesman gets to maximize potential sales in the least amount of time. \n\nThe problem derives its importance from its \"hardness\" and ubiquitous equivalence to other relevant combinatorial optimization problems that arise in practice.\n \nThe mathematical formulation with some early analysis was proposed by W.R. Hamilton in the early 19th century. Mathematically the problem is, as in the case of Max-Cut, best abstracted in terms of graphs. The TSP on the nodes of a graph asks for the shortest *Hamiltonian cycle* that can be taken through each of the nodes. A Hamilton cycle is a closed path that uses every vertex of a graph once. The general solution is unknown and an algorithm that finds it efficiently (e.g., in polynomial time) is not expected to exist.\n\nFind the shortest Hamiltonian cycle in a graph $G=(V,E)$ with $n=|V|$ nodes and distances, $w_{ij}$ (distance from vertex $i$ to vertex $j$). A Hamiltonian cycle is described by $N^2$ variables $x_{i,p}$, where $i$ represents the node and $p$ represents its order in a prospective cycle. The decision variable takes the value 1 if the solution occurs at node $i$ at time order $p$. We require that every node can only appear once in the cycle, and for each time a node has to occur. This amounts to the two constraints (here and in the following, whenever not specified, the summands run over 0,1,...N-1)\n\n$$\\sum_{i} x_{i,p} = 1 ~~\\forall p$$\n$$\\sum_{p} x_{i,p} = 1 ~~\\forall i.$$\n\nFor nodes in our prospective ordering, if $x_{i,p}$ and $x_{j,p+1}$ are both 1, then there should be an energy penalty if $(i,j) \\notin E$ (not connected in the graph). The form of this penalty is \n\n$$\\sum_{i,j\\notin E}\\sum_{p} x_{i,p}x_{j,p+1}>0,$$ \n\nwhere it is assumed the boundary condition of the Hamiltonian cycles $(p=N)\\equiv (p=0)$. However, here it will be assumed a fully connected graph and not include this term. The distance that needs to be minimized is \n\n$$C(\\textbf{x})=\\sum_{i,j}w_{ij}\\sum_{p} x_{i,p}x_{j,p+1}.$$\n\nPutting this all together in a single objective function to be minimized, we get the following:\n\n$$C(\\textbf{x})=\\sum_{i,j}w_{ij}\\sum_{p} x_{i,p}x_{j,p+1}+ A\\sum_p\\left(1- \\sum_i x_{i,p}\\right)^2+A\\sum_i\\left(1- \\sum_p x_{i,p}\\right)^2,$$\n\nwhere $A$ is a free parameter. One needs to ensure that $A$ is large enough so that these constraints are respected. One way to do this is to choose $A$ such that $A > \\mathrm{max}(w_{ij})$.\n\nOnce again, it is easy to map the problem in this form to a quantum computer, and the solution will be found by minimizing a Ising Hamiltonian. ", "_____no_output_____" ] ], [ [ "# Generating a graph of 3 nodes\nn = 3\nnum_qubits = n ** 2\nins = tsp.random_tsp(n)\nG = nx.Graph()\nG.add_nodes_from(np.arange(0, n, 1))\ncolors = ['r' for node in G.nodes()]\npos = {k: v for k, v in enumerate(ins.coord)}\ndefault_axes = plt.axes(frameon=True)\nnx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, ax=default_axes, pos=pos)\nprint('distance\\n', ins.w)", "distance\n [[ 0. 25. 19.]\n [25. 0. 27.]\n [19. 27. 0.]]\n" ] ], [ [ "### Brute force approach", "_____no_output_____" ] ], [ [ "from itertools import permutations\n\ndef brute_force_tsp(w, N):\n a=list(permutations(range(1,N)))\n last_best_distance = 1e10\n for i in a:\n distance = 0\n pre_j = 0\n for j in i:\n distance = distance + w[j,pre_j]\n pre_j = j\n distance = distance + w[pre_j,0]\n order = (0,) + i\n if distance < last_best_distance:\n best_order = order\n last_best_distance = distance\n print('order = ' + str(order) + ' Distance = ' + str(distance))\n return last_best_distance, best_order\n \nbest_distance, best_order = brute_force_tsp(ins.w, ins.dim)\nprint('Best order from brute force = ' + str(best_order) + ' with total distance = ' + str(best_distance))\n\ndef draw_tsp_solution(G, order, colors, pos):\n G2 = G.copy()\n n = len(order)\n for i in range(n):\n j = (i + 1) % n\n G2.add_edge(order[i], order[j])\n default_axes = plt.axes(frameon=True)\n nx.draw_networkx(G2, node_color=colors, node_size=600, alpha=.8, ax=default_axes, pos=pos)\n\ndraw_tsp_solution(G, best_order, colors, pos)", "order = (0, 1, 2) Distance = 71.0\nBest order from brute force = (0, 1, 2) with total distance = 71.0\n" ] ], [ [ "### Mapping to the Ising problem", "_____no_output_____" ] ], [ [ "qubitOp, offset = tsp.get_operator(ins)", "_____no_output_____" ] ], [ [ "### [Optional] Using DOcplex for mapping to the Ising problem\nUsing ```docplex.get_qubitops``` is a different way to create an Ising Hamiltonian of TSP. ```docplex.get_qubitops``` can create a corresponding Ising Hamiltonian from an optimization model of TSP. An example of using ```docplex.get_qubitops``` is as below. ", "_____no_output_____" ] ], [ [ "# Create an instance of a model and variables\nmdl = Model(name='tsp')\nx = {(i,p): mdl.binary_var(name='x_{0}_{1}'.format(i,p)) for i in range(n) for p in range(n)}\n\n# Object function\ntsp_func = mdl.sum(ins.w[i,j] * x[(i,p)] * x[(j,(p+1)%n)] for i in range(n) for j in range(n) for p in range(n))\nmdl.minimize(tsp_func)\n\n# Constrains\nfor i in range(n):\n mdl.add_constraint(mdl.sum(x[(i,p)] for p in range(n)) == 1)\nfor p in range(n):\n mdl.add_constraint(mdl.sum(x[(i,p)] for i in range(n)) == 1)", "_____no_output_____" ], [ "qubitOp_docplex, offset_docplex = docplex.get_operator(mdl)", "_____no_output_____" ] ], [ [ "### Checking that the full Hamiltonian gives the right cost ", "_____no_output_____" ] ], [ [ "#Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector\nee = ExactEigensolver(qubitOp, k=1)\nresult = ee.run()\n\nprint('energy:', result['energy'])\nprint('tsp objective:', result['energy'] + offset)\nx = sample_most_likely(result['eigvecs'][0])\nprint('feasible:', tsp.tsp_feasible(x))\nz = tsp.get_tsp_solution(x)\nprint('solution:', z)\nprint('solution objective:', tsp.tsp_value(z, ins.w))\ndraw_tsp_solution(G, z, colors, pos)", "energy: -600035.5\ntsp objective: 71.0\nfeasible: True\nsolution: [0, 1, 2]\nsolution objective: 71.0\n" ] ], [ [ "### Running it on quantum computer\nWe run the optimization routine using a feedback loop with a quantum computer that uses trial functions built with Y single-qubit rotations, $U_\\mathrm{single}(\\theta) = \\prod_{i=1}^n Y(\\theta_{i})$, and entangler steps $U_\\mathrm{entangler}$.", "_____no_output_____" ] ], [ [ "seed = 10598\n\nspsa = SPSA(max_trials=300)\nry = RY(qubitOp.num_qubits, depth=5, entanglement='linear')\nvqe = VQE(qubitOp, ry, spsa)\n\nbackend = BasicAer.get_backend('statevector_simulator')\nquantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed)\n\nresult = vqe.run(quantum_instance)\n\nprint('energy:', result['energy'])\nprint('time:', result['eval_time'])\n#print('tsp objective:', result['energy'] + offset)\nx = sample_most_likely(result['eigvecs'][0])\nprint('feasible:', tsp.tsp_feasible(x))\nz = tsp.get_tsp_solution(x)\nprint('solution:', z)\nprint('solution objective:', tsp.tsp_value(z, ins.w))\ndraw_tsp_solution(G, z, colors, pos)", "energy: -595934.1907769153\ntime: 17.446267127990723\nfeasible: True\nsolution: [1, 2, 0]\nsolution objective: 71.0\n" ], [ "# run quantum algorithm with shots\n\nseed = 10598\n\nspsa = SPSA(max_trials=300)\nry = RY(qubitOp.num_qubits, depth=5, entanglement='linear')\nvqe = VQE(qubitOp, ry, spsa)\n\nbackend = BasicAer.get_backend('qasm_simulator')\nquantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=seed, seed_transpiler=seed)\n\nresult = vqe.run(quantum_instance)\n\nprint('energy:', result['energy'])\nprint('time:', result['eval_time'])\n#print('tsp objective:', result['energy'] + offset)\nx = sample_most_likely(result['eigvecs'][0])\nprint('feasible:', tsp.tsp_feasible(x))\nz = tsp.get_tsp_solution(x)\nprint('solution:', z)\nprint('solution objective:', tsp.tsp_value(z, ins.w))\nplot_histogram(result['eigvecs'][0])\ndraw_tsp_solution(G, z, colors, pos)", "_____no_output_____" ] ], [ [ "### [Optional] Checking that the full Hamiltonian made by ```docplex.get_operator``` gives the right cost", "_____no_output_____" ] ], [ [ "ee = ExactEigensolver(qubitOp_docplex, k=1)\nresult = ee.run()\n\nprint('energy:', result['energy'])\nprint('tsp objective:', result['energy'] + offset_docplex)\n\nx = sample_most_likely(result['eigvecs'][0])\nprint('feasible:', tsp.tsp_feasible(x))\nz = tsp.get_tsp_solution(x)\nprint('solution:', z)\nprint('solution objective:', tsp.tsp_value(z, ins.w))\ndraw_tsp_solution(G, z, colors, pos)", "_____no_output_____" ], [ "import qiskit.tools.jupyter\n%qiskit_version_table\n%qiskit_copyright", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "from ds import DoubledLinkedList\n\nclass Stack:\n def __init__(self):\n self.__list = DoubledLinkedList()\n def push(self , val):\n self.__list.add(val)\n def pop(self):\n self.pop.remove_last()\n def is_empty(self):\n pass\n def peek(self):\n pass\n\n", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "%matplotlib inline", "_____no_output_____" ] ], [ [ "**Read Later:**\n\nModule Documentation\n\nhttps://pytorch.org/docs/stable/generated/torch.nn.Module.html", "_____no_output_____" ], [ "\nA Gentle Introduction to ``torch.autograd``\n---------------------------------\n\n``torch.autograd`` is PyTorch’s automatic differentiation engine that powers\nneural network training. In this section, you will get a conceptual\nunderstanding of how autograd helps a neural network train.\n\nBackground\n~~~~~~~~~~\nNeural networks (NNs) are a collection of nested functions that are\nexecuted on some input data. These functions are defined by *parameters*\n(consisting of weights and biases), which in PyTorch are stored in\ntensors.\n\nTraining a NN happens in two steps:\n\n**Forward Propagation**: In forward prop, the NN makes its best guess\nabout the correct output. It runs the input data through each of its\nfunctions to make this guess.\n\n**Backward Propagation**: In backprop, the NN adjusts its parameters\nproportionate to the error in its guess. It does this by traversing\nbackwards from the output, collecting the derivatives of the error with\nrespect to the parameters of the functions (*gradients*), and optimizing\nthe parameters using gradient descent. For a more detailed walkthrough\nof backprop, check out this `video from\n3Blue1Brown <https://www.youtube.com/watch?v=tIeHLnjs5U8>`__.\n\n\n\n\nUsage in PyTorch\n~~~~~~~~~~~\nLet's take a look at a single training step.\nFor this example, we load a pretrained resnet18 model from ``torchvision``.\nWe create a random data tensor to represent a single image with 3 channels, and height & width of 64,\nand its corresponding ``label`` initialized to some random values.\n\n", "_____no_output_____" ] ], [ [ "import torch, torchvision\nmodel = torchvision.models.resnet18(pretrained=True)\ndata = torch.rand(1, 3, 64, 64)\nlabels = torch.rand(1, 1000)\nprint(data.size(),labels.size())", "torch.Size([1, 3, 64, 64]) torch.Size([1, 1000])\n" ] ], [ [ "Next, we run the input data through the model through each of its layers to make a prediction.\nThis is the **forward pass**.\n\n\n", "_____no_output_____" ] ], [ [ "prediction = model(data) # forward pass\nprint(prediction.size())", "torch.Size([1, 1000])\n" ] ], [ [ "We use the model's prediction and the corresponding label to calculate the error (``loss``).\nThe next step is to backpropagate this error through the network.\nBackward propagation is kicked off when we call ``.backward()`` on the error tensor.\nAutograd then calculates and stores the gradients for each model parameter in the parameter's ``.grad`` attribute.\n\n\n", "_____no_output_____" ] ], [ [ "loss = (prediction - labels).sum()\nloss.backward() # backward pass", "_____no_output_____" ] ], [ [ "Next, we load an optimizer, in this case SGD with a learning rate of 0.01 and momentum of 0.9.\nWe register all the parameters of the model in the optimizer.\n\nmodel.parameters() can acesss all model's parameters\n\n", "_____no_output_____" ] ], [ [ "optim = torch.optim.SGD(model.parameters(), lr=1e-2, momentum=0.9)", "_____no_output_____" ] ], [ [ "Finally, we call ``.step()`` to initiate gradient descent. The optimizer adjusts each parameter by its gradient stored in ``.grad``.\n\n\n", "_____no_output_____" ] ], [ [ "optim.step() #gradient descent", "_____no_output_____" ] ], [ [ "At this point, you have everything you need to train your neural network.\nThe below sections detail the workings of autograd - feel free to skip them.\n\n\n", "_____no_output_____" ], [ "--------------\n\n\n", "_____no_output_____" ], [ "Differentiation in Autograd\n~~~~~~~~~~~~~~~~~~~~~~~~~~~\nLet's take a look at how ``autograd`` collects gradients. We create two tensors ``a`` and ``b`` with\n``requires_grad=True``. This signals to ``autograd`` that every operation on them should be tracked.\n\n\n", "_____no_output_____" ] ], [ [ "import torch\n\na = torch.tensor([2., 3.], requires_grad=True)\nb = torch.tensor([6., 4.], requires_grad=True)", "_____no_output_____" ] ], [ [ "We create another tensor ``Q`` from ``a`` and ``b``.\n\n\\begin{align}Q = 3a^3 - b^2\\end{align}\n\n", "_____no_output_____" ] ], [ [ "Q = 3*a**3 - b**2\nprint(Q)", "tensor([-12., 65.], grad_fn=<SubBackward0>)\n" ] ], [ [ "Let's assume ``a`` and ``b`` to be parameters of an NN, and ``Q``\nto be the error. In NN training, we want gradients of the error\nw.r.t. parameters, i.e.\n\n\\begin{align}\\frac{\\partial Q}{\\partial a} = 9a^2\\end{align}\n\n\\begin{align}\\frac{\\partial Q}{\\partial b} = -2b\\end{align}\n\n\nWhen we call ``.backward()`` on ``Q``, autograd calculates these gradients\nand stores them in the respective tensors' ``.grad`` attribute.\n\nWe need to explicitly pass a ``gradient`` argument in ``Q.backward()`` because it is a vector.\n``gradient`` is a tensor of the same shape as ``Q``, and it represents the\ngradient of Q w.r.t. itself, i.e.\n\n\\begin{align}\\frac{dQ}{dQ} = 1\\end{align}\n\nEquivalently, we can also aggregate Q into a scalar and call backward implicitly, like ``Q.sum().backward()``.\n\n\n", "_____no_output_____" ] ], [ [ "external_grad = torch.tensor([1,1])\nQ.backward(gradient=external_grad)", "_____no_output_____" ] ], [ [ "Gradients are now deposited in ``a.grad`` and ``b.grad``\n\n", "_____no_output_____" ] ], [ [ "# check if collected gradients are correct\nprint(a.grad)\nprint(9*a**2)\nprint(9*a**2 == a.grad)\nprint(-2*b == b.grad)", "tensor([36., 81.])\ntensor([36., 81.], grad_fn=<MulBackward0>)\ntensor([True, True])\ntensor([True, True])\n" ] ], [ [ "Optional Reading - Vector Calculus using ``autograd``\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nMathematically, if you have a vector valued function\n$\\vec{y}=f(\\vec{x})$, then the gradient of $\\vec{y}$ with\nrespect to $\\vec{x}$ is a Jacobian matrix $J$:\n\n\\begin{align}J\n =\n \\left(\\begin{array}{cc}\n \\frac{\\partial \\bf{y}}{\\partial x_{1}} &\n ... &\n \\frac{\\partial \\bf{y}}{\\partial x_{n}}\n \\end{array}\\right)\n =\n \\left(\\begin{array}{ccc}\n \\frac{\\partial y_{1}}{\\partial x_{1}} & \\cdots & \\frac{\\partial y_{1}}{\\partial x_{n}}\\\\\n \\vdots & \\ddots & \\vdots\\\\\n \\frac{\\partial y_{m}}{\\partial x_{1}} & \\cdots & \\frac{\\partial y_{m}}{\\partial x_{n}}\n \\end{array}\\right)\\end{align}\n\nGenerally speaking, ``torch.autograd`` is an engine for computing\nvector-Jacobian product. That is, given any vector $\\vec{v}$, compute the product\n$J^{T}\\cdot \\vec{v}$\n\nIf $\\vec{v}$ happens to be the gradient of a scalar function $l=g\\left(\\vec{y}\\right)$:\n\n\\begin{align}\\vec{v}\n =\n \\left(\\begin{array}{ccc}\\frac{\\partial l}{\\partial y_{1}} & \\cdots & \\frac{\\partial l}{\\partial y_{m}}\\end{array}\\right)^{T}\\end{align}\n\nthen by the chain rule, the vector-Jacobian product would be the\ngradient of $l$ with respect to $\\vec{x}$:\n\n\\begin{align}J^{T}\\cdot \\vec{v}=\\left(\\begin{array}{ccc}\n \\frac{\\partial y_{1}}{\\partial x_{1}} & \\cdots & \\frac{\\partial y_{m}}{\\partial x_{1}}\\\\\n \\vdots & \\ddots & \\vdots\\\\\n \\frac{\\partial y_{1}}{\\partial x_{n}} & \\cdots & \\frac{\\partial y_{m}}{\\partial x_{n}}\n \\end{array}\\right)\\left(\\begin{array}{c}\n \\frac{\\partial l}{\\partial y_{1}}\\\\\n \\vdots\\\\\n \\frac{\\partial l}{\\partial y_{m}}\n \\end{array}\\right)=\\left(\\begin{array}{c}\n \\frac{\\partial l}{\\partial x_{1}}\\\\\n \\vdots\\\\\n \\frac{\\partial l}{\\partial x_{n}}\n \\end{array}\\right)\\end{align}\n\nThis characteristic of vector-Jacobian product is what we use in the above example;\n``external_grad`` represents $\\vec{v}$.\n\n\n", "_____no_output_____" ], [ "Computational Graph\n~~~~~~~~~~~~~~~~~~~\n\nConceptually, autograd keeps a record of data (tensors) & all executed\noperations (along with the resulting new tensors) in a directed acyclic\ngraph (DAG) consisting of\n`Function <https://pytorch.org/docs/stable/autograd.html#torch.autograd.Function>`__\nobjects. In this DAG, leaves are the input tensors, roots are the output\ntensors. By tracing this graph from roots to leaves, you can\nautomatically compute the gradients using the chain rule.\n\nIn a forward pass, autograd does two things simultaneously:\n\n- run the requested operation to compute a resulting tensor, and\n- maintain the operation’s *gradient function* in the DAG.\n\nThe backward pass kicks off when ``.backward()`` is called on the DAG\nroot. ``autograd`` then:\n\n- computes the gradients from each ``.grad_fn``,\n- accumulates them in the respective tensor’s ``.grad`` attribute, and\n- using the chain rule, propagates all the way to the leaf tensors.\n\nBelow is a visual representation of the DAG in our example. In the graph,\nthe arrows are in the direction of the forward pass. The nodes represent the backward functions\nof each operation in the forward pass. The leaf nodes in blue represent our leaf tensors ``a`` and ``b``.\n\n.. figure:: /_static/img/dag_autograd.png\n\n<div class=\"alert alert-info\"><h4>Note</h4><p>**DAGs are dynamic in PyTorch**\n An important thing to note is that the graph is recreated from scratch; after each\n ``.backward()`` call, autograd starts populating a new graph. This is\n exactly what allows you to use control flow statements in your model;\n you can change the shape, size and operations at every iteration if\n needed.</p></div>\n\nExclusion from the DAG\n^^^^^^^^^^^^^^^^^^^^^^\n\n``torch.autograd`` tracks operations on all tensors which have their\n``requires_grad`` flag set to ``True``. For tensors that don’t require\ngradients, setting this attribute to ``False`` excludes it from the\ngradient computation DAG.\n\nThe output tensor of an operation will require gradients even if only a\nsingle input tensor has ``requires_grad=True``.\n\n\n", "_____no_output_____" ] ], [ [ "x = torch.rand(5, 5)\ny = torch.rand(5, 5)\nz = torch.rand((5, 5), requires_grad=True)\n\na = x + y\nprint(f\"Does `a` require gradients? : {a.requires_grad}\")\nb = x + z\nprint(f\"Does `b` require gradients?: {b.requires_grad}\")", "_____no_output_____" ] ], [ [ "In a NN, parameters that don't compute gradients are usually called **frozen parameters**.\nIt is useful to \"freeze\" part of your model if you know in advance that you won't need the gradients of those parameters\n(this offers some performance benefits by reducing autograd computations).\n\nAnother common usecase where exclusion from the DAG is important is for\n`finetuning a pretrained network <https://pytorch.org/tutorials/beginner/finetuning_torchvision_models_tutorial.html>`__\n\nIn finetuning, we freeze most of the model and typically only modify the classifier layers to make predictions on new labels.\nLet's walk through a small example to demonstrate this. As before, we load a pretrained resnet18 model, and freeze all the parameters.\n\n", "_____no_output_____" ] ], [ [ "from torch import nn, optim\n\nmodel = torchvision.models.resnet18(pretrained=True)\n\n# Freeze all the parameters in the network\nfor param in model.parameters():\n param.requires_grad = False", "_____no_output_____" ] ], [ [ "Let's say we want to finetune the model on a new dataset with 10 labels.\nIn resnet, the classifier is the last linear layer ``model.fc``.\nWe can simply replace it with a new linear layer (unfrozen by default)\nthat acts as our classifier.\n\n", "_____no_output_____" ] ], [ [ "model.fc = nn.Linear(512, 10)", "_____no_output_____" ] ], [ [ "Now all parameters in the model, except the parameters of ``model.fc``, are frozen.\nThe only parameters that compute gradients are the weights and bias of ``model.fc``.\n\n", "_____no_output_____" ] ], [ [ "# Optimize only the classifier\noptimizer = optim.SGD(model.parameters(), lr=1e-2, momentum=0.9)", "_____no_output_____" ] ], [ [ "Notice although we register all the parameters in the optimizer,\nthe only parameters that are computing gradients (and hence updated in gradient descent)\nare the weights and bias of the classifier.\n\nThe same exclusionary functionality is available as a context manager in\n`torch.no_grad() <https://pytorch.org/docs/stable/generated/torch.no_grad.html>`__\n\n\n", "_____no_output_____" ], [ "--------------\n\n\n", "_____no_output_____" ], [ "Further readings:\n~~~~~~~~~~~~~~~~~~~\n\n- `In-place operations & Multithreaded Autograd <https://pytorch.org/docs/stable/notes/autograd.html>`__\n- `Example implementation of reverse-mode autodiff <https://colab.research.google.com/drive/1VpeE6UvEPRz9HmsHh1KS0XxXjYu533EC>`__\n\n", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Thai2Vec Classification Using ULMFit\n\nThis notebook demonstrates how to use the [ULMFit model](https://arxiv.org/abs/1801.06146) implemented by`thai2vec` for text classification. We use [Wongnai Challenge: Review Rating Prediction](https://www.kaggle.com/c/wongnai-challenge-review-rating-prediction) as our benchmark as it is the only sizeable and publicly available text classification dataset at the time of writing (June 21, 2018). It has 39,999 reviews for training and validation, and 6,203 reviews for testing. Our workflow is as follows:\n\n* Perform 75/15 train-validation split\n* Minimal text cleaning and tokenization using `newmm` engine of `pyThaiNLP`\n* Get embeddings of Wongnai dataset from all the data available (train and test sets)\n* Load pretrained Thai Wikipedia embeddings; for those embeddings which exist only in Wongnai dataset, we use the average of Wikipedia embeddings instead\n* Train language model based on all the data available on Wongnai dataset\n* Replace the top and train the classifier based on the training set by gradual unfreezing\n\nWe achieved validation perplexity at 35.75113 and validation micro F1 score at 0.598 for five-label classification. Micro F1 scores for public and private leaderboards are 0.61451 and 0.60925 respectively (supposedly we could train further with the 15% validation set we did not use), which are state-of-the-art as of the time of writing (June 21, 2018). FastText benchmark has the performance of 0.50483 and 0.49366 for public and private leaderboards respectively.", "_____no_output_____" ], [ "![alt text](../wongnai_data/misc/submission.jpg \"Submission\")", "_____no_output_____" ], [ "![alt text](../wongnai_data/misc/leaderboard.jpg \"Leaderboards\")", "_____no_output_____" ], [ "## Imports", "_____no_output_____" ] ], [ [ "%reload_ext autoreload\n%autoreload 2\n%matplotlib inline\n\nimport re\nimport html\nimport numpy as np\nimport dill as pickle\nfrom IPython.display import Image\nfrom IPython.core.display import HTML \nfrom collections import Counter\nfrom sklearn.model_selection import train_test_split\n\nfrom fastai.text import *\nfrom pythainlp.tokenize import word_tokenize\nfrom utils import *\n\n\nDATA_PATH='/home/ubuntu/Projects/new2vec/wongnai_data/'\nRAW_PATH = f'{DATA_PATH}raw/'\nMODEL_PATH = f'{DATA_PATH}models/'\n\nraw_files = !ls {RAW_PATH}", "_____no_output_____" ] ], [ [ "## Train/Validation Sets\n\nWe use data from [Wongnai Challenge: Review Rating Prediction](https://www.kaggle.com/c/wongnai-challenge-review-rating-prediction). The training data consists of 39,999 restaurant reviews from unknown number of reviewers labeled one to five stars, with the schema `(label,review)`. We use 75/15 train-validation split. The test set has 6,203 reviews from the same number of reviewers. No information accuracy is 46.9%.", "_____no_output_____" ] ], [ [ "raw_train = pd.read_csv(f'{RAW_PATH}w_review_train.csv',sep=';',header=None)\nraw_train = raw_train.iloc[:,[1,0]]\nraw_train.columns = ['label','review']\nraw_test = pd.read_csv(f'{RAW_PATH}test_file.csv',sep=';')\nsubmission = pd.read_csv(f'{RAW_PATH}sample_submission.csv',sep=',')", "_____no_output_____" ], [ "print(raw_train.shape)\nraw_train.head()", "(40000, 2)\n" ], [ "cnt = Counter(raw_train['label'])\ncnt", "_____no_output_____" ], [ "#baseline\ncnt.most_common(1)[0][1] / raw_train.shape[0]", "_____no_output_____" ], [ "raw_test.head()", "_____no_output_____" ], [ "submission.head()", "_____no_output_____" ], [ "#test df\nraw_test = pd.read_csv(f'{RAW_PATH}test_file.csv',sep=';')\nraw_test.head()\ndf_tst = pd.DataFrame({'label':raw_test['reviewID'],'review':raw_test['review']})\ndf_tst.to_csv(f'{DATA_PATH}test.csv', header=False, index=False)", "_____no_output_____" ], [ "#train/validation/train_language_model split\ndf_trn, df_val = train_test_split(raw_train, test_size = 0.15, random_state = 1412)\ndf_lm = pd.concat([df_trn,df_tst])\n\ndf_lm.to_csv(f'{DATA_PATH}train_lm.csv', header=False, index=False)\ndf_trn.to_csv(f'{DATA_PATH}train.csv', header=False, index=False)\ndf_val.to_csv(f'{DATA_PATH}valid.csv', header=False, index=False)", "_____no_output_____" ], [ "df_trn.shape,df_val.shape,df_lm.shape", "_____no_output_____" ] ], [ [ "## Language Modeling", "_____no_output_____" ], [ "### Text Processing", "_____no_output_____" ], [ "We first determine the vocab for the reviews, then train a language model based on our training set. We perform the following minimal text processing:\n* The token `xbos` is used to note start of a text since we will be chaining them together for the language model training. \n* `pyThaiNLP`'s `newmm` word tokenizer is used to tokenize the texts.\n* `tkrep` is used to replace repetitive characters such as `อร่อยมากกกกกก` becoming `อรอ่ยมาtkrep6ก`", "_____no_output_____" ] ], [ [ "max_vocab = 60000\nmin_freq = 2\n\ndf_lm = pd.read_csv(f'{DATA_PATH}train_lm.csv',header=None,chunksize=30000)\ndf_val = pd.read_csv(f'{DATA_PATH}valid.csv',header=None,chunksize=30000)\n\ntrn_lm,trn_tok,trn_labels,itos_cls,stoi_cls,freq_trn = numericalizer(df_trn)\nval_lm,val_tok,val_labels,itos_cls,stoi_cls,freq_val = numericalizer(df_val,itos_cls)", "_____no_output_____" ], [ "# np.save(f'{MODEL_PATH}trn_tok.npy', trn_tok)\n# np.save(f'{MODEL_PATH}val_tok.npy', val_tok)\n# np.save(f'{MODEL_PATH}trn_lm.npy', trn_lm)\n# np.save(f'{MODEL_PATH}val_lm.npy', val_lm)\n# pickle.dump(itos_cls, open(f'{MODEL_PATH}itos_cls.pkl', 'wb'))", "_____no_output_____" ], [ "tok_lm = np.load(f'{MODEL_PATH}tok_lm.npy')\ntok_val = np.load(f'{MODEL_PATH}tok_val.npy')", "_____no_output_____" ], [ "tok_lm[:1]", "_____no_output_____" ], [ "#numericalized tokenized texts\ntrn_lm[:1]", "_____no_output_____" ], [ "#index to token\nitos_cls[:10]", "_____no_output_____" ] ], [ [ "### Load Pretrained Language Model", "_____no_output_____" ], [ "Instead of starting from random weights, we import the language model pretrained on Wikipedia (see `pretrained_wiki.ipynb`). For words that appear only in the Wongnai dataset but not Wikipedia, we start with the average of all embeddings instead. Max vocab size is set at 60,000 and minimum frequency of 2 consistent with the pretrained model. We ended up with 19,998 embeddings for all reviews.", "_____no_output_____" ] ], [ [ "em_sz = 300\nvocab_size = len(itos_cls)\nwgts = torch.load(f'{MODEL_PATH}thwiki_model2.h5', map_location=lambda storage, loc: storage)\nitos_pre = pickle.load(open(f'{MODEL_PATH}itos_pre.pkl','rb'))\nstoi_pre = collections.defaultdict(lambda:-1, {v:k for k,v in enumerate(itos_pre)})", "_____no_output_____" ], [ "#pretrained weights\nwgts = merge_wgts(em_sz, wgts, itos_pre, itos_cls)", "_____no_output_____" ] ], [ [ "### Train Language Model", "_____no_output_____" ] ], [ [ "em_sz,nh,nl = 300,1150,3\nwd=1e-7\nbptt=70\nbs=60\nopt_fn = partial(optim.Adam, betas=(0.8, 0.99))\nweight_factor = 0.7\ndrops = np.array([0.25, 0.1, 0.2, 0.02, 0.15])*weight_factor", "_____no_output_____" ], [ "#data loader\ntrn_dl = LanguageModelLoader(np.concatenate(trn_lm), bs, bptt)\nval_dl = LanguageModelLoader(np.concatenate(val_lm), bs, bptt)\nmd = LanguageModelData(path=DATA_PATH, pad_idx=1, n_tok=vocab_size, \n trn_dl=trn_dl, val_dl=val_dl, bs=bs, bptt=bptt)", "_____no_output_____" ], [ "#model fitter\nlearner= md.get_model(opt_fn, em_sz, nh, nl, \n dropouti=drops[0], dropout=drops[1], wdrop=drops[2], dropoute=drops[3], dropouth=drops[4])\nlearner.metrics = [accuracy]", "_____no_output_____" ], [ "#load the saved models + new embeddings\nlearner.model.load_state_dict(wgts)", "_____no_output_____" ], [ "#find optimal learning rate\nlearner.lr_find2(start_lr = 1e-6, end_lr=0.1)\nlearner.sched.plot()", "_____no_output_____" ], [ "#optimal learning rate\nlr=3e-3\nlr", "_____no_output_____" ], [ "#train while frozen once to warm up\nlearner.freeze_to(-1)\nlearner.fit(lr, 1, wds=wd, use_clr=(20,5), cycle_len=1)", "_____no_output_____" ], [ "#use_clr (peak as ratio of lr, iterations to grow and descend e.g. 10 is 1/10 grow and 9/10 descend)\nlearner.unfreeze()\nlearner.fit(lr, 1, wds=wd, use_clr=(20,5), cycle_len=5)", "_____no_output_____" ], [ "learner.sched.plot_loss()", "_____no_output_____" ], [ "learner.save('wongnai_lm')\nlearner.save_encoder('wongnai_enc')", "_____no_output_____" ] ], [ [ "## Classification", "_____no_output_____" ], [ "With the language model trained on Wongnai dataset, we use its embeddings to initialize the review classifier. We train the classifier using discriminative learning rates, slanted triangular learning rates, gradual unfreezing and a few other tricks detailed in the [ULMFit paper](https://arxiv.org/abs/1801.06146). We have found that training only the last two layers of the model seems to be the right balance for this dataset.", "_____no_output_____" ], [ "### Load Tokenized Texts and Labels", "_____no_output_____" ] ], [ [ "#load csvs and tokenizer\nmax_vocab = 60000\nmin_freq = 2\ndf_trn = pd.read_csv(f'{DATA_PATH}train.csv',header=None,chunksize=30000)\ndf_val = pd.read_csv(f'{DATA_PATH}valid.csv',header=None,chunksize=30000)\ndf_tst = pd.read_csv(f'{DATA_PATH}test.csv',header=None,chunksize=30000)\n\ntrn_cls,trn_tok,trn_labels,itos_cls,stoi_cls,freq = numericalizer(df_trn)\nval_cls,val_tok,val_labels,itos_cls,stoi_cls,freq = numericalizer(df_val,itos_cls)\ntst_cls,tst_tok,tst_labels,itos_cls,stoi_cls,freq = numericalizer(df_tst,itos_cls)", "_____no_output_____" ], [ "#get labels\ntrn_labels = np.squeeze(trn_labels)\nval_labels = np.squeeze(val_labels)\ntst_labels = np.squeeze(tst_labels)\nmin_lbl = trn_labels.min()\ntrn_labels -= min_lbl\nval_labels -= min_lbl", "_____no_output_____" ] ], [ [ "### Create Data Loader", "_____no_output_____" ] ], [ [ "#dataset object\nbs = 60\ntrn_ds = TextDataset(trn_cls, trn_labels)\nval_ds = TextDataset(val_cls, val_labels)\ntst_ds = TextDataset(tst_cls, tst_labels)\n\n#sampler\ntrn_samp = SortishSampler(trn_cls, key=lambda x: len(trn_cls[x]), bs=bs//2)\nval_samp = SortSampler(val_cls, key=lambda x: len(val_cls[x]))\ntst_samp = SortSampler(tst_cls, key=lambda x: len(tst_cls[x]))\n\n#data loader\ntrn_dl = DataLoader(trn_ds, bs//2, transpose=True, num_workers=1, pad_idx=1, sampler=trn_samp)\nval_dl = DataLoader(val_ds, bs, transpose=True, num_workers=1, pad_idx=1, sampler=val_samp)\ntst_dl = DataLoader(tst_ds, bs, transpose=True, num_workers=1, pad_idx=1, sampler=tst_samp)\nmd = ModelData(DATA_PATH, trn_dl, val_dl, tst_dl)", "_____no_output_____" ] ], [ [ "### Train Classifier", "_____no_output_____" ] ], [ [ "#parameters\nweight_factor = 0.5\ndrops = np.array([0.25, 0.1, 0.2, 0.02, 0.15])*weight_factor\nbptt = 70\nem_sz = 300\nnh = 1150\nnl = 3\nvocab_size = len(itos_cls)\nnb_class=int(trn_labels.max())+1\nopt_fn = partial(optim.Adam, betas=(0.7, 0.99))\nbs = 60\nwd = 1e-7\n\n#classifier model\n# em_sz*3 for max, mean, just activations\nm = get_rnn_classifer(bptt, max_seq=1000, n_class=nb_class, \n n_tok=vocab_size, emb_sz=em_sz, n_hid=nh, n_layers=nl, pad_token=1,\n layers=[em_sz*3, 50, nb_class], drops=[drops[4], 0.1],\n dropouti=drops[0], wdrop=drops[1], dropoute=drops[2], dropouth=drops[3])", "_____no_output_____" ], [ "#get learner\nlearner = RNN_Learner(md, TextModel(to_gpu(m)), opt_fn=opt_fn)\nlearner.reg_fn = partial(seq2seq_reg, alpha=2, beta=1)\nlearner.clip=25.\nlearner.metrics = [accuracy]\n#load encoder trained earlier\nlearner.load_encoder('wongnai_enc')", "_____no_output_____" ], [ "#find learning rate\nlearner.lr_find2()\nlearner.sched.plot()", "_____no_output_____" ], [ "#set learning rate\nlr=1e-2\nlrm = 2.6\nlrs = np.array([lr/(lrm**4), lr/(lrm**3), lr/(lrm**2), lr/lrm, lr])", "_____no_output_____" ], [ "#train last layer\nlearner.freeze_to(-1)\nlearner.fit(lrs, 1, wds=wd, cycle_len=10, use_clr=(10,10))\nlearner.save('last_layer')", "_____no_output_____" ], [ "#train last two layers\nlearner.load('last_layer')\nlearner.freeze_to(-2)\nlearner.fit(lrs, 1, wds=wd, cycle_len=3, use_clr=(8,3))\nlearner.save('last_two_layers')", "_____no_output_____" ] ], [ [ "## Validation Performance", "_____no_output_____" ] ], [ [ "learner.load('last_two_layers')\n#get validation performance\nprobs,y= learner.predict_with_targs()\npreds = np.argmax(np.exp(probs),1)", "_____no_output_____" ], [ "Counter(preds)", "_____no_output_____" ], [ "Counter(y)", "_____no_output_____" ], [ "from sklearn.metrics import confusion_matrix\nfrom sklearn.metrics import fbeta_score\n\nmost_frequent = np.array([4]*len(preds))\nprint(f'Baseline Micro F1: {fbeta_score(y,most_frequent,1,average=\"micro\")}')\nprint(f'Micro F1: {fbeta_score(y,preds,1,average=\"micro\")}')\ncm = confusion_matrix(y,preds)\nplot_confusion_matrix(cm,classes=[1,2,3,4,5])", "Baseline Micro F1: 0.176\nMicro F1: 0.5976666666666667\nConfusion matrix, without normalization\n[[ 14 36 13 1 1]\n [ 13 80 150 22 2]\n [ 5 36 945 814 28]\n [ 0 0 344 2210 230]\n [ 0 1 22 696 337]]\n" ] ], [ [ "## Submission", "_____no_output_____" ] ], [ [ "probs,y= learner.predict_with_targs(is_test=True)", "_____no_output_____" ], [ "preds = np.argmax(np.exp(probs),1) + 1", "_____no_output_____" ], [ "Counter(preds)", "_____no_output_____" ], [ "submit_df = pd.DataFrame({'a':y,'b':preds})\nsubmit_df.columns = ['reviewID','rating']\nsubmit_df.head()", "_____no_output_____" ], [ "submit_df.to_csv(f'{DATA_PATH}valid10_2layers_newmm.csv',index=False)", "_____no_output_____" ] ], [ [ "## Benchmark with FastText", "_____no_output_____" ], [ "We used [fastText](https://github.com/facebookresearch/fastText)'s own [pretrained embeddings](https://github.com/facebookresearch/fastText/blob/master/pretrained-vectors.md) and a relatively \"default\" settings in order to benchmark our results. This gave us the micro-averaged F1 score of 0.50483 and 0.49366 for the public and private leaderboard respectively.", "_____no_output_____" ], [ "![alt text](../wongnai_data/misc/fasttext.jpg \"fastText\")", "_____no_output_____" ], [ "### Data Preparation", "_____no_output_____" ] ], [ [ "df_trn = pd.read_csv(f'{DATA_PATH}train.csv',header=None)\ndf_val = pd.read_csv(f'{DATA_PATH}valid.csv',header=None)\ndf_tst = pd.read_csv(f'{DATA_PATH}test.csv', header=None)", "_____no_output_____" ], [ "train_set = []\nfor i in range(df_trn.shape[0]):\n label = df_trn.iloc[i,0]\n line = df_trn.iloc[i,1].replace('\\n', ' ')\n train_set.append(f'__label__{label} {line}')\ntrain_doc = '\\n'.join(train_set)\nwith open(f'{DATA_PATH}train.txt','w') as f:\n f.write(train_doc)", "_____no_output_____" ], [ "valid_set = []\nfor i in range(df_val.shape[0]):\n label = df_val.iloc[i,0]\n line = df_val.iloc[i,1].replace('\\n', ' ')\n valid_set.append(f'__label__{label} {line}')\nvalid_doc = '\\n'.join(valid_set)\nwith open(f'{DATA_PATH}valid.txt','w') as f:\n f.write(valid_doc)", "_____no_output_____" ], [ "test_set = []\nfor i in range(df_tst.shape[0]):\n label = df_tst.iloc[i,0]\n line = df_tst.iloc[i,1].replace('\\n', ' ')\n test_set.append(f'__label__{label} {line}')\ntest_doc = '\\n'.join(test_set)\nwith open(f'{DATA_PATH}test.txt','w') as f:\n f.write(test_doc)", "_____no_output_____" ] ], [ [ "### Train FastText", "_____no_output_____" ] ], [ [ "!/home/ubuntu/theFastText/fastText-0.1.0/fasttext supervised -input '{DATA_PATH}train.txt' -pretrainedVectors '{MODEL_PATH}wiki.th.vec' -epoch 10 -dim 300 -wordNgrams 2 -output '{MODEL_PATH}fasttext_model'", "Read 1M words\nNumber of words: 629560\nNumber of labels: 5\nProgress: 100.0% words/sec/thread: 524361 lr: 0.000000 loss: 0.612446 eta: 0h0m \n" ], [ "!/home/ubuntu/theFastText/fastText-0.1.0/fasttext test '{MODEL_PATH}fasttext_model.bin' '{DATA_PATH}valid.txt'", "N\t6000\nP@1\t0.473\nR@1\t0.473\nNumber of examples: 6000\n" ], [ "preds = !/home/ubuntu/theFastText/fastText-0.1.0/fasttext predict '{MODEL_PATH}fasttext_model.bin' '{DATA_PATH}test.txt'", "_____no_output_____" ] ], [ [ "### Submission", "_____no_output_____" ] ], [ [ "submit_df = pd.DataFrame({'a':[i+1 for i in range(len(preds))],'b':preds})\nsubmit_df.columns = ['reviewID','rating']\nsubmit_df['rating'] = submit_df['rating'].apply(lambda x: x.split('__')[2])\nsubmit_df.head()", "_____no_output_____" ], [ "submit_df.to_csv(f'{DATA_PATH}fasttext.csv',index=False)", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown", "markdown", "markdown" ], [ "code", "code", "code", "code", "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ], [ "markdown", "markdown", "markdown", "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import glob\nimport pandas as pd\nimport seaborn as sns\nimport matplotlib.pyplot as plt", "_____no_output_____" ], [ "extend_df = pd.read_csv('/home/jupyter-zyh/Gnhe/analysis_profile/global_setting/Linear/Texas/profile-1/all.csv')\nextend_df = extend_df.query(\"trial == 'simulated'\")\nextend_df['centroid'] = False\nextend_df_c = extend_df.copy()\nextend_df['centroid'] = True", "_____no_output_____" ], [ "df = pd.read_csv('/home/jupyter-zyh/Gnhe/analysis_setting/centroid/Linear/all.csv')\ndf = df.append(extend_df).append(extend_df_c)\ndf.to_csv('/home/jupyter-zyh/Gnhe/analysis_setting/centroid/Linear/merged.csv')", "_____no_output_____" ], [ "sns.catplot(data=df,col='method',row='trial',row_order=['hourly','simulated','combined'],x='ncluster',y='mae_ex_tc',hue='centroid',kind='box')", "_____no_output_____" ], [ "query_string = \"method == 'single' and trial == 'combined'\"\np = sns.boxplot(data=df.query(query_string),x='ncluster',y='mae_ex_tc',hue='centroid',palette='coolwarm')\nplt.title('Mae under different centroid setting',pad=18,fontdict={'size':14})\nplt.text(s=query_string.replace(\"'\",\"\").replace(\"==\",\"=\").replace(\"and\",\"&\"),x=2.25,y=0.49,color='#c04851')\nplt.xlabel('Number of representative weeks',fontdict={'size':14})\nplt.xticks([0,1,2,3,4,5],['5','10','15','20','25','30'])\nplt.ylabel('Mean absolute error',fontdict={'size':14})\nplt.legend(title='centroid',loc='upper right')", "_____no_output_____" ], [ "p.get_figure().savefig(\n '/home/jupyter-zyh/Gnhe/analysis/images/setting/centroid/mae_under_different_centroid_setting.png',\n dpi=300)", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "########################################################################################################################\n# Filename: Generate_ANN_Results.ipynb\n#\n# Purpose: Generate results from different ANN models trained on paragraph \n# classification task\n#\n# Author(s): Bobby (Robert) Lumpkin\n#\n# Library Dependencies: numpy, pandas, tensorflow, bpmll, os, json, ast, random, \n# tensorflow_addons, skljson, sklearn, sys, threshold_learning\n########################################################################################################################", "_____no_output_____" ] ], [ [ "# Generate and Save Results from Different ANN Methods", "_____no_output_____" ] ], [ [ "import numpy as np\nimport pandas as pd\nimport os\nimport json\nimport ast\nimport random\nimport tensorflow as tf\nimport tensorflow_addons as tfa\nfrom bpmll import bp_mll_loss\nimport sklearn_json as skljson\nfrom sklearn.model_selection import train_test_split\nfrom sklearn import metrics\nimport sys\nos.chdir('C:\\\\Users\\\\rober\\\\OneDrive\\\\Documents\\\\STAT 6500\\\\Project\\\\NewsArticleClassification\\\\codes\\\\ANN Results') ## Set working directory\n ## to be 'ANN Results'\nsys.path.append('../ThresholdFunctionLearning') ## Append path to the ThresholdFunctionLearning directory to the interpreters\n ## search path\nfrom threshold_learning import predict_test_labels_binary ## Import the 'predict_test_labels_binary()' function from the \nfrom threshold_learning import predict_labels_binary ## threshold_learning library", "_____no_output_____" ] ], [ [ "## Models on Reduced Dataset (each instance has atleast one label)", "_____no_output_____" ] ], [ [ "## Load the reduced tfidf dataset\nfile_object = open('../BP-MLL Text Categorization/tfidf_trainTest_data_reduced.json',)\ntfidf_data_reduced = json.load(file_object)\nX_train_hasLabel = np.array(tfidf_data_reduced['X_train_hasLabel'])\nX_test_hasLabel = np.array(tfidf_data_reduced['X_test_hasLabel'])\nY_train_hasLabel = np.array(tfidf_data_reduced['Y_train_hasLabel'])\nY_test_hasLabel = np.array(tfidf_data_reduced['Y_test_hasLabel'])", "_____no_output_____" ] ], [ [ "### Feed-Forward Cross-Entropy Network", "_____no_output_____" ] ], [ [ "## Start by defining and compiling the cross-entropy loss network (bpmll used later)\ntf.random.set_seed(123)\nnum_labels = 13\n\nmodel_ce_FF = tf.keras.models.Sequential([\n tf.keras.layers.Dense(32, activation = 'relu'),\n tf.keras.layers.Dropout(0.5),\n tf.keras.layers.Dense(num_labels, activation = 'sigmoid')\n])\n\noptim_func = tf.keras.optimizers.Adam(lr=0.0001)\n\nmetric = tfa.metrics.HammingLoss(mode = 'multilabel', threshold = 0.5)\n\nmodel_ce_FF.compile(optimizer = optim_func,\n loss = 'binary_crossentropy', metrics = metric\n )", "_____no_output_____" ], [ "tf.random.set_seed(123)\nhistory_ce_FF_lr001 = model_ce_FF.fit(X_train_hasLabel, Y_train_hasLabel, epochs = 100,\n validation_data = (X_test_hasLabel, Y_test_hasLabel), verbose=2)", "Epoch 1/100\n6/6 - 1s - loss: 0.7028 - hamming_loss: 0.4847 - val_loss: 0.6898 - val_hamming_loss: 0.4650\nEpoch 2/100\n6/6 - 0s - loss: 0.6970 - hamming_loss: 0.4742 - val_loss: 0.6878 - val_hamming_loss: 0.4572\nEpoch 3/100\n6/6 - 0s - loss: 0.6969 - hamming_loss: 0.4764 - val_loss: 0.6858 - val_hamming_loss: 0.4484\nEpoch 4/100\n6/6 - 0s - loss: 0.6936 - hamming_loss: 0.4642 - val_loss: 0.6838 - val_hamming_loss: 0.4414\nEpoch 5/100\n6/6 - 0s - loss: 0.6903 - hamming_loss: 0.4572 - val_loss: 0.6818 - val_hamming_loss: 0.4318\nEpoch 6/100\n6/6 - 0s - loss: 0.6836 - hamming_loss: 0.4489 - val_loss: 0.6799 - val_hamming_loss: 0.4274\nEpoch 7/100\n6/6 - 0s - loss: 0.6821 - hamming_loss: 0.4414 - val_loss: 0.6780 - val_hamming_loss: 0.4248\nEpoch 8/100\n6/6 - 0s - loss: 0.6825 - hamming_loss: 0.4427 - val_loss: 0.6761 - val_hamming_loss: 0.4205\nEpoch 9/100\n6/6 - 0s - loss: 0.6757 - hamming_loss: 0.4135 - val_loss: 0.6743 - val_hamming_loss: 0.4152\nEpoch 10/100\n6/6 - 0s - loss: 0.6670 - hamming_loss: 0.4091 - val_loss: 0.6724 - val_hamming_loss: 0.4082\nEpoch 11/100\n6/6 - 0s - loss: 0.6709 - hamming_loss: 0.4087 - val_loss: 0.6705 - val_hamming_loss: 0.4012\nEpoch 12/100\n6/6 - 0s - loss: 0.6657 - hamming_loss: 0.4126 - val_loss: 0.6686 - val_hamming_loss: 0.3942\nEpoch 13/100\n6/6 - 0s - loss: 0.6648 - hamming_loss: 0.3964 - val_loss: 0.6668 - val_hamming_loss: 0.3837\nEpoch 14/100\n6/6 - 0s - loss: 0.6559 - hamming_loss: 0.3776 - val_loss: 0.6649 - val_hamming_loss: 0.3794\nEpoch 15/100\n6/6 - 0s - loss: 0.6587 - hamming_loss: 0.3811 - val_loss: 0.6630 - val_hamming_loss: 0.3706\nEpoch 16/100\n6/6 - 0s - loss: 0.6551 - hamming_loss: 0.3767 - val_loss: 0.6611 - val_hamming_loss: 0.3654\nEpoch 17/100\n6/6 - 0s - loss: 0.6499 - hamming_loss: 0.3741 - val_loss: 0.6592 - val_hamming_loss: 0.3566\nEpoch 18/100\n6/6 - 0s - loss: 0.6474 - hamming_loss: 0.3580 - val_loss: 0.6573 - val_hamming_loss: 0.3523\nEpoch 19/100\n6/6 - 0s - loss: 0.6433 - hamming_loss: 0.3510 - val_loss: 0.6554 - val_hamming_loss: 0.3453\nEpoch 20/100\n6/6 - 0s - loss: 0.6441 - hamming_loss: 0.3501 - val_loss: 0.6535 - val_hamming_loss: 0.3392\nEpoch 21/100\n6/6 - 0s - loss: 0.6385 - hamming_loss: 0.3448 - val_loss: 0.6516 - val_hamming_loss: 0.3313\nEpoch 22/100\n6/6 - 0s - loss: 0.6348 - hamming_loss: 0.3326 - val_loss: 0.6497 - val_hamming_loss: 0.3260\nEpoch 23/100\n6/6 - 0s - loss: 0.6361 - hamming_loss: 0.3339 - val_loss: 0.6478 - val_hamming_loss: 0.3156\nEpoch 24/100\n6/6 - 0s - loss: 0.6341 - hamming_loss: 0.3352 - val_loss: 0.6459 - val_hamming_loss: 0.3138\nEpoch 25/100\n6/6 - 0s - loss: 0.6297 - hamming_loss: 0.3269 - val_loss: 0.6440 - val_hamming_loss: 0.3086\nEpoch 26/100\n6/6 - 0s - loss: 0.6267 - hamming_loss: 0.3147 - val_loss: 0.6420 - val_hamming_loss: 0.3033\nEpoch 27/100\n6/6 - 0s - loss: 0.6171 - hamming_loss: 0.3090 - val_loss: 0.6400 - val_hamming_loss: 0.2972\nEpoch 28/100\n6/6 - 0s - loss: 0.6220 - hamming_loss: 0.3204 - val_loss: 0.6380 - val_hamming_loss: 0.2955\nEpoch 29/100\n6/6 - 0s - loss: 0.6199 - hamming_loss: 0.3164 - val_loss: 0.6359 - val_hamming_loss: 0.2928\nEpoch 30/100\n6/6 - 0s - loss: 0.6075 - hamming_loss: 0.2858 - val_loss: 0.6339 - val_hamming_loss: 0.2885\nEpoch 31/100\n6/6 - 0s - loss: 0.6019 - hamming_loss: 0.2976 - val_loss: 0.6317 - val_hamming_loss: 0.2841\nEpoch 32/100\n6/6 - 0s - loss: 0.6088 - hamming_loss: 0.3073 - val_loss: 0.6295 - val_hamming_loss: 0.2815\nEpoch 33/100\n6/6 - 0s - loss: 0.6038 - hamming_loss: 0.2911 - val_loss: 0.6274 - val_hamming_loss: 0.2797\nEpoch 34/100\n6/6 - 0s - loss: 0.5995 - hamming_loss: 0.2832 - val_loss: 0.6252 - val_hamming_loss: 0.2788\nEpoch 35/100\n6/6 - 0s - loss: 0.5993 - hamming_loss: 0.2885 - val_loss: 0.6231 - val_hamming_loss: 0.2771\nEpoch 36/100\n6/6 - 0s - loss: 0.5996 - hamming_loss: 0.2972 - val_loss: 0.6209 - val_hamming_loss: 0.2762\nEpoch 37/100\n6/6 - 0s - loss: 0.5926 - hamming_loss: 0.2775 - val_loss: 0.6187 - val_hamming_loss: 0.2719\nEpoch 38/100\n6/6 - 0s - loss: 0.5895 - hamming_loss: 0.2810 - val_loss: 0.6165 - val_hamming_loss: 0.2692\nEpoch 39/100\n6/6 - 0s - loss: 0.5860 - hamming_loss: 0.2710 - val_loss: 0.6142 - val_hamming_loss: 0.2692\nEpoch 40/100\n6/6 - 0s - loss: 0.5845 - hamming_loss: 0.2666 - val_loss: 0.6119 - val_hamming_loss: 0.2666\nEpoch 41/100\n6/6 - 0s - loss: 0.5836 - hamming_loss: 0.2684 - val_loss: 0.6097 - val_hamming_loss: 0.2657\nEpoch 42/100\n6/6 - 0s - loss: 0.5820 - hamming_loss: 0.2688 - val_loss: 0.6074 - val_hamming_loss: 0.2640\nEpoch 43/100\n6/6 - 0s - loss: 0.5766 - hamming_loss: 0.2478 - val_loss: 0.6051 - val_hamming_loss: 0.2605\nEpoch 44/100\n6/6 - 0s - loss: 0.5689 - hamming_loss: 0.2526 - val_loss: 0.6027 - val_hamming_loss: 0.2552\nEpoch 45/100\n6/6 - 0s - loss: 0.5691 - hamming_loss: 0.2570 - val_loss: 0.6004 - val_hamming_loss: 0.2535\nEpoch 46/100\n6/6 - 0s - loss: 0.5695 - hamming_loss: 0.2653 - val_loss: 0.5981 - val_hamming_loss: 0.2535\nEpoch 47/100\n6/6 - 0s - loss: 0.5633 - hamming_loss: 0.2395 - val_loss: 0.5958 - val_hamming_loss: 0.2517\nEpoch 48/100\n6/6 - 0s - loss: 0.5536 - hamming_loss: 0.2343 - val_loss: 0.5934 - val_hamming_loss: 0.2465\nEpoch 49/100\n6/6 - 0s - loss: 0.5501 - hamming_loss: 0.2268 - val_loss: 0.5909 - val_hamming_loss: 0.2421\nEpoch 50/100\n6/6 - 0s - loss: 0.5601 - hamming_loss: 0.2461 - val_loss: 0.5886 - val_hamming_loss: 0.2395\nEpoch 51/100\n6/6 - 0s - loss: 0.5460 - hamming_loss: 0.2391 - val_loss: 0.5862 - val_hamming_loss: 0.2395\nEpoch 52/100\n6/6 - 0s - loss: 0.5441 - hamming_loss: 0.2334 - val_loss: 0.5839 - val_hamming_loss: 0.2386\nEpoch 53/100\n6/6 - 0s - loss: 0.5418 - hamming_loss: 0.2356 - val_loss: 0.5815 - val_hamming_loss: 0.2360\nEpoch 54/100\n6/6 - 0s - loss: 0.5415 - hamming_loss: 0.2351 - val_loss: 0.5792 - val_hamming_loss: 0.2325\nEpoch 55/100\n6/6 - 0s - loss: 0.5389 - hamming_loss: 0.2330 - val_loss: 0.5768 - val_hamming_loss: 0.2308\nEpoch 56/100\n6/6 - 0s - loss: 0.5391 - hamming_loss: 0.2299 - val_loss: 0.5745 - val_hamming_loss: 0.2308\nEpoch 57/100\n6/6 - 0s - loss: 0.5311 - hamming_loss: 0.2264 - val_loss: 0.5721 - val_hamming_loss: 0.2290\nEpoch 58/100\n6/6 - 0s - loss: 0.5304 - hamming_loss: 0.2247 - val_loss: 0.5697 - val_hamming_loss: 0.2290\nEpoch 59/100\n6/6 - 0s - loss: 0.5301 - hamming_loss: 0.2198 - val_loss: 0.5674 - val_hamming_loss: 0.2264\nEpoch 60/100\n6/6 - 0s - loss: 0.5215 - hamming_loss: 0.2124 - val_loss: 0.5651 - val_hamming_loss: 0.2255\nEpoch 61/100\n6/6 - 0s - loss: 0.5163 - hamming_loss: 0.2172 - val_loss: 0.5628 - val_hamming_loss: 0.2255\nEpoch 62/100\n6/6 - 0s - loss: 0.5165 - hamming_loss: 0.2159 - val_loss: 0.5605 - val_hamming_loss: 0.2247\nEpoch 63/100\n6/6 - 0s - loss: 0.5209 - hamming_loss: 0.2238 - val_loss: 0.5582 - val_hamming_loss: 0.2247\nEpoch 64/100\n6/6 - 0s - loss: 0.5172 - hamming_loss: 0.2163 - val_loss: 0.5559 - val_hamming_loss: 0.2255\nEpoch 65/100\n6/6 - 0s - loss: 0.5037 - hamming_loss: 0.2032 - val_loss: 0.5537 - val_hamming_loss: 0.2238\nEpoch 66/100\n6/6 - 0s - loss: 0.5044 - hamming_loss: 0.1989 - val_loss: 0.5514 - val_hamming_loss: 0.2212\nEpoch 67/100\n6/6 - 0s - loss: 0.5076 - hamming_loss: 0.2098 - val_loss: 0.5491 - val_hamming_loss: 0.2194\nEpoch 68/100\n6/6 - 0s - loss: 0.5066 - hamming_loss: 0.2032 - val_loss: 0.5470 - val_hamming_loss: 0.2203\nEpoch 69/100\n6/6 - 0s - loss: 0.5032 - hamming_loss: 0.1980 - val_loss: 0.5448 - val_hamming_loss: 0.2203\nEpoch 70/100\n6/6 - 0s - loss: 0.4897 - hamming_loss: 0.2032 - val_loss: 0.5426 - val_hamming_loss: 0.2185\nEpoch 71/100\n6/6 - 0s - loss: 0.4867 - hamming_loss: 0.2006 - val_loss: 0.5405 - val_hamming_loss: 0.2150\nEpoch 72/100\n6/6 - 0s - loss: 0.4865 - hamming_loss: 0.1980 - val_loss: 0.5383 - val_hamming_loss: 0.2142\nEpoch 73/100\n6/6 - 0s - loss: 0.4941 - hamming_loss: 0.2050 - val_loss: 0.5362 - val_hamming_loss: 0.2133\nEpoch 74/100\n6/6 - 0s - loss: 0.4873 - hamming_loss: 0.1901 - val_loss: 0.5341 - val_hamming_loss: 0.2124\nEpoch 75/100\n6/6 - 0s - loss: 0.4855 - hamming_loss: 0.2015 - val_loss: 0.5319 - val_hamming_loss: 0.2115\nEpoch 76/100\n6/6 - 0s - loss: 0.4857 - hamming_loss: 0.1993 - val_loss: 0.5298 - val_hamming_loss: 0.2115\nEpoch 77/100\n6/6 - 0s - loss: 0.4655 - hamming_loss: 0.1770 - val_loss: 0.5277 - val_hamming_loss: 0.2107\nEpoch 78/100\n6/6 - 0s - loss: 0.4769 - hamming_loss: 0.1906 - val_loss: 0.5256 - val_hamming_loss: 0.2089\nEpoch 79/100\n6/6 - 0s - loss: 0.4855 - hamming_loss: 0.2050 - val_loss: 0.5235 - val_hamming_loss: 0.2072\nEpoch 80/100\n6/6 - 0s - loss: 0.4750 - hamming_loss: 0.1971 - val_loss: 0.5215 - val_hamming_loss: 0.2045\nEpoch 81/100\n6/6 - 0s - loss: 0.4594 - hamming_loss: 0.1788 - val_loss: 0.5195 - val_hamming_loss: 0.2045\nEpoch 82/100\n6/6 - 0s - loss: 0.4640 - hamming_loss: 0.1823 - val_loss: 0.5175 - val_hamming_loss: 0.2002\nEpoch 83/100\n6/6 - 0s - loss: 0.4574 - hamming_loss: 0.1849 - val_loss: 0.5156 - val_hamming_loss: 0.1993\nEpoch 84/100\n6/6 - 0s - loss: 0.4538 - hamming_loss: 0.1696 - val_loss: 0.5136 - val_hamming_loss: 0.1967\nEpoch 85/100\n6/6 - 0s - loss: 0.4546 - hamming_loss: 0.1788 - val_loss: 0.5117 - val_hamming_loss: 0.1967\nEpoch 86/100\n6/6 - 0s - loss: 0.4556 - hamming_loss: 0.1805 - val_loss: 0.5098 - val_hamming_loss: 0.1941\nEpoch 87/100\n6/6 - 0s - loss: 0.4508 - hamming_loss: 0.1796 - val_loss: 0.5079 - val_hamming_loss: 0.1932\nEpoch 88/100\n6/6 - 0s - loss: 0.4524 - hamming_loss: 0.1753 - val_loss: 0.5060 - val_hamming_loss: 0.1923\nEpoch 89/100\n6/6 - 0s - loss: 0.4381 - hamming_loss: 0.1683 - val_loss: 0.5041 - val_hamming_loss: 0.1906\nEpoch 90/100\n6/6 - 0s - loss: 0.4421 - hamming_loss: 0.1753 - val_loss: 0.5023 - val_hamming_loss: 0.1906\nEpoch 91/100\n6/6 - 0s - loss: 0.4494 - hamming_loss: 0.1757 - val_loss: 0.5005 - val_hamming_loss: 0.1897\nEpoch 92/100\n6/6 - 0s - loss: 0.4400 - hamming_loss: 0.1674 - val_loss: 0.4987 - val_hamming_loss: 0.1888\nEpoch 93/100\n6/6 - 0s - loss: 0.4324 - hamming_loss: 0.1656 - val_loss: 0.4969 - val_hamming_loss: 0.1888\nEpoch 94/100\n6/6 - 0s - loss: 0.4400 - hamming_loss: 0.1753 - val_loss: 0.4951 - val_hamming_loss: 0.1862\nEpoch 95/100\n6/6 - 0s - loss: 0.4294 - hamming_loss: 0.1700 - val_loss: 0.4933 - val_hamming_loss: 0.1862\nEpoch 96/100\n6/6 - 0s - loss: 0.4338 - hamming_loss: 0.1696 - val_loss: 0.4916 - val_hamming_loss: 0.1827\nEpoch 97/100\n6/6 - 0s - loss: 0.4300 - hamming_loss: 0.1639 - val_loss: 0.4899 - val_hamming_loss: 0.1827\nEpoch 98/100\n6/6 - 0s - loss: 0.4241 - hamming_loss: 0.1569 - val_loss: 0.4882 - val_hamming_loss: 0.1783\nEpoch 99/100\n6/6 - 0s - loss: 0.4332 - hamming_loss: 0.1735 - val_loss: 0.4866 - val_hamming_loss: 0.1757\nEpoch 100/100\n6/6 - 0s - loss: 0.4285 - hamming_loss: 0.1696 - val_loss: 0.4850 - val_hamming_loss: 0.1757\n" ], [ "## (CAUTION: DO NOT OVERWRITE EXISTING FILES) -- Convert training history to dataframe and write to a .json file \nhistory_ce_FF_lr001_df = pd.DataFrame(history_ce_FF_lr001.history)\n#with open(\"Reduced Data Eval Metrics/Cross Entropy Feed Forward/history_ce_FF_lr0001.json\", \"w\") as outfile: \n# history_ce_FF_lr001_df.to_json(outfile)", "_____no_output_____" ], [ "## Learn a threshold function and save the test error for use in future DF\nY_train_pred = model_ce_FF.predict(X_train_hasLabel)\nY_test_pred = model_ce_FF.predict(X_test_hasLabel)\nt_range = (0, 1)\n\ntest_labels_binary, threshold_function = predict_test_labels_binary(Y_train_pred, Y_train_hasLabel, Y_test_pred, t_range)\nce_FF_withThreshold = metrics.hamming_loss(Y_test_hasLabel, test_labels_binary)", "_____no_output_____" ] ], [ [ "### Feed-Forward BP-MLL Network", "_____no_output_____" ] ], [ [ "## Start by defining and compiling the bp-mll loss network \ntf.random.set_seed(123)\nmodel_bpmll_FF = tf.keras.models.Sequential([\n tf.keras.layers.Dense(32, activation = 'relu'),\n tf.keras.layers.Dropout(0.5),\n tf.keras.layers.Dense(num_labels, activation = 'sigmoid')\n])\n\noptim_func = tf.keras.optimizers.Adam(lr = 0.0001)\n\nmodel_bpmll_FF.compile(optimizer = optim_func,\n loss = bp_mll_loss, metrics = metric\n )", "_____no_output_____" ], [ "tf.random.set_seed(123)\nhistory_bpmll_FF_lr001 = model_bpmll_FF.fit(X_train_hasLabel, Y_train_hasLabel, epochs = 100,\n validation_data = (X_test_hasLabel, Y_test_hasLabel), verbose=2)", "Epoch 1/100\n6/6 - 1s - loss: 0.9846 - hamming_loss: 0.3820 - val_loss: 0.9769 - val_hamming_loss: 0.4685\nEpoch 2/100\n6/6 - 0s - loss: 0.9782 - hamming_loss: 0.4808 - val_loss: 0.9751 - val_hamming_loss: 0.4624\nEpoch 3/100\n6/6 - 0s - loss: 0.9793 - hamming_loss: 0.4830 - val_loss: 0.9733 - val_hamming_loss: 0.4598\nEpoch 4/100\n6/6 - 0s - loss: 0.9722 - hamming_loss: 0.4672 - val_loss: 0.9715 - val_hamming_loss: 0.4537\nEpoch 5/100\n6/6 - 0s - loss: 0.9715 - hamming_loss: 0.4668 - val_loss: 0.9698 - val_hamming_loss: 0.4519\nEpoch 6/100\n6/6 - 0s - loss: 0.9645 - hamming_loss: 0.4563 - val_loss: 0.9680 - val_hamming_loss: 0.4449\nEpoch 7/100\n6/6 - 0s - loss: 0.9601 - hamming_loss: 0.4515 - val_loss: 0.9662 - val_hamming_loss: 0.4423\nEpoch 8/100\n6/6 - 0s - loss: 0.9639 - hamming_loss: 0.4567 - val_loss: 0.9644 - val_hamming_loss: 0.4406\nEpoch 9/100\n6/6 - 0s - loss: 0.9539 - hamming_loss: 0.4388 - val_loss: 0.9626 - val_hamming_loss: 0.4379\nEpoch 10/100\n6/6 - 0s - loss: 0.9491 - hamming_loss: 0.4226 - val_loss: 0.9607 - val_hamming_loss: 0.4318\nEpoch 11/100\n6/6 - 0s - loss: 0.9474 - hamming_loss: 0.4349 - val_loss: 0.9589 - val_hamming_loss: 0.4301\nEpoch 12/100\n6/6 - 0s - loss: 0.9459 - hamming_loss: 0.4375 - val_loss: 0.9570 - val_hamming_loss: 0.4240\nEpoch 13/100\n6/6 - 0s - loss: 0.9469 - hamming_loss: 0.4226 - val_loss: 0.9552 - val_hamming_loss: 0.4152\nEpoch 14/100\n6/6 - 0s - loss: 0.9365 - hamming_loss: 0.4043 - val_loss: 0.9534 - val_hamming_loss: 0.4108\nEpoch 15/100\n6/6 - 0s - loss: 0.9372 - hamming_loss: 0.4130 - val_loss: 0.9515 - val_hamming_loss: 0.4065\nEpoch 16/100\n6/6 - 0s - loss: 0.9343 - hamming_loss: 0.4165 - val_loss: 0.9496 - val_hamming_loss: 0.4056\nEpoch 17/100\n6/6 - 0s - loss: 0.9313 - hamming_loss: 0.4174 - val_loss: 0.9477 - val_hamming_loss: 0.4030\nEpoch 18/100\n6/6 - 0s - loss: 0.9284 - hamming_loss: 0.4017 - val_loss: 0.9459 - val_hamming_loss: 0.3977\nEpoch 19/100\n6/6 - 0s - loss: 0.9251 - hamming_loss: 0.3925 - val_loss: 0.9441 - val_hamming_loss: 0.3969\nEpoch 20/100\n6/6 - 0s - loss: 0.9247 - hamming_loss: 0.3916 - val_loss: 0.9422 - val_hamming_loss: 0.3934\nEpoch 21/100\n6/6 - 0s - loss: 0.9152 - hamming_loss: 0.3837 - val_loss: 0.9403 - val_hamming_loss: 0.3951\nEpoch 22/100\n6/6 - 0s - loss: 0.9112 - hamming_loss: 0.3986 - val_loss: 0.9384 - val_hamming_loss: 0.3916\nEpoch 23/100\n6/6 - 0s - loss: 0.9108 - hamming_loss: 0.3890 - val_loss: 0.9364 - val_hamming_loss: 0.3881\nEpoch 24/100\n6/6 - 0s - loss: 0.9103 - hamming_loss: 0.3789 - val_loss: 0.9345 - val_hamming_loss: 0.3837\nEpoch 25/100\n6/6 - 0s - loss: 0.9038 - hamming_loss: 0.3890 - val_loss: 0.9326 - val_hamming_loss: 0.3820\nEpoch 26/100\n6/6 - 0s - loss: 0.9020 - hamming_loss: 0.3785 - val_loss: 0.9307 - val_hamming_loss: 0.3767\nEpoch 27/100\n6/6 - 0s - loss: 0.8928 - hamming_loss: 0.3641 - val_loss: 0.9288 - val_hamming_loss: 0.3733\nEpoch 28/100\n6/6 - 0s - loss: 0.8969 - hamming_loss: 0.3680 - val_loss: 0.9269 - val_hamming_loss: 0.3741\nEpoch 29/100\n6/6 - 0s - loss: 0.8967 - hamming_loss: 0.3702 - val_loss: 0.9249 - val_hamming_loss: 0.3715\nEpoch 30/100\n6/6 - 0s - loss: 0.8813 - hamming_loss: 0.3497 - val_loss: 0.9229 - val_hamming_loss: 0.3698\nEpoch 31/100\n6/6 - 0s - loss: 0.8766 - hamming_loss: 0.3497 - val_loss: 0.9209 - val_hamming_loss: 0.3663\nEpoch 32/100\n6/6 - 0s - loss: 0.8827 - hamming_loss: 0.3684 - val_loss: 0.9189 - val_hamming_loss: 0.3645\nEpoch 33/100\n6/6 - 0s - loss: 0.8800 - hamming_loss: 0.3510 - val_loss: 0.9169 - val_hamming_loss: 0.3636\nEpoch 34/100\n6/6 - 0s - loss: 0.8750 - hamming_loss: 0.3409 - val_loss: 0.9149 - val_hamming_loss: 0.3593\nEpoch 35/100\n6/6 - 0s - loss: 0.8699 - hamming_loss: 0.3400 - val_loss: 0.9129 - val_hamming_loss: 0.3540\nEpoch 36/100\n6/6 - 0s - loss: 0.8780 - hamming_loss: 0.3571 - val_loss: 0.9109 - val_hamming_loss: 0.3497\nEpoch 37/100\n6/6 - 0s - loss: 0.8746 - hamming_loss: 0.3457 - val_loss: 0.9090 - val_hamming_loss: 0.3462\nEpoch 38/100\n6/6 - 0s - loss: 0.8647 - hamming_loss: 0.3440 - val_loss: 0.9071 - val_hamming_loss: 0.3444\nEpoch 39/100\n6/6 - 0s - loss: 0.8597 - hamming_loss: 0.3413 - val_loss: 0.9051 - val_hamming_loss: 0.3435\nEpoch 40/100\n6/6 - 0s - loss: 0.8596 - hamming_loss: 0.3392 - val_loss: 0.9030 - val_hamming_loss: 0.3392\nEpoch 41/100\n6/6 - 0s - loss: 0.8591 - hamming_loss: 0.3370 - val_loss: 0.9010 - val_hamming_loss: 0.3339\nEpoch 42/100\n6/6 - 0s - loss: 0.8571 - hamming_loss: 0.3479 - val_loss: 0.8989 - val_hamming_loss: 0.3304\nEpoch 43/100\n6/6 - 0s - loss: 0.8511 - hamming_loss: 0.3396 - val_loss: 0.8969 - val_hamming_loss: 0.3287\nEpoch 44/100\n6/6 - 0s - loss: 0.8443 - hamming_loss: 0.3177 - val_loss: 0.8948 - val_hamming_loss: 0.3278\nEpoch 45/100\n6/6 - 0s - loss: 0.8467 - hamming_loss: 0.3234 - val_loss: 0.8928 - val_hamming_loss: 0.3260\nEpoch 46/100\n6/6 - 0s - loss: 0.8455 - hamming_loss: 0.3326 - val_loss: 0.8908 - val_hamming_loss: 0.3226\nEpoch 47/100\n6/6 - 0s - loss: 0.8401 - hamming_loss: 0.3156 - val_loss: 0.8888 - val_hamming_loss: 0.3199\nEpoch 48/100\n6/6 - 0s - loss: 0.8294 - hamming_loss: 0.3134 - val_loss: 0.8868 - val_hamming_loss: 0.3191\nEpoch 49/100\n6/6 - 0s - loss: 0.8296 - hamming_loss: 0.3077 - val_loss: 0.8847 - val_hamming_loss: 0.3173\nEpoch 50/100\n6/6 - 0s - loss: 0.8348 - hamming_loss: 0.3278 - val_loss: 0.8827 - val_hamming_loss: 0.3129\nEpoch 51/100\n6/6 - 0s - loss: 0.8213 - hamming_loss: 0.2963 - val_loss: 0.8806 - val_hamming_loss: 0.3112\nEpoch 52/100\n6/6 - 0s - loss: 0.8191 - hamming_loss: 0.3116 - val_loss: 0.8786 - val_hamming_loss: 0.3059\nEpoch 53/100\n6/6 - 0s - loss: 0.8206 - hamming_loss: 0.3081 - val_loss: 0.8767 - val_hamming_loss: 0.3042\nEpoch 54/100\n6/6 - 0s - loss: 0.8194 - hamming_loss: 0.2990 - val_loss: 0.8747 - val_hamming_loss: 0.3024\nEpoch 55/100\n6/6 - 0s - loss: 0.8149 - hamming_loss: 0.3103 - val_loss: 0.8727 - val_hamming_loss: 0.2990\nEpoch 56/100\n6/6 - 0s - loss: 0.8172 - hamming_loss: 0.3024 - val_loss: 0.8708 - val_hamming_loss: 0.2937\nEpoch 57/100\n6/6 - 0s - loss: 0.8162 - hamming_loss: 0.2898 - val_loss: 0.8688 - val_hamming_loss: 0.2920\nEpoch 58/100\n6/6 - 0s - loss: 0.8073 - hamming_loss: 0.3068 - val_loss: 0.8669 - val_hamming_loss: 0.2920\nEpoch 59/100\n6/6 - 0s - loss: 0.8073 - hamming_loss: 0.3024 - val_loss: 0.8649 - val_hamming_loss: 0.2876\nEpoch 60/100\n6/6 - 0s - loss: 0.7974 - hamming_loss: 0.2841 - val_loss: 0.8630 - val_hamming_loss: 0.2867\nEpoch 61/100\n6/6 - 0s - loss: 0.7957 - hamming_loss: 0.2823 - val_loss: 0.8611 - val_hamming_loss: 0.2841\nEpoch 62/100\n6/6 - 0s - loss: 0.7957 - hamming_loss: 0.2981 - val_loss: 0.8592 - val_hamming_loss: 0.2815\nEpoch 63/100\n6/6 - 0s - loss: 0.8008 - hamming_loss: 0.2898 - val_loss: 0.8573 - val_hamming_loss: 0.2780\nEpoch 64/100\n6/6 - 0s - loss: 0.7946 - hamming_loss: 0.2845 - val_loss: 0.8555 - val_hamming_loss: 0.2762\nEpoch 65/100\n6/6 - 0s - loss: 0.7847 - hamming_loss: 0.2802 - val_loss: 0.8536 - val_hamming_loss: 0.2745\nEpoch 66/100\n6/6 - 0s - loss: 0.7864 - hamming_loss: 0.2815 - val_loss: 0.8517 - val_hamming_loss: 0.2745\nEpoch 67/100\n6/6 - 0s - loss: 0.7899 - hamming_loss: 0.2793 - val_loss: 0.8498 - val_hamming_loss: 0.2736\nEpoch 68/100\n6/6 - 0s - loss: 0.7885 - hamming_loss: 0.2819 - val_loss: 0.8481 - val_hamming_loss: 0.2710\nEpoch 69/100\n6/6 - 0s - loss: 0.7883 - hamming_loss: 0.2832 - val_loss: 0.8463 - val_hamming_loss: 0.2692\nEpoch 70/100\n6/6 - 0s - loss: 0.7744 - hamming_loss: 0.2740 - val_loss: 0.8445 - val_hamming_loss: 0.2684\nEpoch 71/100\n6/6 - 0s - loss: 0.7699 - hamming_loss: 0.2806 - val_loss: 0.8427 - val_hamming_loss: 0.2649\nEpoch 72/100\n6/6 - 0s - loss: 0.7728 - hamming_loss: 0.2653 - val_loss: 0.8409 - val_hamming_loss: 0.2640\nEpoch 73/100\n6/6 - 0s - loss: 0.7749 - hamming_loss: 0.2793 - val_loss: 0.8391 - val_hamming_loss: 0.2640\nEpoch 74/100\n6/6 - 0s - loss: 0.7695 - hamming_loss: 0.2596 - val_loss: 0.8373 - val_hamming_loss: 0.2631\nEpoch 75/100\n6/6 - 0s - loss: 0.7669 - hamming_loss: 0.2609 - val_loss: 0.8356 - val_hamming_loss: 0.2587\nEpoch 76/100\n6/6 - 0s - loss: 0.7674 - hamming_loss: 0.2592 - val_loss: 0.8338 - val_hamming_loss: 0.2579\nEpoch 77/100\n6/6 - 0s - loss: 0.7532 - hamming_loss: 0.2574 - val_loss: 0.8320 - val_hamming_loss: 0.2587\nEpoch 78/100\n6/6 - 0s - loss: 0.7614 - hamming_loss: 0.2675 - val_loss: 0.8303 - val_hamming_loss: 0.2552\nEpoch 79/100\n6/6 - 0s - loss: 0.7678 - hamming_loss: 0.2666 - val_loss: 0.8286 - val_hamming_loss: 0.2561\nEpoch 80/100\n6/6 - 0s - loss: 0.7572 - hamming_loss: 0.2631 - val_loss: 0.8269 - val_hamming_loss: 0.2552\nEpoch 81/100\n6/6 - 0s - loss: 0.7446 - hamming_loss: 0.2509 - val_loss: 0.8252 - val_hamming_loss: 0.2535\nEpoch 82/100\n6/6 - 0s - loss: 0.7484 - hamming_loss: 0.2461 - val_loss: 0.8235 - val_hamming_loss: 0.2509\nEpoch 83/100\n6/6 - 0s - loss: 0.7455 - hamming_loss: 0.2448 - val_loss: 0.8219 - val_hamming_loss: 0.2491\nEpoch 84/100\n6/6 - 0s - loss: 0.7400 - hamming_loss: 0.2557 - val_loss: 0.8202 - val_hamming_loss: 0.2474\nEpoch 85/100\n6/6 - 0s - loss: 0.7447 - hamming_loss: 0.2386 - val_loss: 0.8185 - val_hamming_loss: 0.2448\nEpoch 86/100\n6/6 - 0s - loss: 0.7366 - hamming_loss: 0.2399 - val_loss: 0.8169 - val_hamming_loss: 0.2430\nEpoch 87/100\n6/6 - 0s - loss: 0.7391 - hamming_loss: 0.2522 - val_loss: 0.8153 - val_hamming_loss: 0.2421\nEpoch 88/100\n6/6 - 0s - loss: 0.7427 - hamming_loss: 0.2465 - val_loss: 0.8137 - val_hamming_loss: 0.2413\nEpoch 89/100\n6/6 - 0s - loss: 0.7228 - hamming_loss: 0.2378 - val_loss: 0.8120 - val_hamming_loss: 0.2404\nEpoch 90/100\n6/6 - 0s - loss: 0.7271 - hamming_loss: 0.2382 - val_loss: 0.8104 - val_hamming_loss: 0.2369\nEpoch 91/100\n6/6 - 0s - loss: 0.7351 - hamming_loss: 0.2504 - val_loss: 0.8088 - val_hamming_loss: 0.2351\nEpoch 92/100\n6/6 - 0s - loss: 0.7295 - hamming_loss: 0.2308 - val_loss: 0.8072 - val_hamming_loss: 0.2325\nEpoch 93/100\n6/6 - 0s - loss: 0.7152 - hamming_loss: 0.2295 - val_loss: 0.8057 - val_hamming_loss: 0.2316\nEpoch 94/100\n6/6 - 0s - loss: 0.7256 - hamming_loss: 0.2338 - val_loss: 0.8041 - val_hamming_loss: 0.2299\nEpoch 95/100\n6/6 - 0s - loss: 0.7153 - hamming_loss: 0.2251 - val_loss: 0.8025 - val_hamming_loss: 0.2290\nEpoch 96/100\n6/6 - 0s - loss: 0.7214 - hamming_loss: 0.2351 - val_loss: 0.8010 - val_hamming_loss: 0.2264\nEpoch 97/100\n6/6 - 0s - loss: 0.7192 - hamming_loss: 0.2299 - val_loss: 0.7994 - val_hamming_loss: 0.2255\nEpoch 98/100\n6/6 - 0s - loss: 0.7101 - hamming_loss: 0.2225 - val_loss: 0.7979 - val_hamming_loss: 0.2255\nEpoch 99/100\n6/6 - 0s - loss: 0.7176 - hamming_loss: 0.2356 - val_loss: 0.7964 - val_hamming_loss: 0.2238\nEpoch 100/100\n6/6 - 0s - loss: 0.7169 - hamming_loss: 0.2281 - val_loss: 0.7950 - val_hamming_loss: 0.2238\n" ], [ "## (CAUTION: DO NOT OVERWRITE EXISTING FILES) -- Convert training history to dataframe and write to a .json file \nhistory_bpmll_FF_lr001_df = pd.DataFrame(history_bpmll_FF_lr001.history)\n#with open(\"Reduced Data Eval Metrics/BPMLL Feed Forward/history_bpmll_FF_lr0001.json\", \"w\") as outfile: \n# history_bpmll_FF_lr001_df.to_json(outfile)", "_____no_output_____" ], [ "## Learn a threshold function and save the test error for use in future DF\nY_train_pred = model_bpmll_FF.predict(X_train_hasLabel)\nY_test_pred = model_bpmll_FF.predict(X_test_hasLabel)\nt_range = (0, 1)\n\ntest_labels_binary, threshold_function = predict_test_labels_binary(Y_train_pred, Y_train_hasLabel, Y_test_pred, t_range)\nbpmll_FF_withThreshold = metrics.hamming_loss(Y_test_hasLabel, test_labels_binary)", "_____no_output_____" ] ], [ [ "### BPMLL Bidirectional LSTM Recurrent Network", "_____no_output_____" ] ], [ [ "## Load the pre-processed data\nfile_object_reduced = open('../RNN Text Categorization/RNN_data_dict_reduced.json',)\nRNN_data_dict_reduced = json.load(file_object_reduced)\nRNN_data_dict_reduced = ast.literal_eval(RNN_data_dict_reduced)\ntrain_padded_hasLabel = np.array(RNN_data_dict_reduced['train_padded_hasLabel'])\ntest_padded_hasLabel = np.array(RNN_data_dict_reduced['test_padded_hasLabel'])\nY_train_hasLabel = np.array(RNN_data_dict_reduced['Y_train_hasLabel'])\nY_test_hasLabel = np.array(RNN_data_dict_reduced['Y_test_hasLabel'])", "_____no_output_____" ], [ "## Define the bidirectional LSTM RNN architecture\ntf.random.set_seed(123)\nnum_labels = 13\nmax_length = 100\nnum_unique_words = 2711\n\nmodel_bpmll_biLSTM = tf.keras.models.Sequential([\n tf.keras.layers.Embedding(num_unique_words, 32, input_length = max_length),\n tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(16, return_sequences = False, return_state = False)),\n #tf.keras.layers.Dropout(0.5),\n tf.keras.layers.Dense(num_labels, activation = 'sigmoid')\n])\n\noptim_func = tf.keras.optimizers.Adam(lr = 0.0001)\n\nmodel_bpmll_biLSTM.compile(loss = bp_mll_loss, optimizer = optim_func, metrics = metric)", "_____no_output_____" ], [ "tf.random.set_seed(123)\nhistory_bpmll_RNN_lr001 = model_bpmll_biLSTM.fit(train_padded_hasLabel, Y_train_hasLabel, epochs = 100, \n validation_data = (test_padded_hasLabel, Y_test_hasLabel), verbose=2)", "Epoch 1/100\n6/6 - 4s - loss: 0.9990 - hamming_loss: 0.4350 - val_loss: 0.9986 - val_hamming_loss: 0.5411\nEpoch 2/100\n6/6 - 0s - loss: 0.9981 - hamming_loss: 0.5197 - val_loss: 0.9979 - val_hamming_loss: 0.5262\nEpoch 3/100\n6/6 - 0s - loss: 0.9973 - hamming_loss: 0.5017 - val_loss: 0.9971 - val_hamming_loss: 0.5026\nEpoch 4/100\n6/6 - 0s - loss: 0.9964 - hamming_loss: 0.4786 - val_loss: 0.9964 - val_hamming_loss: 0.4895\nEpoch 5/100\n6/6 - 0s - loss: 0.9956 - hamming_loss: 0.4576 - val_loss: 0.9956 - val_hamming_loss: 0.4764\nEpoch 6/100\n6/6 - 0s - loss: 0.9947 - hamming_loss: 0.4406 - val_loss: 0.9948 - val_hamming_loss: 0.4510\nEpoch 7/100\n6/6 - 0s - loss: 0.9938 - hamming_loss: 0.4156 - val_loss: 0.9940 - val_hamming_loss: 0.4266\nEpoch 8/100\n6/6 - 0s - loss: 0.9928 - hamming_loss: 0.3872 - val_loss: 0.9931 - val_hamming_loss: 0.4073\nEpoch 9/100\n6/6 - 0s - loss: 0.9919 - hamming_loss: 0.3663 - val_loss: 0.9922 - val_hamming_loss: 0.3881\nEpoch 10/100\n6/6 - 0s - loss: 0.9908 - hamming_loss: 0.3540 - val_loss: 0.9912 - val_hamming_loss: 0.3733\nEpoch 11/100\n6/6 - 0s - loss: 0.9897 - hamming_loss: 0.3444 - val_loss: 0.9902 - val_hamming_loss: 0.3689\nEpoch 12/100\n6/6 - 0s - loss: 0.9886 - hamming_loss: 0.3361 - val_loss: 0.9892 - val_hamming_loss: 0.3593\nEpoch 13/100\n6/6 - 0s - loss: 0.9874 - hamming_loss: 0.3365 - val_loss: 0.9880 - val_hamming_loss: 0.3505\nEpoch 14/100\n6/6 - 0s - loss: 0.9861 - hamming_loss: 0.3335 - val_loss: 0.9868 - val_hamming_loss: 0.3497\nEpoch 15/100\n6/6 - 0s - loss: 0.9847 - hamming_loss: 0.3313 - val_loss: 0.9855 - val_hamming_loss: 0.3540\nEpoch 16/100\n6/6 - 0s - loss: 0.9833 - hamming_loss: 0.3352 - val_loss: 0.9841 - val_hamming_loss: 0.3523\nEpoch 17/100\n6/6 - 0s - loss: 0.9817 - hamming_loss: 0.3365 - val_loss: 0.9826 - val_hamming_loss: 0.3523\nEpoch 18/100\n6/6 - 0s - loss: 0.9800 - hamming_loss: 0.3387 - val_loss: 0.9810 - val_hamming_loss: 0.3514\nEpoch 19/100\n6/6 - 0s - loss: 0.9782 - hamming_loss: 0.3405 - val_loss: 0.9792 - val_hamming_loss: 0.3514\nEpoch 20/100\n6/6 - 0s - loss: 0.9761 - hamming_loss: 0.3427 - val_loss: 0.9773 - val_hamming_loss: 0.3514\nEpoch 21/100\n6/6 - 0s - loss: 0.9739 - hamming_loss: 0.3453 - val_loss: 0.9751 - val_hamming_loss: 0.3566\nEpoch 22/100\n6/6 - 0s - loss: 0.9715 - hamming_loss: 0.3466 - val_loss: 0.9727 - val_hamming_loss: 0.3584\nEpoch 23/100\n6/6 - 0s - loss: 0.9688 - hamming_loss: 0.3497 - val_loss: 0.9699 - val_hamming_loss: 0.3575\nEpoch 24/100\n6/6 - 0s - loss: 0.9657 - hamming_loss: 0.3514 - val_loss: 0.9668 - val_hamming_loss: 0.3558\nEpoch 25/100\n6/6 - 0s - loss: 0.9622 - hamming_loss: 0.3518 - val_loss: 0.9633 - val_hamming_loss: 0.3584\nEpoch 26/100\n6/6 - 0s - loss: 0.9583 - hamming_loss: 0.3523 - val_loss: 0.9592 - val_hamming_loss: 0.3584\nEpoch 27/100\n6/6 - 0s - loss: 0.9538 - hamming_loss: 0.3518 - val_loss: 0.9546 - val_hamming_loss: 0.3566\nEpoch 28/100\n6/6 - 0s - loss: 0.9487 - hamming_loss: 0.3510 - val_loss: 0.9491 - val_hamming_loss: 0.3558\nEpoch 29/100\n6/6 - 0s - loss: 0.9426 - hamming_loss: 0.3488 - val_loss: 0.9426 - val_hamming_loss: 0.3514\nEpoch 30/100\n6/6 - 0s - loss: 0.9352 - hamming_loss: 0.3431 - val_loss: 0.9348 - val_hamming_loss: 0.3418\nEpoch 31/100\n6/6 - 0s - loss: 0.9265 - hamming_loss: 0.3361 - val_loss: 0.9254 - val_hamming_loss: 0.3313\nEpoch 32/100\n6/6 - 0s - loss: 0.9161 - hamming_loss: 0.3234 - val_loss: 0.9143 - val_hamming_loss: 0.3147\nEpoch 33/100\n6/6 - 0s - loss: 0.9044 - hamming_loss: 0.3142 - val_loss: 0.9017 - val_hamming_loss: 0.3068\nEpoch 34/100\n6/6 - 0s - loss: 0.8909 - hamming_loss: 0.3103 - val_loss: 0.8888 - val_hamming_loss: 0.3007\nEpoch 35/100\n6/6 - 0s - loss: 0.8778 - hamming_loss: 0.3055 - val_loss: 0.8759 - val_hamming_loss: 0.2981\nEpoch 36/100\n6/6 - 0s - loss: 0.8652 - hamming_loss: 0.2990 - val_loss: 0.8643 - val_hamming_loss: 0.2981\nEpoch 37/100\n6/6 - 0s - loss: 0.8539 - hamming_loss: 0.2972 - val_loss: 0.8542 - val_hamming_loss: 0.2955\nEpoch 38/100\n6/6 - 0s - loss: 0.8440 - hamming_loss: 0.2968 - val_loss: 0.8457 - val_hamming_loss: 0.2972\nEpoch 39/100\n6/6 - 0s - loss: 0.8360 - hamming_loss: 0.2968 - val_loss: 0.8383 - val_hamming_loss: 0.2990\nEpoch 40/100\n6/6 - 0s - loss: 0.8289 - hamming_loss: 0.2985 - val_loss: 0.8319 - val_hamming_loss: 0.3007\nEpoch 41/100\n6/6 - 0s - loss: 0.8227 - hamming_loss: 0.2985 - val_loss: 0.8264 - val_hamming_loss: 0.3007\nEpoch 42/100\n6/6 - 0s - loss: 0.8174 - hamming_loss: 0.2985 - val_loss: 0.8214 - val_hamming_loss: 0.3007\nEpoch 43/100\n6/6 - 0s - loss: 0.8125 - hamming_loss: 0.2985 - val_loss: 0.8170 - val_hamming_loss: 0.3007\nEpoch 44/100\n6/6 - 0s - loss: 0.8082 - hamming_loss: 0.2985 - val_loss: 0.8129 - val_hamming_loss: 0.3007\nEpoch 45/100\n6/6 - 0s - loss: 0.8042 - hamming_loss: 0.2985 - val_loss: 0.8091 - val_hamming_loss: 0.3007\nEpoch 46/100\n6/6 - 0s - loss: 0.8005 - hamming_loss: 0.2985 - val_loss: 0.8056 - val_hamming_loss: 0.3007\nEpoch 47/100\n6/6 - 0s - loss: 0.7970 - hamming_loss: 0.2985 - val_loss: 0.8024 - val_hamming_loss: 0.3007\nEpoch 48/100\n6/6 - 0s - loss: 0.7939 - hamming_loss: 0.2985 - val_loss: 0.7993 - val_hamming_loss: 0.3007\nEpoch 49/100\n6/6 - 0s - loss: 0.7909 - hamming_loss: 0.2985 - val_loss: 0.7964 - val_hamming_loss: 0.3007\nEpoch 50/100\n6/6 - 0s - loss: 0.7881 - hamming_loss: 0.2985 - val_loss: 0.7938 - val_hamming_loss: 0.3007\nEpoch 51/100\n6/6 - 0s - loss: 0.7855 - hamming_loss: 0.2985 - val_loss: 0.7913 - val_hamming_loss: 0.3007\nEpoch 52/100\n6/6 - 0s - loss: 0.7830 - hamming_loss: 0.2985 - val_loss: 0.7889 - val_hamming_loss: 0.3007\nEpoch 53/100\n6/6 - 0s - loss: 0.7807 - hamming_loss: 0.2985 - val_loss: 0.7866 - val_hamming_loss: 0.3007\nEpoch 54/100\n6/6 - 0s - loss: 0.7785 - hamming_loss: 0.2985 - val_loss: 0.7844 - val_hamming_loss: 0.3007\nEpoch 55/100\n6/6 - 0s - loss: 0.7764 - hamming_loss: 0.2985 - val_loss: 0.7824 - val_hamming_loss: 0.3007\nEpoch 56/100\n6/6 - 0s - loss: 0.7744 - hamming_loss: 0.2985 - val_loss: 0.7805 - val_hamming_loss: 0.3007\nEpoch 57/100\n6/6 - 0s - loss: 0.7725 - hamming_loss: 0.2985 - val_loss: 0.7787 - val_hamming_loss: 0.3007\nEpoch 58/100\n6/6 - 0s - loss: 0.7707 - hamming_loss: 0.2985 - val_loss: 0.7769 - val_hamming_loss: 0.3007\nEpoch 59/100\n6/6 - 0s - loss: 0.7690 - hamming_loss: 0.2985 - val_loss: 0.7753 - val_hamming_loss: 0.3007\nEpoch 60/100\n6/6 - 0s - loss: 0.7674 - hamming_loss: 0.2985 - val_loss: 0.7737 - val_hamming_loss: 0.3007\nEpoch 61/100\n6/6 - 0s - loss: 0.7658 - hamming_loss: 0.2985 - val_loss: 0.7721 - val_hamming_loss: 0.3007\nEpoch 62/100\n6/6 - 0s - loss: 0.7643 - hamming_loss: 0.2985 - val_loss: 0.7706 - val_hamming_loss: 0.3007\nEpoch 63/100\n6/6 - 0s - loss: 0.7628 - hamming_loss: 0.2985 - val_loss: 0.7692 - val_hamming_loss: 0.3007\nEpoch 64/100\n6/6 - 0s - loss: 0.7614 - hamming_loss: 0.2985 - val_loss: 0.7678 - val_hamming_loss: 0.3007\nEpoch 65/100\n6/6 - 0s - loss: 0.7601 - hamming_loss: 0.2985 - val_loss: 0.7665 - val_hamming_loss: 0.3007\nEpoch 66/100\n6/6 - 0s - loss: 0.7589 - hamming_loss: 0.2985 - val_loss: 0.7653 - val_hamming_loss: 0.3007\nEpoch 67/100\n6/6 - 0s - loss: 0.7576 - hamming_loss: 0.2985 - val_loss: 0.7641 - val_hamming_loss: 0.3007\nEpoch 68/100\n6/6 - 0s - loss: 0.7564 - hamming_loss: 0.2985 - val_loss: 0.7629 - val_hamming_loss: 0.3007\nEpoch 69/100\n6/6 - 0s - loss: 0.7553 - hamming_loss: 0.2985 - val_loss: 0.7618 - val_hamming_loss: 0.3007\nEpoch 70/100\n6/6 - 0s - loss: 0.7542 - hamming_loss: 0.2985 - val_loss: 0.7607 - val_hamming_loss: 0.3007\nEpoch 71/100\n6/6 - 0s - loss: 0.7532 - hamming_loss: 0.2985 - val_loss: 0.7596 - val_hamming_loss: 0.3007\nEpoch 72/100\n6/6 - 0s - loss: 0.7522 - hamming_loss: 0.2985 - val_loss: 0.7587 - val_hamming_loss: 0.3007\nEpoch 73/100\n6/6 - 0s - loss: 0.7511 - hamming_loss: 0.2985 - val_loss: 0.7577 - val_hamming_loss: 0.3007\nEpoch 74/100\n6/6 - 0s - loss: 0.7502 - hamming_loss: 0.2985 - val_loss: 0.7568 - val_hamming_loss: 0.3007\nEpoch 75/100\n6/6 - 0s - loss: 0.7493 - hamming_loss: 0.2985 - val_loss: 0.7559 - val_hamming_loss: 0.3007\nEpoch 76/100\n6/6 - 0s - loss: 0.7484 - hamming_loss: 0.2985 - val_loss: 0.7550 - val_hamming_loss: 0.3007\nEpoch 77/100\n6/6 - 0s - loss: 0.7475 - hamming_loss: 0.2985 - val_loss: 0.7541 - val_hamming_loss: 0.3007\nEpoch 78/100\n6/6 - 0s - loss: 0.7467 - hamming_loss: 0.2985 - val_loss: 0.7533 - val_hamming_loss: 0.3007\nEpoch 79/100\n6/6 - 0s - loss: 0.7459 - hamming_loss: 0.2985 - val_loss: 0.7525 - val_hamming_loss: 0.3007\nEpoch 80/100\n6/6 - 0s - loss: 0.7451 - hamming_loss: 0.2985 - val_loss: 0.7517 - val_hamming_loss: 0.3007\nEpoch 81/100\n6/6 - 0s - loss: 0.7443 - hamming_loss: 0.2985 - val_loss: 0.7509 - val_hamming_loss: 0.3007\nEpoch 82/100\n6/6 - 0s - loss: 0.7436 - hamming_loss: 0.2985 - val_loss: 0.7502 - val_hamming_loss: 0.3007\nEpoch 83/100\n6/6 - 0s - loss: 0.7429 - hamming_loss: 0.2985 - val_loss: 0.7495 - val_hamming_loss: 0.3007\nEpoch 84/100\n6/6 - 0s - loss: 0.7422 - hamming_loss: 0.2985 - val_loss: 0.7489 - val_hamming_loss: 0.3007\nEpoch 85/100\n6/6 - 0s - loss: 0.7415 - hamming_loss: 0.2985 - val_loss: 0.7482 - val_hamming_loss: 0.3007\nEpoch 86/100\n6/6 - 0s - loss: 0.7408 - hamming_loss: 0.2985 - val_loss: 0.7476 - val_hamming_loss: 0.3007\nEpoch 87/100\n6/6 - 0s - loss: 0.7402 - hamming_loss: 0.2985 - val_loss: 0.7470 - val_hamming_loss: 0.3007\nEpoch 88/100\n6/6 - 0s - loss: 0.7395 - hamming_loss: 0.2985 - val_loss: 0.7464 - val_hamming_loss: 0.3007\nEpoch 89/100\n6/6 - 0s - loss: 0.7389 - hamming_loss: 0.2985 - val_loss: 0.7458 - val_hamming_loss: 0.3007\nEpoch 90/100\n6/6 - 0s - loss: 0.7383 - hamming_loss: 0.2985 - val_loss: 0.7452 - val_hamming_loss: 0.3007\nEpoch 91/100\n6/6 - 0s - loss: 0.7377 - hamming_loss: 0.2985 - val_loss: 0.7446 - val_hamming_loss: 0.3007\nEpoch 92/100\n6/6 - 0s - loss: 0.7371 - hamming_loss: 0.2985 - val_loss: 0.7441 - val_hamming_loss: 0.3007\nEpoch 93/100\n6/6 - 0s - loss: 0.7366 - hamming_loss: 0.2985 - val_loss: 0.7435 - val_hamming_loss: 0.3007\nEpoch 94/100\n6/6 - 0s - loss: 0.7360 - hamming_loss: 0.2985 - val_loss: 0.7430 - val_hamming_loss: 0.3007\nEpoch 95/100\n6/6 - 0s - loss: 0.7355 - hamming_loss: 0.2985 - val_loss: 0.7425 - val_hamming_loss: 0.3007\nEpoch 96/100\n6/6 - 0s - loss: 0.7349 - hamming_loss: 0.2985 - val_loss: 0.7419 - val_hamming_loss: 0.3007\nEpoch 97/100\n6/6 - 0s - loss: 0.7344 - hamming_loss: 0.2985 - val_loss: 0.7415 - val_hamming_loss: 0.3007\nEpoch 98/100\n6/6 - 0s - loss: 0.7339 - hamming_loss: 0.2985 - val_loss: 0.7410 - val_hamming_loss: 0.3007\nEpoch 99/100\n6/6 - 0s - loss: 0.7334 - hamming_loss: 0.2985 - val_loss: 0.7405 - val_hamming_loss: 0.3007\nEpoch 100/100\n6/6 - 0s - loss: 0.7329 - hamming_loss: 0.2985 - val_loss: 0.7400 - val_hamming_loss: 0.3007\n" ], [ "## (CAUTION: DO NOT OVERWRITE EXISTING FILES) -- Convert training history to dataframe and write to a .json file\nhistory_bpmll_RNN_lr001_df = pd.DataFrame(history_bpmll_RNN_lr001.history)\n#with open(\"Reduced Data Eval Metrics/BPMLL RNN/history_bpmll_RNN_lr0001.json\", \"w\") as outfile: \n# history_bpmll_RNN_lr001_df.to_json(outfile)", "_____no_output_____" ], [ "## Learn a threshold function and save the test error for use in future DF\nY_train_pred = model_bpmll_biLSTM.predict(train_padded_hasLabel)\nY_test_pred = model_bpmll_biLSTM.predict(test_padded_hasLabel)\nt_range = (0, 1)\n\ntest_labels_binary, threshold_function = predict_test_labels_binary(Y_train_pred, Y_train_hasLabel, Y_test_pred, t_range)\nbpmll_RNN_withThreshold = metrics.hamming_loss(Y_test_hasLabel, test_labels_binary)", "_____no_output_____" ] ], [ [ "### Cross-Entropy Bidirectional LSTM Recurrent Network", "_____no_output_____" ] ], [ [ "## Define the bidirectional LSTM RNN architecture\ntf.random.set_seed(123)\nnum_labels = 13\nmax_length = 100\nnum_unique_words = 2711\n\nmodel_ce_biLSTM = tf.keras.models.Sequential([\n tf.keras.layers.Embedding(num_unique_words, 32, input_length = max_length),\n tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(16, return_sequences = False, return_state = False)),\n #tf.keras.layers.Dropout(0.5),\n tf.keras.layers.Dense(num_labels, activation = 'sigmoid')\n])\n\noptim_func = tf.keras.optimizers.Adam(lr = 0.0001)\n\nmodel_ce_biLSTM.compile(loss = 'binary_crossentropy', optimizer = optim_func, metrics = metric)", "_____no_output_____" ], [ "tf.random.set_seed(123)\nhistory_ce_RNN_lr001 = model_ce_biLSTM.fit(train_padded_hasLabel, Y_train_hasLabel, epochs = 100, \n validation_data = (test_padded_hasLabel, Y_test_hasLabel), verbose=2)", "Epoch 1/100\n6/6 - 5s - loss: 0.6407 - hamming_loss: 0.2946 - val_loss: 0.4737 - val_hamming_loss: 0.1783\nEpoch 2/100\n6/6 - 0s - loss: 0.4329 - hamming_loss: 0.1792 - val_loss: 0.4222 - val_hamming_loss: 0.1888\nEpoch 3/100\n6/6 - 0s - loss: 0.4174 - hamming_loss: 0.1849 - val_loss: 0.4183 - val_hamming_loss: 0.1783\nEpoch 4/100\n6/6 - 0s - loss: 0.4093 - hamming_loss: 0.1796 - val_loss: 0.4088 - val_hamming_loss: 0.1783\nEpoch 5/100\n6/6 - 0s - loss: 0.3969 - hamming_loss: 0.1788 - val_loss: 0.4083 - val_hamming_loss: 0.1897\nEpoch 6/100\n6/6 - 0s - loss: 0.3801 - hamming_loss: 0.1744 - val_loss: 0.4075 - val_hamming_loss: 0.1801\nEpoch 7/100\n6/6 - 0s - loss: 0.3577 - hamming_loss: 0.1591 - val_loss: 0.4027 - val_hamming_loss: 0.1731\nEpoch 8/100\n6/6 - 0s - loss: 0.3325 - hamming_loss: 0.1342 - val_loss: 0.4029 - val_hamming_loss: 0.1809\nEpoch 9/100\n6/6 - 0s - loss: 0.3072 - hamming_loss: 0.1289 - val_loss: 0.4015 - val_hamming_loss: 0.1818\nEpoch 10/100\n6/6 - 0s - loss: 0.2821 - hamming_loss: 0.1132 - val_loss: 0.3962 - val_hamming_loss: 0.1722\nEpoch 11/100\n6/6 - 0s - loss: 0.2591 - hamming_loss: 0.1049 - val_loss: 0.4009 - val_hamming_loss: 0.1722\nEpoch 12/100\n6/6 - 0s - loss: 0.2396 - hamming_loss: 0.0940 - val_loss: 0.4037 - val_hamming_loss: 0.1722\nEpoch 13/100\n6/6 - 0s - loss: 0.2230 - hamming_loss: 0.0822 - val_loss: 0.4074 - val_hamming_loss: 0.1740\nEpoch 14/100\n6/6 - 0s - loss: 0.2085 - hamming_loss: 0.0712 - val_loss: 0.4131 - val_hamming_loss: 0.1713\nEpoch 15/100\n6/6 - 0s - loss: 0.1947 - hamming_loss: 0.0664 - val_loss: 0.4272 - val_hamming_loss: 0.1792\nEpoch 16/100\n6/6 - 0s - loss: 0.1818 - hamming_loss: 0.0625 - val_loss: 0.4242 - val_hamming_loss: 0.1722\nEpoch 17/100\n6/6 - 0s - loss: 0.1712 - hamming_loss: 0.0586 - val_loss: 0.4322 - val_hamming_loss: 0.1713\nEpoch 18/100\n6/6 - 0s - loss: 0.1596 - hamming_loss: 0.0485 - val_loss: 0.4446 - val_hamming_loss: 0.1652\nEpoch 19/100\n6/6 - 0s - loss: 0.1497 - hamming_loss: 0.0389 - val_loss: 0.4518 - val_hamming_loss: 0.1643\nEpoch 20/100\n6/6 - 0s - loss: 0.1412 - hamming_loss: 0.0350 - val_loss: 0.4494 - val_hamming_loss: 0.1626\nEpoch 21/100\n6/6 - 0s - loss: 0.1328 - hamming_loss: 0.0310 - val_loss: 0.4564 - val_hamming_loss: 0.1661\nEpoch 22/100\n6/6 - 0s - loss: 0.1240 - hamming_loss: 0.0288 - val_loss: 0.4581 - val_hamming_loss: 0.1661\nEpoch 23/100\n6/6 - 0s - loss: 0.1158 - hamming_loss: 0.0293 - val_loss: 0.4670 - val_hamming_loss: 0.1670\nEpoch 24/100\n6/6 - 0s - loss: 0.1081 - hamming_loss: 0.0245 - val_loss: 0.4701 - val_hamming_loss: 0.1643\nEpoch 25/100\n6/6 - 0s - loss: 0.1014 - hamming_loss: 0.0201 - val_loss: 0.4867 - val_hamming_loss: 0.1678\nEpoch 26/100\n6/6 - 0s - loss: 0.0953 - hamming_loss: 0.0188 - val_loss: 0.4735 - val_hamming_loss: 0.1652\nEpoch 27/100\n6/6 - 0s - loss: 0.0905 - hamming_loss: 0.0201 - val_loss: 0.4778 - val_hamming_loss: 0.1635\nEpoch 28/100\n6/6 - 0s - loss: 0.0847 - hamming_loss: 0.0188 - val_loss: 0.4841 - val_hamming_loss: 0.1678\nEpoch 29/100\n6/6 - 0s - loss: 0.0785 - hamming_loss: 0.0175 - val_loss: 0.4895 - val_hamming_loss: 0.1617\nEpoch 30/100\n6/6 - 0s - loss: 0.0739 - hamming_loss: 0.0144 - val_loss: 0.5127 - val_hamming_loss: 0.1678\nEpoch 31/100\n6/6 - 0s - loss: 0.0701 - hamming_loss: 0.0122 - val_loss: 0.5200 - val_hamming_loss: 0.1696\nEpoch 32/100\n6/6 - 0s - loss: 0.0659 - hamming_loss: 0.0092 - val_loss: 0.5120 - val_hamming_loss: 0.1643\nEpoch 33/100\n6/6 - 0s - loss: 0.0616 - hamming_loss: 0.0092 - val_loss: 0.5221 - val_hamming_loss: 0.1678\nEpoch 34/100\n6/6 - 0s - loss: 0.0580 - hamming_loss: 0.0083 - val_loss: 0.5252 - val_hamming_loss: 0.1678\nEpoch 35/100\n6/6 - 0s - loss: 0.0544 - hamming_loss: 0.0070 - val_loss: 0.5308 - val_hamming_loss: 0.1635\nEpoch 36/100\n6/6 - 0s - loss: 0.0512 - hamming_loss: 0.0066 - val_loss: 0.5415 - val_hamming_loss: 0.1635\nEpoch 37/100\n6/6 - 0s - loss: 0.0483 - hamming_loss: 0.0052 - val_loss: 0.5476 - val_hamming_loss: 0.1635\nEpoch 38/100\n6/6 - 0s - loss: 0.0459 - hamming_loss: 0.0039 - val_loss: 0.5558 - val_hamming_loss: 0.1635\nEpoch 39/100\n6/6 - 0s - loss: 0.0435 - hamming_loss: 0.0052 - val_loss: 0.5556 - val_hamming_loss: 0.1652\nEpoch 40/100\n6/6 - 0s - loss: 0.0413 - hamming_loss: 0.0035 - val_loss: 0.5556 - val_hamming_loss: 0.1626\nEpoch 41/100\n6/6 - 0s - loss: 0.0393 - hamming_loss: 0.0031 - val_loss: 0.5702 - val_hamming_loss: 0.1626\nEpoch 42/100\n6/6 - 0s - loss: 0.0378 - hamming_loss: 0.0022 - val_loss: 0.5764 - val_hamming_loss: 0.1643\nEpoch 43/100\n6/6 - 0s - loss: 0.0363 - hamming_loss: 0.0022 - val_loss: 0.5775 - val_hamming_loss: 0.1661\nEpoch 44/100\n6/6 - 0s - loss: 0.0347 - hamming_loss: 0.0013 - val_loss: 0.5779 - val_hamming_loss: 0.1652\nEpoch 45/100\n6/6 - 0s - loss: 0.0332 - hamming_loss: 0.0017 - val_loss: 0.5786 - val_hamming_loss: 0.1635\nEpoch 46/100\n6/6 - 0s - loss: 0.0319 - hamming_loss: 0.0017 - val_loss: 0.5799 - val_hamming_loss: 0.1608\nEpoch 47/100\n6/6 - 0s - loss: 0.0306 - hamming_loss: 0.0013 - val_loss: 0.5865 - val_hamming_loss: 0.1591\nEpoch 48/100\n6/6 - 0s - loss: 0.0295 - hamming_loss: 0.0013 - val_loss: 0.5915 - val_hamming_loss: 0.1643\nEpoch 49/100\n6/6 - 0s - loss: 0.0285 - hamming_loss: 0.0013 - val_loss: 0.5916 - val_hamming_loss: 0.1652\nEpoch 50/100\n6/6 - 0s - loss: 0.0273 - hamming_loss: 8.7413e-04 - val_loss: 0.5947 - val_hamming_loss: 0.1617\nEpoch 51/100\n6/6 - 0s - loss: 0.0267 - hamming_loss: 0.0013 - val_loss: 0.5986 - val_hamming_loss: 0.1626\nEpoch 52/100\n6/6 - 0s - loss: 0.0255 - hamming_loss: 8.7413e-04 - val_loss: 0.6050 - val_hamming_loss: 0.1678\nEpoch 53/100\n6/6 - 0s - loss: 0.0246 - hamming_loss: 8.7413e-04 - val_loss: 0.6124 - val_hamming_loss: 0.1652\nEpoch 54/100\n6/6 - 0s - loss: 0.0235 - hamming_loss: 4.3706e-04 - val_loss: 0.6159 - val_hamming_loss: 0.1705\nEpoch 55/100\n6/6 - 0s - loss: 0.0226 - hamming_loss: 4.3706e-04 - val_loss: 0.6195 - val_hamming_loss: 0.1635\nEpoch 56/100\n6/6 - 0s - loss: 0.0219 - hamming_loss: 4.3706e-04 - val_loss: 0.6227 - val_hamming_loss: 0.1643\nEpoch 57/100\n6/6 - 0s - loss: 0.0211 - hamming_loss: 4.3706e-04 - val_loss: 0.6252 - val_hamming_loss: 0.1643\nEpoch 58/100\n6/6 - 0s - loss: 0.0205 - hamming_loss: 4.3706e-04 - val_loss: 0.6296 - val_hamming_loss: 0.1652\nEpoch 59/100\n6/6 - 0s - loss: 0.0198 - hamming_loss: 4.3706e-04 - val_loss: 0.6377 - val_hamming_loss: 0.1713\nEpoch 60/100\n6/6 - 0s - loss: 0.0192 - hamming_loss: 4.3706e-04 - val_loss: 0.6345 - val_hamming_loss: 0.1705\nEpoch 61/100\n6/6 - 0s - loss: 0.0186 - hamming_loss: 4.3706e-04 - val_loss: 0.6369 - val_hamming_loss: 0.1713\nEpoch 62/100\n6/6 - 0s - loss: 0.0181 - hamming_loss: 4.3706e-04 - val_loss: 0.6424 - val_hamming_loss: 0.1705\nEpoch 63/100\n6/6 - 0s - loss: 0.0176 - hamming_loss: 4.3706e-04 - val_loss: 0.6431 - val_hamming_loss: 0.1696\nEpoch 64/100\n6/6 - 0s - loss: 0.0171 - hamming_loss: 4.3706e-04 - val_loss: 0.6480 - val_hamming_loss: 0.1722\nEpoch 65/100\n6/6 - 0s - loss: 0.0167 - hamming_loss: 4.3706e-04 - val_loss: 0.6563 - val_hamming_loss: 0.1687\nEpoch 66/100\n6/6 - 0s - loss: 0.0162 - hamming_loss: 4.3706e-04 - val_loss: 0.6620 - val_hamming_loss: 0.1705\nEpoch 67/100\n6/6 - 0s - loss: 0.0158 - hamming_loss: 4.3706e-04 - val_loss: 0.6650 - val_hamming_loss: 0.1687\nEpoch 68/100\n6/6 - 0s - loss: 0.0153 - hamming_loss: 4.3706e-04 - val_loss: 0.6666 - val_hamming_loss: 0.1696\nEpoch 69/100\n6/6 - 0s - loss: 0.0149 - hamming_loss: 4.3706e-04 - val_loss: 0.6730 - val_hamming_loss: 0.1670\nEpoch 70/100\n6/6 - 0s - loss: 0.0145 - hamming_loss: 4.3706e-04 - val_loss: 0.6749 - val_hamming_loss: 0.1696\nEpoch 71/100\n6/6 - 0s - loss: 0.0143 - hamming_loss: 4.3706e-04 - val_loss: 0.6782 - val_hamming_loss: 0.1678\nEpoch 72/100\n6/6 - 0s - loss: 0.0138 - hamming_loss: 4.3706e-04 - val_loss: 0.6845 - val_hamming_loss: 0.1687\nEpoch 73/100\n6/6 - 0s - loss: 0.0135 - hamming_loss: 4.3706e-04 - val_loss: 0.6838 - val_hamming_loss: 0.1687\nEpoch 74/100\n6/6 - 0s - loss: 0.0131 - hamming_loss: 4.3706e-04 - val_loss: 0.6846 - val_hamming_loss: 0.1670\nEpoch 75/100\n6/6 - 0s - loss: 0.0128 - hamming_loss: 4.3706e-04 - val_loss: 0.6935 - val_hamming_loss: 0.1705\nEpoch 76/100\n6/6 - 0s - loss: 0.0125 - hamming_loss: 4.3706e-04 - val_loss: 0.6937 - val_hamming_loss: 0.1696\nEpoch 77/100\n6/6 - 0s - loss: 0.0122 - hamming_loss: 4.3706e-04 - val_loss: 0.6938 - val_hamming_loss: 0.1670\nEpoch 78/100\n6/6 - 0s - loss: 0.0119 - hamming_loss: 4.3706e-04 - val_loss: 0.7017 - val_hamming_loss: 0.1687\nEpoch 79/100\n6/6 - 0s - loss: 0.0116 - hamming_loss: 0.0000e+00 - val_loss: 0.7070 - val_hamming_loss: 0.1705\nEpoch 80/100\n6/6 - 0s - loss: 0.0114 - hamming_loss: 4.3706e-04 - val_loss: 0.7072 - val_hamming_loss: 0.1670\nEpoch 81/100\n6/6 - 0s - loss: 0.0111 - hamming_loss: 4.3706e-04 - val_loss: 0.7083 - val_hamming_loss: 0.1722\nEpoch 82/100\n6/6 - 0s - loss: 0.0109 - hamming_loss: 4.3706e-04 - val_loss: 0.7100 - val_hamming_loss: 0.1722\nEpoch 83/100\n6/6 - 0s - loss: 0.0106 - hamming_loss: 0.0000e+00 - val_loss: 0.7143 - val_hamming_loss: 0.1713\nEpoch 84/100\n6/6 - 0s - loss: 0.0104 - hamming_loss: 0.0000e+00 - val_loss: 0.7158 - val_hamming_loss: 0.1740\nEpoch 85/100\n6/6 - 0s - loss: 0.0102 - hamming_loss: 0.0000e+00 - val_loss: 0.7199 - val_hamming_loss: 0.1740\nEpoch 86/100\n6/6 - 0s - loss: 0.0100 - hamming_loss: 0.0000e+00 - val_loss: 0.7226 - val_hamming_loss: 0.1713\nEpoch 87/100\n6/6 - 0s - loss: 0.0097 - hamming_loss: 0.0000e+00 - val_loss: 0.7239 - val_hamming_loss: 0.1705\nEpoch 88/100\n6/6 - 0s - loss: 0.0095 - hamming_loss: 0.0000e+00 - val_loss: 0.7277 - val_hamming_loss: 0.1748\nEpoch 89/100\n6/6 - 0s - loss: 0.0094 - hamming_loss: 0.0000e+00 - val_loss: 0.7301 - val_hamming_loss: 0.1731\nEpoch 90/100\n6/6 - 0s - loss: 0.0092 - hamming_loss: 0.0000e+00 - val_loss: 0.7343 - val_hamming_loss: 0.1713\nEpoch 91/100\n6/6 - 0s - loss: 0.0090 - hamming_loss: 0.0000e+00 - val_loss: 0.7359 - val_hamming_loss: 0.1687\nEpoch 92/100\n6/6 - 0s - loss: 0.0088 - hamming_loss: 0.0000e+00 - val_loss: 0.7389 - val_hamming_loss: 0.1705\nEpoch 93/100\n6/6 - 0s - loss: 0.0087 - hamming_loss: 0.0000e+00 - val_loss: 0.7400 - val_hamming_loss: 0.1687\nEpoch 94/100\n6/6 - 0s - loss: 0.0085 - hamming_loss: 0.0000e+00 - val_loss: 0.7454 - val_hamming_loss: 0.1713\nEpoch 95/100\n6/6 - 0s - loss: 0.0084 - hamming_loss: 0.0000e+00 - val_loss: 0.7423 - val_hamming_loss: 0.1705\nEpoch 96/100\n6/6 - 0s - loss: 0.0083 - hamming_loss: 0.0000e+00 - val_loss: 0.7469 - val_hamming_loss: 0.1696\nEpoch 97/100\n6/6 - 0s - loss: 0.0081 - hamming_loss: 0.0000e+00 - val_loss: 0.7465 - val_hamming_loss: 0.1696\nEpoch 98/100\n6/6 - 0s - loss: 0.0080 - hamming_loss: 0.0000e+00 - val_loss: 0.7377 - val_hamming_loss: 0.1696\nEpoch 99/100\n6/6 - 0s - loss: 0.0079 - hamming_loss: 0.0000e+00 - val_loss: 0.7567 - val_hamming_loss: 0.1748\nEpoch 100/100\n6/6 - 0s - loss: 0.0077 - hamming_loss: 0.0000e+00 - val_loss: 0.7553 - val_hamming_loss: 0.1678\n" ], [ "## (CAUTION: DO NOT OVERWRITE EXISTING FILES) -- Convert training history to dataframe and write to a .json file\nhistory_ce_RNN_lr001_df = pd.DataFrame(history_ce_RNN_lr001.history)\n#with open(\"Reduced Data Eval Metrics/Cross Entropy RNN/history_ce_RNN_lr0001.json\", \"w\") as outfile: \n# history_ce_RNN_lr001_df.to_json(outfile)", "_____no_output_____" ], [ "## Learn a threshold function and save the test error for use in future DF\nY_train_pred = model_ce_biLSTM.predict(train_padded_hasLabel)\nY_test_pred = model_ce_biLSTM.predict(test_padded_hasLabel)\nt_range = (0, 1)\n\ntest_labels_binary, threshold_function = predict_test_labels_binary(Y_train_pred, Y_train_hasLabel, Y_test_pred, t_range)\nce_RNN_withThreshold = metrics.hamming_loss(Y_test_hasLabel, test_labels_binary)", "_____no_output_____" ], [ "## (CAUTION: DO NOT OVERWRITE EXISTING FILES) -- Collect the test set hamming losses for the models \n## with learned threshold functions into a df and write to .json file\nval_hamming_loss_withThreshold_lr001_df = pd.DataFrame({'ce_FF_lr0001' : ce_FF_withThreshold,\n 'bpmll_FF_lr0001' : bpmll_FF_withThreshold,\n 'ce_RNN_lr0001' : ce_RNN_withThreshold,\n 'bpmll_RNN_lr0001' : bpmll_RNN_withThreshold},\n index = [0])\n\n#with open(\"Reduced Data Eval Metrics/val_hamming_loss_withThreshold_lr0001.json\", \"w\") as outfile: \n# val_hamming_loss_withThreshold_lr001_df.to_json(outfile)", "_____no_output_____" ], [ "val_hamming_loss_withThreshold_lr001_df", "_____no_output_____" ] ], [ [ "## Models on Full Dataset (some instances have no labels)", "_____no_output_____" ] ], [ [ "## Load the full tfidf dataset\nfile_object = open('../BP-MLL Text Categorization/tfidf_trainTest_data.json',)\ntfidf_data_full = json.load(file_object)\nX_train = np.array(tfidf_data_full['X_train'])\nX_test = np.array(tfidf_data_full['X_test'])\nY_train = np.array(tfidf_data_full['Y_train'])\nY_test = np.array(tfidf_data_full['Y_test'])", "_____no_output_____" ] ], [ [ "### Feed-Forward Cross-Entropy Network", "_____no_output_____" ] ], [ [ "## Use same architecture as the previous cross-entropy feed-forward network and train on full dataset\ntf.random.set_seed(123)\nnum_labels = 13\n\nmodel_ce_FF_full = tf.keras.models.Sequential([\n tf.keras.layers.Dense(32, activation = 'relu'),\n tf.keras.layers.Dropout(0.5),\n tf.keras.layers.Dense(num_labels, activation = 'sigmoid')\n])\n\noptim_func = tf.keras.optimizers.Adam(lr = 0.0001)\n\nmodel_ce_FF_full.compile(optimizer = optim_func,\n loss = 'binary_crossentropy', metrics = metric\n )", "_____no_output_____" ], [ "tf.random.set_seed(123)\nhistory_ce_FF_lr001_full = model_ce_FF_full.fit(X_train, Y_train, epochs = 100,\n validation_data = (X_test, Y_test), verbose=2)", "Epoch 1/100\n7/7 - 1s - loss: 0.7023 - hamming_loss: 0.3895 - val_loss: 0.6944 - val_hamming_loss: 0.4808\nEpoch 2/100\n7/7 - 0s - loss: 0.7009 - hamming_loss: 0.4738 - val_loss: 0.6923 - val_hamming_loss: 0.4728\nEpoch 3/100\n7/7 - 0s - loss: 0.7003 - hamming_loss: 0.4762 - val_loss: 0.6902 - val_hamming_loss: 0.4663\nEpoch 4/100\n7/7 - 0s - loss: 0.6940 - hamming_loss: 0.4592 - val_loss: 0.6881 - val_hamming_loss: 0.4607\nEpoch 5/100\n7/7 - 0s - loss: 0.6914 - hamming_loss: 0.4592 - val_loss: 0.6860 - val_hamming_loss: 0.4511\nEpoch 6/100\n7/7 - 0s - loss: 0.6892 - hamming_loss: 0.4496 - val_loss: 0.6840 - val_hamming_loss: 0.4431\nEpoch 7/100\n7/7 - 0s - loss: 0.6862 - hamming_loss: 0.4437 - val_loss: 0.6820 - val_hamming_loss: 0.4343\nEpoch 8/100\n7/7 - 0s - loss: 0.6767 - hamming_loss: 0.4211 - val_loss: 0.6800 - val_hamming_loss: 0.4271\nEpoch 9/100\n7/7 - 0s - loss: 0.6723 - hamming_loss: 0.4132 - val_loss: 0.6781 - val_hamming_loss: 0.4183\nEpoch 10/100\n7/7 - 0s - loss: 0.6712 - hamming_loss: 0.4096 - val_loss: 0.6763 - val_hamming_loss: 0.4119\nEpoch 11/100\n7/7 - 0s - loss: 0.6707 - hamming_loss: 0.4029 - val_loss: 0.6745 - val_hamming_loss: 0.4062\nEpoch 12/100\n7/7 - 0s - loss: 0.6704 - hamming_loss: 0.4048 - val_loss: 0.6727 - val_hamming_loss: 0.4030\nEpoch 13/100\n7/7 - 0s - loss: 0.6698 - hamming_loss: 0.4076 - val_loss: 0.6709 - val_hamming_loss: 0.3958\nEpoch 14/100\n7/7 - 0s - loss: 0.6630 - hamming_loss: 0.3838 - val_loss: 0.6691 - val_hamming_loss: 0.3926\nEpoch 15/100\n7/7 - 0s - loss: 0.6594 - hamming_loss: 0.3767 - val_loss: 0.6673 - val_hamming_loss: 0.3886\nEpoch 16/100\n7/7 - 0s - loss: 0.6486 - hamming_loss: 0.3672 - val_loss: 0.6655 - val_hamming_loss: 0.3814\nEpoch 17/100\n7/7 - 0s - loss: 0.6517 - hamming_loss: 0.3620 - val_loss: 0.6637 - val_hamming_loss: 0.3742\nEpoch 18/100\n7/7 - 0s - loss: 0.6466 - hamming_loss: 0.3501 - val_loss: 0.6619 - val_hamming_loss: 0.3710\nEpoch 19/100\n7/7 - 0s - loss: 0.6440 - hamming_loss: 0.3505 - val_loss: 0.6601 - val_hamming_loss: 0.3678\nEpoch 20/100\n7/7 - 0s - loss: 0.6397 - hamming_loss: 0.3351 - val_loss: 0.6584 - val_hamming_loss: 0.3582\nEpoch 21/100\n7/7 - 0s - loss: 0.6379 - hamming_loss: 0.3442 - val_loss: 0.6566 - val_hamming_loss: 0.3542\nEpoch 22/100\n7/7 - 0s - loss: 0.6332 - hamming_loss: 0.3366 - val_loss: 0.6547 - val_hamming_loss: 0.3478\nEpoch 23/100\n7/7 - 0s - loss: 0.6328 - hamming_loss: 0.3295 - val_loss: 0.6529 - val_hamming_loss: 0.3446\nEpoch 24/100\n7/7 - 0s - loss: 0.6347 - hamming_loss: 0.3402 - val_loss: 0.6510 - val_hamming_loss: 0.3429\nEpoch 25/100\n7/7 - 0s - loss: 0.6305 - hamming_loss: 0.3335 - val_loss: 0.6492 - val_hamming_loss: 0.3429\nEpoch 26/100\n7/7 - 0s - loss: 0.6248 - hamming_loss: 0.3168 - val_loss: 0.6473 - val_hamming_loss: 0.3365\nEpoch 27/100\n7/7 - 0s - loss: 0.6230 - hamming_loss: 0.3081 - val_loss: 0.6454 - val_hamming_loss: 0.3309\nEpoch 28/100\n7/7 - 0s - loss: 0.6223 - hamming_loss: 0.3152 - val_loss: 0.6436 - val_hamming_loss: 0.3245\nEpoch 29/100\n7/7 - 0s - loss: 0.6151 - hamming_loss: 0.3109 - val_loss: 0.6417 - val_hamming_loss: 0.3229\nEpoch 30/100\n7/7 - 0s - loss: 0.6134 - hamming_loss: 0.3037 - val_loss: 0.6397 - val_hamming_loss: 0.3197\nEpoch 31/100\n7/7 - 0s - loss: 0.6110 - hamming_loss: 0.2922 - val_loss: 0.6378 - val_hamming_loss: 0.3157\nEpoch 32/100\n7/7 - 0s - loss: 0.6054 - hamming_loss: 0.2934 - val_loss: 0.6358 - val_hamming_loss: 0.3077\nEpoch 33/100\n7/7 - 0s - loss: 0.6090 - hamming_loss: 0.2835 - val_loss: 0.6339 - val_hamming_loss: 0.3053\nEpoch 34/100\n7/7 - 0s - loss: 0.5966 - hamming_loss: 0.2807 - val_loss: 0.6320 - val_hamming_loss: 0.3013\nEpoch 35/100\n7/7 - 0s - loss: 0.6028 - hamming_loss: 0.2807 - val_loss: 0.6301 - val_hamming_loss: 0.2989\nEpoch 36/100\n7/7 - 0s - loss: 0.6033 - hamming_loss: 0.2902 - val_loss: 0.6282 - val_hamming_loss: 0.2973\nEpoch 37/100\n7/7 - 0s - loss: 0.5909 - hamming_loss: 0.2760 - val_loss: 0.6262 - val_hamming_loss: 0.2965\nEpoch 38/100\n7/7 - 0s - loss: 0.5904 - hamming_loss: 0.2724 - val_loss: 0.6242 - val_hamming_loss: 0.2925\nEpoch 39/100\n7/7 - 0s - loss: 0.5874 - hamming_loss: 0.2661 - val_loss: 0.6223 - val_hamming_loss: 0.2909\nEpoch 40/100\n7/7 - 0s - loss: 0.5800 - hamming_loss: 0.2613 - val_loss: 0.6203 - val_hamming_loss: 0.2885\nEpoch 41/100\n7/7 - 0s - loss: 0.5808 - hamming_loss: 0.2661 - val_loss: 0.6182 - val_hamming_loss: 0.2861\nEpoch 42/100\n7/7 - 0s - loss: 0.5803 - hamming_loss: 0.2577 - val_loss: 0.6162 - val_hamming_loss: 0.2829\nEpoch 43/100\n7/7 - 0s - loss: 0.5782 - hamming_loss: 0.2581 - val_loss: 0.6143 - val_hamming_loss: 0.2804\nEpoch 44/100\n7/7 - 0s - loss: 0.5760 - hamming_loss: 0.2577 - val_loss: 0.6124 - val_hamming_loss: 0.2772\nEpoch 45/100\n7/7 - 0s - loss: 0.5734 - hamming_loss: 0.2466 - val_loss: 0.6105 - val_hamming_loss: 0.2756\nEpoch 46/100\n7/7 - 0s - loss: 0.5699 - hamming_loss: 0.2375 - val_loss: 0.6086 - val_hamming_loss: 0.2740\nEpoch 47/100\n7/7 - 0s - loss: 0.5646 - hamming_loss: 0.2446 - val_loss: 0.6066 - val_hamming_loss: 0.2732\nEpoch 48/100\n7/7 - 0s - loss: 0.5700 - hamming_loss: 0.2542 - val_loss: 0.6046 - val_hamming_loss: 0.2724\nEpoch 49/100\n7/7 - 0s - loss: 0.5602 - hamming_loss: 0.2431 - val_loss: 0.6026 - val_hamming_loss: 0.2700\nEpoch 50/100\n7/7 - 0s - loss: 0.5564 - hamming_loss: 0.2395 - val_loss: 0.6005 - val_hamming_loss: 0.2676\nEpoch 51/100\n7/7 - 0s - loss: 0.5556 - hamming_loss: 0.2486 - val_loss: 0.5984 - val_hamming_loss: 0.2668\nEpoch 52/100\n7/7 - 0s - loss: 0.5512 - hamming_loss: 0.2272 - val_loss: 0.5962 - val_hamming_loss: 0.2644\nEpoch 53/100\n7/7 - 0s - loss: 0.5473 - hamming_loss: 0.2335 - val_loss: 0.5941 - val_hamming_loss: 0.2628\nEpoch 54/100\n7/7 - 0s - loss: 0.5480 - hamming_loss: 0.2367 - val_loss: 0.5920 - val_hamming_loss: 0.2604\nEpoch 55/100\n7/7 - 0s - loss: 0.5358 - hamming_loss: 0.2209 - val_loss: 0.5898 - val_hamming_loss: 0.2588\nEpoch 56/100\n7/7 - 0s - loss: 0.5429 - hamming_loss: 0.2300 - val_loss: 0.5878 - val_hamming_loss: 0.2572\nEpoch 57/100\n7/7 - 0s - loss: 0.5358 - hamming_loss: 0.2228 - val_loss: 0.5857 - val_hamming_loss: 0.2564\nEpoch 58/100\n7/7 - 0s - loss: 0.5319 - hamming_loss: 0.2177 - val_loss: 0.5835 - val_hamming_loss: 0.2548\nEpoch 59/100\n7/7 - 0s - loss: 0.5348 - hamming_loss: 0.2236 - val_loss: 0.5814 - val_hamming_loss: 0.2532\nEpoch 60/100\n7/7 - 0s - loss: 0.5277 - hamming_loss: 0.2197 - val_loss: 0.5794 - val_hamming_loss: 0.2516\nEpoch 61/100\n7/7 - 0s - loss: 0.5287 - hamming_loss: 0.2165 - val_loss: 0.5774 - val_hamming_loss: 0.2468\nEpoch 62/100\n7/7 - 0s - loss: 0.5305 - hamming_loss: 0.2228 - val_loss: 0.5754 - val_hamming_loss: 0.2452\nEpoch 63/100\n7/7 - 0s - loss: 0.5137 - hamming_loss: 0.2105 - val_loss: 0.5734 - val_hamming_loss: 0.2444\nEpoch 64/100\n7/7 - 0s - loss: 0.5194 - hamming_loss: 0.2149 - val_loss: 0.5714 - val_hamming_loss: 0.2444\nEpoch 65/100\n7/7 - 0s - loss: 0.5295 - hamming_loss: 0.2320 - val_loss: 0.5695 - val_hamming_loss: 0.2396\nEpoch 66/100\n7/7 - 0s - loss: 0.5144 - hamming_loss: 0.2141 - val_loss: 0.5675 - val_hamming_loss: 0.2372\nEpoch 67/100\n7/7 - 0s - loss: 0.5127 - hamming_loss: 0.2006 - val_loss: 0.5656 - val_hamming_loss: 0.2340\nEpoch 68/100\n7/7 - 0s - loss: 0.5035 - hamming_loss: 0.2050 - val_loss: 0.5636 - val_hamming_loss: 0.2316\nEpoch 69/100\n7/7 - 0s - loss: 0.5062 - hamming_loss: 0.2070 - val_loss: 0.5617 - val_hamming_loss: 0.2292\nEpoch 70/100\n7/7 - 0s - loss: 0.5077 - hamming_loss: 0.2090 - val_loss: 0.5597 - val_hamming_loss: 0.2284\nEpoch 71/100\n7/7 - 0s - loss: 0.5069 - hamming_loss: 0.2034 - val_loss: 0.5577 - val_hamming_loss: 0.2276\nEpoch 72/100\n7/7 - 0s - loss: 0.5016 - hamming_loss: 0.1990 - val_loss: 0.5557 - val_hamming_loss: 0.2268\nEpoch 73/100\n7/7 - 0s - loss: 0.5043 - hamming_loss: 0.2018 - val_loss: 0.5537 - val_hamming_loss: 0.2276\nEpoch 74/100\n7/7 - 0s - loss: 0.4894 - hamming_loss: 0.1967 - val_loss: 0.5517 - val_hamming_loss: 0.2260\nEpoch 75/100\n7/7 - 0s - loss: 0.4957 - hamming_loss: 0.1975 - val_loss: 0.5498 - val_hamming_loss: 0.2252\nEpoch 76/100\n7/7 - 0s - loss: 0.4910 - hamming_loss: 0.1955 - val_loss: 0.5479 - val_hamming_loss: 0.2236\nEpoch 77/100\n7/7 - 0s - loss: 0.4825 - hamming_loss: 0.1852 - val_loss: 0.5461 - val_hamming_loss: 0.2220\nEpoch 78/100\n7/7 - 0s - loss: 0.4847 - hamming_loss: 0.1907 - val_loss: 0.5444 - val_hamming_loss: 0.2179\nEpoch 79/100\n7/7 - 0s - loss: 0.4894 - hamming_loss: 0.1899 - val_loss: 0.5425 - val_hamming_loss: 0.2171\nEpoch 80/100\n7/7 - 0s - loss: 0.4767 - hamming_loss: 0.1899 - val_loss: 0.5408 - val_hamming_loss: 0.2171\nEpoch 81/100\n7/7 - 0s - loss: 0.4819 - hamming_loss: 0.1872 - val_loss: 0.5390 - val_hamming_loss: 0.2163\nEpoch 82/100\n7/7 - 0s - loss: 0.4748 - hamming_loss: 0.1923 - val_loss: 0.5373 - val_hamming_loss: 0.2139\nEpoch 83/100\n7/7 - 0s - loss: 0.4732 - hamming_loss: 0.1860 - val_loss: 0.5355 - val_hamming_loss: 0.2131\nEpoch 84/100\n7/7 - 0s - loss: 0.4701 - hamming_loss: 0.1935 - val_loss: 0.5337 - val_hamming_loss: 0.2115\nEpoch 85/100\n7/7 - 0s - loss: 0.4691 - hamming_loss: 0.1875 - val_loss: 0.5319 - val_hamming_loss: 0.2099\nEpoch 86/100\n7/7 - 0s - loss: 0.4667 - hamming_loss: 0.1737 - val_loss: 0.5301 - val_hamming_loss: 0.2099\nEpoch 87/100\n7/7 - 0s - loss: 0.4622 - hamming_loss: 0.1745 - val_loss: 0.5283 - val_hamming_loss: 0.2059\nEpoch 88/100\n7/7 - 0s - loss: 0.4554 - hamming_loss: 0.1745 - val_loss: 0.5265 - val_hamming_loss: 0.2051\nEpoch 89/100\n7/7 - 0s - loss: 0.4682 - hamming_loss: 0.1832 - val_loss: 0.5248 - val_hamming_loss: 0.2043\nEpoch 90/100\n7/7 - 0s - loss: 0.4532 - hamming_loss: 0.1737 - val_loss: 0.5231 - val_hamming_loss: 0.2019\nEpoch 91/100\n7/7 - 0s - loss: 0.4563 - hamming_loss: 0.1725 - val_loss: 0.5213 - val_hamming_loss: 0.2019\nEpoch 92/100\n7/7 - 0s - loss: 0.4572 - hamming_loss: 0.1804 - val_loss: 0.5196 - val_hamming_loss: 0.2019\nEpoch 93/100\n7/7 - 0s - loss: 0.4501 - hamming_loss: 0.1697 - val_loss: 0.5180 - val_hamming_loss: 0.2011\nEpoch 94/100\n7/7 - 0s - loss: 0.4447 - hamming_loss: 0.1705 - val_loss: 0.5163 - val_hamming_loss: 0.2011\nEpoch 95/100\n7/7 - 0s - loss: 0.4420 - hamming_loss: 0.1721 - val_loss: 0.5146 - val_hamming_loss: 0.2003\nEpoch 96/100\n7/7 - 0s - loss: 0.4412 - hamming_loss: 0.1649 - val_loss: 0.5130 - val_hamming_loss: 0.2003\nEpoch 97/100\n7/7 - 0s - loss: 0.4385 - hamming_loss: 0.1701 - val_loss: 0.5114 - val_hamming_loss: 0.1979\nEpoch 98/100\n7/7 - 0s - loss: 0.4309 - hamming_loss: 0.1602 - val_loss: 0.5098 - val_hamming_loss: 0.1955\nEpoch 99/100\n7/7 - 0s - loss: 0.4288 - hamming_loss: 0.1614 - val_loss: 0.5082 - val_hamming_loss: 0.1947\nEpoch 100/100\n7/7 - 0s - loss: 0.4349 - hamming_loss: 0.1598 - val_loss: 0.5066 - val_hamming_loss: 0.1939\n" ], [ "## (CAUTION: DO NOT OVERWRITE EXISTING FILES) -- Convert training history to dataframe and write to a .json file\nhistory_ce_FF_lr001_full_df = pd.DataFrame(history_ce_FF_lr001_full.history)\n#with open(\"Full Data Eval Metrics/Cross Entropy Feed Forward/history_ce_FF_lr0001_full.json\", \"w\") as outfile: \n# history_ce_FF_lr001_full_df.to_json(outfile)", "_____no_output_____" ], [ "## Learn a threshold function and save the test error for use in future DF\nY_train_pred = model_ce_FF_full.predict(X_train)\nY_test_pred = model_ce_FF_full.predict(X_test)\nt_range = (0, 1)\n\ntest_labels_binary, threshold_function = predict_test_labels_binary(Y_train_pred, Y_train, Y_test_pred, t_range)\nce_FF_full_withThreshold = metrics.hamming_loss(Y_test, test_labels_binary)", "_____no_output_____" ] ], [ [ "### LSTM Reccurrent Network", "_____no_output_____" ] ], [ [ "## Load the pre-processed data\nfile_object = open('../RNN Text Categorization/RNN_data_dict.json',)\nRNN_data_dict = json.load(file_object)\nRNN_data_dict = ast.literal_eval(RNN_data_dict)\ntrain_padded = np.array(RNN_data_dict['train_padded'])\ntest_padded = np.array(RNN_data_dict['test_padded'])\nY_train = np.array(RNN_data_dict['Y_train'])\nY_test = np.array(RNN_data_dict['Y_test'])", "_____no_output_____" ], [ "## Define the LSTM RNN architecture\ntf.random.set_seed(123)\nnum_labels = 13\n\nmodel_LSTM_full = tf.keras.models.Sequential([\n tf.keras.layers.Embedding(num_unique_words, 32, input_length = max_length),\n tf.keras.layers.LSTM(16, return_sequences = False, return_state = False),\n #tf.keras.layers.Dropout(0.5),\n tf.keras.layers.Dense(num_labels, activation = 'sigmoid')\n])\n\noptim_func = tf.keras.optimizers.Adam(lr = 0.0001)\n\nmodel_LSTM_full.compile(loss = 'binary_crossentropy', optimizer = optim_func, metrics = metric)", "_____no_output_____" ], [ "tf.random.set_seed(123)\nhistory_ce_RNN_lr001_full = model_LSTM_full.fit(train_padded, Y_train, epochs = 100, \n validation_data = (test_padded, Y_test), verbose=2)", "Epoch 1/100\n7/7 - 3s - loss: 0.6953 - hamming_loss: 0.5159 - val_loss: 0.6949 - val_hamming_loss: 0.5921\nEpoch 2/100\n7/7 - 0s - loss: 0.6944 - hamming_loss: 0.5948 - val_loss: 0.6940 - val_hamming_loss: 0.5921\nEpoch 3/100\n7/7 - 0s - loss: 0.6935 - hamming_loss: 0.5948 - val_loss: 0.6931 - val_hamming_loss: 0.5921\nEpoch 4/100\n7/7 - 0s - loss: 0.6926 - hamming_loss: 0.5956 - val_loss: 0.6922 - val_hamming_loss: 0.5585\nEpoch 5/100\n7/7 - 0s - loss: 0.6917 - hamming_loss: 0.5757 - val_loss: 0.6913 - val_hamming_loss: 0.5585\nEpoch 6/100\n7/7 - 0s - loss: 0.6908 - hamming_loss: 0.5757 - val_loss: 0.6904 - val_hamming_loss: 0.4960\nEpoch 7/100\n7/7 - 0s - loss: 0.6899 - hamming_loss: 0.4734 - val_loss: 0.6894 - val_hamming_loss: 0.4431\nEpoch 8/100\n7/7 - 0s - loss: 0.6889 - hamming_loss: 0.4187 - val_loss: 0.6885 - val_hamming_loss: 0.3421\nEpoch 9/100\n7/7 - 0s - loss: 0.6879 - hamming_loss: 0.3466 - val_loss: 0.6875 - val_hamming_loss: 0.3421\nEpoch 10/100\n7/7 - 0s - loss: 0.6870 - hamming_loss: 0.3466 - val_loss: 0.6864 - val_hamming_loss: 0.3421\nEpoch 11/100\n7/7 - 0s - loss: 0.6859 - hamming_loss: 0.3148 - val_loss: 0.6854 - val_hamming_loss: 0.2813\nEpoch 12/100\n7/7 - 0s - loss: 0.6848 - hamming_loss: 0.2879 - val_loss: 0.6843 - val_hamming_loss: 0.2813\nEpoch 13/100\n7/7 - 0s - loss: 0.6837 - hamming_loss: 0.2879 - val_loss: 0.6831 - val_hamming_loss: 0.2813\nEpoch 14/100\n7/7 - 0s - loss: 0.6825 - hamming_loss: 0.2879 - val_loss: 0.6818 - val_hamming_loss: 0.2813\nEpoch 15/100\n7/7 - 0s - loss: 0.6813 - hamming_loss: 0.2879 - val_loss: 0.6806 - val_hamming_loss: 0.2813\nEpoch 16/100\n7/7 - 0s - loss: 0.6800 - hamming_loss: 0.2879 - val_loss: 0.6792 - val_hamming_loss: 0.2813\nEpoch 17/100\n7/7 - 0s - loss: 0.6786 - hamming_loss: 0.2871 - val_loss: 0.6777 - val_hamming_loss: 0.2043\nEpoch 18/100\n7/7 - 0s - loss: 0.6770 - hamming_loss: 0.2109 - val_loss: 0.6760 - val_hamming_loss: 0.2043\nEpoch 19/100\n7/7 - 0s - loss: 0.6753 - hamming_loss: 0.2109 - val_loss: 0.6742 - val_hamming_loss: 0.2043\nEpoch 20/100\n7/7 - 0s - loss: 0.6735 - hamming_loss: 0.2109 - val_loss: 0.6722 - val_hamming_loss: 0.2043\nEpoch 21/100\n7/7 - 0s - loss: 0.6715 - hamming_loss: 0.2109 - val_loss: 0.6700 - val_hamming_loss: 0.2043\nEpoch 22/100\n7/7 - 0s - loss: 0.6691 - hamming_loss: 0.1907 - val_loss: 0.6675 - val_hamming_loss: 0.1723\nEpoch 23/100\n7/7 - 0s - loss: 0.6665 - hamming_loss: 0.1792 - val_loss: 0.6646 - val_hamming_loss: 0.1723\nEpoch 24/100\n7/7 - 0s - loss: 0.6635 - hamming_loss: 0.1792 - val_loss: 0.6614 - val_hamming_loss: 0.1723\nEpoch 25/100\n7/7 - 0s - loss: 0.6602 - hamming_loss: 0.1792 - val_loss: 0.6577 - val_hamming_loss: 0.1723\nEpoch 26/100\n7/7 - 0s - loss: 0.6564 - hamming_loss: 0.1792 - val_loss: 0.6535 - val_hamming_loss: 0.1723\nEpoch 27/100\n7/7 - 0s - loss: 0.6520 - hamming_loss: 0.1792 - val_loss: 0.6486 - val_hamming_loss: 0.1723\nEpoch 28/100\n7/7 - 0s - loss: 0.6468 - hamming_loss: 0.1792 - val_loss: 0.6430 - val_hamming_loss: 0.1723\nEpoch 29/100\n7/7 - 0s - loss: 0.6409 - hamming_loss: 0.1792 - val_loss: 0.6364 - val_hamming_loss: 0.1723\nEpoch 30/100\n7/7 - 0s - loss: 0.6342 - hamming_loss: 0.1792 - val_loss: 0.6289 - val_hamming_loss: 0.1723\nEpoch 31/100\n7/7 - 0s - loss: 0.6265 - hamming_loss: 0.1792 - val_loss: 0.6206 - val_hamming_loss: 0.1723\nEpoch 32/100\n7/7 - 0s - loss: 0.6181 - hamming_loss: 0.1792 - val_loss: 0.6117 - val_hamming_loss: 0.1723\nEpoch 33/100\n7/7 - 0s - loss: 0.6092 - hamming_loss: 0.1792 - val_loss: 0.6020 - val_hamming_loss: 0.1723\nEpoch 34/100\n7/7 - 0s - loss: 0.5998 - hamming_loss: 0.1792 - val_loss: 0.5925 - val_hamming_loss: 0.1723\nEpoch 35/100\n7/7 - 0s - loss: 0.5907 - hamming_loss: 0.1792 - val_loss: 0.5835 - val_hamming_loss: 0.1723\nEpoch 36/100\n7/7 - 0s - loss: 0.5823 - hamming_loss: 0.1792 - val_loss: 0.5756 - val_hamming_loss: 0.1723\nEpoch 37/100\n7/7 - 0s - loss: 0.5752 - hamming_loss: 0.1792 - val_loss: 0.5689 - val_hamming_loss: 0.1723\nEpoch 38/100\n7/7 - 0s - loss: 0.5693 - hamming_loss: 0.1792 - val_loss: 0.5634 - val_hamming_loss: 0.1723\nEpoch 39/100\n7/7 - 0s - loss: 0.5642 - hamming_loss: 0.1792 - val_loss: 0.5587 - val_hamming_loss: 0.1723\nEpoch 40/100\n7/7 - 0s - loss: 0.5599 - hamming_loss: 0.1792 - val_loss: 0.5546 - val_hamming_loss: 0.1723\nEpoch 41/100\n7/7 - 0s - loss: 0.5560 - hamming_loss: 0.1792 - val_loss: 0.5508 - val_hamming_loss: 0.1723\nEpoch 42/100\n7/7 - 0s - loss: 0.5523 - hamming_loss: 0.1792 - val_loss: 0.5472 - val_hamming_loss: 0.1723\nEpoch 43/100\n7/7 - 0s - loss: 0.5489 - hamming_loss: 0.1792 - val_loss: 0.5439 - val_hamming_loss: 0.1723\nEpoch 44/100\n7/7 - 0s - loss: 0.5458 - hamming_loss: 0.1792 - val_loss: 0.5408 - val_hamming_loss: 0.1723\nEpoch 45/100\n7/7 - 0s - loss: 0.5429 - hamming_loss: 0.1792 - val_loss: 0.5380 - val_hamming_loss: 0.1723\nEpoch 46/100\n7/7 - 0s - loss: 0.5401 - hamming_loss: 0.1792 - val_loss: 0.5353 - val_hamming_loss: 0.1723\nEpoch 47/100\n7/7 - 0s - loss: 0.5375 - hamming_loss: 0.1792 - val_loss: 0.5327 - val_hamming_loss: 0.1723\nEpoch 48/100\n7/7 - 0s - loss: 0.5349 - hamming_loss: 0.1792 - val_loss: 0.5301 - val_hamming_loss: 0.1723\nEpoch 49/100\n7/7 - 0s - loss: 0.5323 - hamming_loss: 0.1792 - val_loss: 0.5276 - val_hamming_loss: 0.1723\nEpoch 50/100\n7/7 - 0s - loss: 0.5298 - hamming_loss: 0.1792 - val_loss: 0.5250 - val_hamming_loss: 0.1723\nEpoch 51/100\n7/7 - 0s - loss: 0.5273 - hamming_loss: 0.1792 - val_loss: 0.5226 - val_hamming_loss: 0.1723\nEpoch 52/100\n7/7 - 0s - loss: 0.5249 - hamming_loss: 0.1792 - val_loss: 0.5203 - val_hamming_loss: 0.1723\nEpoch 53/100\n7/7 - 0s - loss: 0.5227 - hamming_loss: 0.1792 - val_loss: 0.5181 - val_hamming_loss: 0.1723\nEpoch 54/100\n7/7 - 0s - loss: 0.5206 - hamming_loss: 0.1792 - val_loss: 0.5159 - val_hamming_loss: 0.1723\nEpoch 55/100\n7/7 - 0s - loss: 0.5184 - hamming_loss: 0.1792 - val_loss: 0.5138 - val_hamming_loss: 0.1723\nEpoch 56/100\n7/7 - 0s - loss: 0.5164 - hamming_loss: 0.1792 - val_loss: 0.5119 - val_hamming_loss: 0.1723\nEpoch 57/100\n7/7 - 0s - loss: 0.5145 - hamming_loss: 0.1792 - val_loss: 0.5097 - val_hamming_loss: 0.1723\nEpoch 58/100\n7/7 - 0s - loss: 0.5124 - hamming_loss: 0.1792 - val_loss: 0.5077 - val_hamming_loss: 0.1723\nEpoch 59/100\n7/7 - 0s - loss: 0.5104 - hamming_loss: 0.1792 - val_loss: 0.5057 - val_hamming_loss: 0.1723\nEpoch 60/100\n7/7 - 0s - loss: 0.5085 - hamming_loss: 0.1792 - val_loss: 0.5038 - val_hamming_loss: 0.1723\nEpoch 61/100\n7/7 - 0s - loss: 0.5067 - hamming_loss: 0.1792 - val_loss: 0.5020 - val_hamming_loss: 0.1723\nEpoch 62/100\n7/7 - 0s - loss: 0.5049 - hamming_loss: 0.1792 - val_loss: 0.5002 - val_hamming_loss: 0.1723\nEpoch 63/100\n7/7 - 0s - loss: 0.5032 - hamming_loss: 0.1792 - val_loss: 0.4984 - val_hamming_loss: 0.1723\nEpoch 64/100\n7/7 - 0s - loss: 0.5014 - hamming_loss: 0.1792 - val_loss: 0.4967 - val_hamming_loss: 0.1723\nEpoch 65/100\n7/7 - 0s - loss: 0.4998 - hamming_loss: 0.1792 - val_loss: 0.4951 - val_hamming_loss: 0.1723\nEpoch 66/100\n7/7 - 0s - loss: 0.4981 - hamming_loss: 0.1792 - val_loss: 0.4934 - val_hamming_loss: 0.1723\nEpoch 67/100\n7/7 - 0s - loss: 0.4965 - hamming_loss: 0.1792 - val_loss: 0.4918 - val_hamming_loss: 0.1723\nEpoch 68/100\n7/7 - 0s - loss: 0.4949 - hamming_loss: 0.1792 - val_loss: 0.4902 - val_hamming_loss: 0.1723\nEpoch 69/100\n7/7 - 0s - loss: 0.4933 - hamming_loss: 0.1792 - val_loss: 0.4887 - val_hamming_loss: 0.1723\nEpoch 70/100\n7/7 - 0s - loss: 0.4918 - hamming_loss: 0.1792 - val_loss: 0.4872 - val_hamming_loss: 0.1723\nEpoch 71/100\n7/7 - 0s - loss: 0.4903 - hamming_loss: 0.1792 - val_loss: 0.4857 - val_hamming_loss: 0.1723\nEpoch 72/100\n7/7 - 0s - loss: 0.4888 - hamming_loss: 0.1792 - val_loss: 0.4842 - val_hamming_loss: 0.1723\nEpoch 73/100\n7/7 - 0s - loss: 0.4873 - hamming_loss: 0.1792 - val_loss: 0.4827 - val_hamming_loss: 0.1723\nEpoch 74/100\n7/7 - 0s - loss: 0.4858 - hamming_loss: 0.1792 - val_loss: 0.4812 - val_hamming_loss: 0.1723\nEpoch 75/100\n7/7 - 0s - loss: 0.4844 - hamming_loss: 0.1792 - val_loss: 0.4799 - val_hamming_loss: 0.1723\nEpoch 76/100\n7/7 - 0s - loss: 0.4831 - hamming_loss: 0.1792 - val_loss: 0.4785 - val_hamming_loss: 0.1723\nEpoch 77/100\n7/7 - 0s - loss: 0.4818 - hamming_loss: 0.1792 - val_loss: 0.4773 - val_hamming_loss: 0.1723\nEpoch 78/100\n7/7 - 0s - loss: 0.4806 - hamming_loss: 0.1792 - val_loss: 0.4761 - val_hamming_loss: 0.1723\nEpoch 79/100\n7/7 - 0s - loss: 0.4794 - hamming_loss: 0.1792 - val_loss: 0.4749 - val_hamming_loss: 0.1723\nEpoch 80/100\n7/7 - 0s - loss: 0.4782 - hamming_loss: 0.1792 - val_loss: 0.4738 - val_hamming_loss: 0.1723\nEpoch 81/100\n7/7 - 0s - loss: 0.4770 - hamming_loss: 0.1792 - val_loss: 0.4726 - val_hamming_loss: 0.1723\nEpoch 82/100\n7/7 - 0s - loss: 0.4759 - hamming_loss: 0.1792 - val_loss: 0.4715 - val_hamming_loss: 0.1723\nEpoch 83/100\n7/7 - 0s - loss: 0.4748 - hamming_loss: 0.1792 - val_loss: 0.4705 - val_hamming_loss: 0.1723\nEpoch 84/100\n7/7 - 0s - loss: 0.4736 - hamming_loss: 0.1792 - val_loss: 0.4694 - val_hamming_loss: 0.1723\nEpoch 85/100\n7/7 - 0s - loss: 0.4725 - hamming_loss: 0.1792 - val_loss: 0.4684 - val_hamming_loss: 0.1723\nEpoch 86/100\n7/7 - 0s - loss: 0.4714 - hamming_loss: 0.1792 - val_loss: 0.4673 - val_hamming_loss: 0.1723\nEpoch 87/100\n7/7 - 0s - loss: 0.4704 - hamming_loss: 0.1792 - val_loss: 0.4663 - val_hamming_loss: 0.1723\nEpoch 88/100\n7/7 - 0s - loss: 0.4693 - hamming_loss: 0.1792 - val_loss: 0.4653 - val_hamming_loss: 0.1723\nEpoch 89/100\n7/7 - 0s - loss: 0.4682 - hamming_loss: 0.1792 - val_loss: 0.4643 - val_hamming_loss: 0.1723\nEpoch 90/100\n7/7 - 0s - loss: 0.4672 - hamming_loss: 0.1792 - val_loss: 0.4633 - val_hamming_loss: 0.1723\nEpoch 91/100\n7/7 - 0s - loss: 0.4662 - hamming_loss: 0.1792 - val_loss: 0.4624 - val_hamming_loss: 0.1723\nEpoch 92/100\n7/7 - 0s - loss: 0.4652 - hamming_loss: 0.1792 - val_loss: 0.4615 - val_hamming_loss: 0.1723\nEpoch 93/100\n7/7 - 0s - loss: 0.4643 - hamming_loss: 0.1792 - val_loss: 0.4607 - val_hamming_loss: 0.1723\nEpoch 94/100\n7/7 - 0s - loss: 0.4633 - hamming_loss: 0.1792 - val_loss: 0.4598 - val_hamming_loss: 0.1723\nEpoch 95/100\n7/7 - 0s - loss: 0.4624 - hamming_loss: 0.1792 - val_loss: 0.4590 - val_hamming_loss: 0.1723\nEpoch 96/100\n7/7 - 0s - loss: 0.4615 - hamming_loss: 0.1792 - val_loss: 0.4581 - val_hamming_loss: 0.1723\nEpoch 97/100\n7/7 - 0s - loss: 0.4606 - hamming_loss: 0.1792 - val_loss: 0.4573 - val_hamming_loss: 0.1723\nEpoch 98/100\n7/7 - 0s - loss: 0.4598 - hamming_loss: 0.1792 - val_loss: 0.4565 - val_hamming_loss: 0.1723\nEpoch 99/100\n7/7 - 0s - loss: 0.4589 - hamming_loss: 0.1792 - val_loss: 0.4557 - val_hamming_loss: 0.1723\nEpoch 100/100\n7/7 - 0s - loss: 0.4581 - hamming_loss: 0.1792 - val_loss: 0.4550 - val_hamming_loss: 0.1723\n" ], [ "## (CAUTION: DO NOT OVERWRITE EXISTING FILES) -- Convert training history to dataframe and write to a .json file\nhistory_ce_RNN_lr001_full_df = pd.DataFrame(history_ce_RNN_lr001_full.history)\n#with open(\"Full Data Eval Metrics/Cross Entropy RNN/history_ce_RNN_lr0001_full.json\", \"w\") as outfile: \n# history_ce_RNN_lr001_full_df.to_json(outfile)", "_____no_output_____" ], [ "## Learn a threshold function and save the test error for use in future DF\nY_train_pred = model_LSTM_full.predict(train_padded)\nY_test_pred = model_LSTM_full.predict(test_padded)\nt_range = (0, 1)\n\ntest_labels_binary, threshold_function = predict_test_labels_binary(Y_train_pred, Y_train, Y_test_pred, t_range)\nce_RNN_full_withThreshold = metrics.hamming_loss(Y_test, test_labels_binary)", "_____no_output_____" ], [ "ce_RNN_full_withThreshold", "_____no_output_____" ], [ "## (CAUTION: DO NOT OVERWRITE EXISTING FILES) -- Collect the test set hamming losses for the models \n## with learned threshold functions into a df and write to .json file\nval_hamming_loss_withThreshold_lr001_df = pd.DataFrame({'ce_FF_full_lr0001' : ce_FF_full_withThreshold,\n 'ce_RNN_full_lr0001' : ce_RNN_full_withThreshold},\n index = [0])\n\n#with open(\"Full Data Eval Metrics/val_hamming_loss_withThreshold_lr0001.json\", \"w\") as outfile: \n# val_hamming_loss_withThreshold_lr001_df.to_json(outfile)", "_____no_output_____" ], [ "val_hamming_loss_withThreshold_lr001_df", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Azure Content Moderator API", "_____no_output_____" ], [ "Reference: https://docs.microsoft.com/en-us/azure/cognitive-services/Content-Moderator/api-reference", "_____no_output_____" ] ], [ [ "import requests", "_____no_output_____" ], [ "subscripiton_key = 'YOUR_SUBSCRIPTION_KEY'\nendpoint = 'YOUR_ENDPOINT_URL'\nrequest_url = f'{endpoint}/contentmoderator/moderate/v1.0/ProcessText/Screen'", "_____no_output_____" ], [ "headers = {\n 'Content-Type': 'text/plain',\n 'Ocp-Apim-Subscription-Key': subscripiton_key,\n}", "_____no_output_____" ], [ "params = {\n 'classify': True,\n}", "_____no_output_____" ], [ "body = 'Is this a crap email [email protected], phone: 6657789887, IP: 255.255.255.255, 1 Microsoft Way, Redmond, WA 98052'", "_____no_output_____" ], [ "response = requests.post(request_url, data=body, headers=headers, params=params)", "_____no_output_____" ], [ "response.json()", "_____no_output_____" ] ] ]

[ "markdown", "code" ]

[ [ "markdown", "markdown" ], [ "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Data Analytic Boot Camp - ETL Project\n\n## How is the restaurant's inspection score compare to the Yelp customer review rating?\n\n#### We always rely on the application on our digital device to look for high rating restaurant. However,does the high rating restaurants (rank by customers) provide a clearn and healthy food environment for their customer? This project is trying to answer this question by building an ETL flow.\n\n#### Resources:\n#### - Restaurant Inspection Scores, San Francisco Department of Public Health\n#### (After cleaning the data, n = 54314)\n\n#### - Customers Based Rating Scores, Yelp API\n#### (After cleaning the data, n = 4049)\n\n#### Note: Yelp partnered with the local city government to develop the Local Inspector Value_Entry Specification (LIVES) system. However, the system is partnered with other local web developers, which has no link to Yelp database.", "_____no_output_____" ] ], [ [ "# Dependencies\nimport pandas as pd\nimport os\nimport csv\nimport requests\nimport json\nimport numpy as np\nfrom config_1 import ykey\n\n# Database Connection Dependencies\nimport sqlalchemy\nfrom sqlalchemy.ext.automap import automap_base\nfrom sqlalchemy.orm import Session\nfrom sqlalchemy import create_engine, inspect\nimport sqlite3\n\n# Import Matplot Lib\nimport matplotlib\nfrom matplotlib import style\nstyle.use('seaborn')\nimport matplotlib.pyplot as plt", "_____no_output_____" ], [ "# Loading the CSV file\n\ncsvpath = os.path.join(\".\", \"Resources\", \"Restaurant_Scores_-_LIVES_Standard.csv\")\ninspection_scores = pd.read_csv(csvpath)", "_____no_output_____" ], [ "# Rename the headers of the dataframe for merging in the database\ninspection_scores = inspection_scores.rename(index=str, columns={\"business_name\":\"name\", \"business_address\":\"address\"})\ninspection_scores[\"zip\"] = inspection_scores[\"business_postal_code\"].astype(str)\ninspection_scores['phone'] = inspection_scores['business_phone_number'].astype(str)", "_____no_output_____" ], [ "# Count the unique value of business id in the data\ninspection_scores['business_id'].value_counts()\ninspection_scores['business_id'].nunique()", "_____no_output_____" ], [ "# Make the business name and address lower case for merging in the database\ninspection_scores['name'] = inspection_scores['name'].str.lower()\ninspection_scores['address'] = inspection_scores['address'].str.lower()\n\n# Modify the zip code and business phone number for referencing the business in the database\ninspection_scores[\"zip\"] = inspection_scores[\"zip\"].str[:5]\ninspection_scores['phone'] = inspection_scores['phone'].map(lambda x: str(x)[:-2])", "_____no_output_____" ], [ "# Drop the unnecessary data in the dataframe\ninspection_df = inspection_scores.drop(['business_postal_code', \n 'business_latitude', 'business_longitude',\n 'business_location', 'business_phone_number',\n 'Neighborhoods', 'Police Districts', 'Supervisor Districts',\n 'Fire Prevention Districts', 'Zip Codes', 'Analysis Neighborhoods'], axis=1)", "_____no_output_____" ], [ "# Check the dataframe after cleaning the data\nprint(len(inspection_df))\ninspection_df.head()", "_____no_output_____" ], [ "# Clearning the zip codes in the data frame and create a list for API request\nzip_codes = inspection_scores[\"zip\"].unique()\n\nzip_codes = zip_codes[zip_codes != \"CA\"]\nzip_codes = zip_codes[zip_codes != \"Ca\"]\nzip_codes = zip_codes[zip_codes != \"0\"]\nzip_codes = zip_codes[zip_codes != \"941\"]\n\nzip_codes = zip_codes.tolist()\ndel zip_codes[7]\n\nzip_codes = [int(i) for i in zip_codes]\n\nprint(zip_codes)", "_____no_output_____" ], [ "# Save the cleaned data frame as a csf file for later use\nyelp_df.to_csv(\"Resources/Restaurant_Scores_-_LIVES_Standard_Cleaned.csv\", index=False, header=True)", "_____no_output_____" ] ], [ [ "## Yelp API Request\n#### We tried two ways to extract data from Yelp API request,\n#### 1. Search by city location, San Francisco\n#### 2. Search by zip codes\n#### This project choose to use method 1 because method 2 create bunch of duplicates that is difficult to clean in the later time.", "_____no_output_____" ] ], [ [ "# Testing Yelp API request for extracting the business related data\n\n# Yelp API key is stored in ykey\nheaders = {\"Authorization\": \"bearer %s\" % ykey}\nendpoint = \"https://api.yelp.com/v3/businesses/search\"\nname = []\nrating = []\nreview_count = []\naddress = []\ncity = []\nstate = []\nzip_ = []\nphone = []\n\n\n \n# Define the parameters\nparams = {\"term\": \"restaurants\", \"location\": \"San Francisco\", \"radius\": 5000,\n \"categories\": \"food\", \"limit\": 50, \"offset\":0}\nprint(params)\n\nfor j in range(0, 50):\n\n try:\n# Make a request to the Yelp API\n response = requests.get(url = endpoint, params = params, headers = headers)\n data_response = response.json()\n\n# Add the total counts of fast food stores to \"total\"\n# print(json.dumps(data_response, indent=4, sort_keys=True))\n \n\n print(data_response[\"businesses\"][j][\"name\"])\n name.append(data_response[\"businesses\"][j][\"name\"])\n print(data_response[\"businesses\"][j][\"rating\"])\n rating.append(data_response[\"businesses\"][j][\"rating\"])\n print(data_response[\"businesses\"][j][\"review_count\"])\n review_count.append(data_response[\"businesses\"][j][\"review_count\"])\n print(data_response[\"businesses\"][j][\"location\"][\"address1\"])\n address.append(data_response[\"businesses\"][j][\"location\"][\"address1\"])\n print(data_response[\"businesses\"][j][\"location\"][\"city\"])\n city.append(data_response[\"businesses\"][j][\"location\"][\"city\"])\n print(data_response[\"businesses\"][j][\"location\"][\"state\"])\n state.append(data_response[\"businesses\"][j][\"location\"][\"state\"])\n print(data_response[\"businesses\"][j][\"location\"][\"zip_code\"])\n zip_.append(data_response[\"businesses\"][j][\"location\"][\"zip_code\"])\n print(data_response[\"businesses\"][j][\"phone\"])\n phone.append(data_response[\"businesses\"][j][\"phone\"])\n \n \n except KeyError:\n print(\"no restaurant found!\")", "_____no_output_____" ], [ "# Print out the responses\nprint(data_response['businesses'][1]['name'])\nprint(data_response['businesses'][1]['rating'])\nprint(data_response['businesses'][1]['price'])\nprint(data_response['businesses'][1]['location']['address1'])\nprint(data_response['businesses'][1]['location']['state'])\nprint(data_response['businesses'][1]['location']['city'])\nprint(data_response['businesses'][1]['location']['zip_code'])", "_____no_output_____" ], [ "# Extract data from Yelp API by location = San Francisco\n\n# Yelp API key is stored in ykey\nheaders = {\"Authorization\": \"bearer %s\" % ykey}\nendpoint = \"https://api.yelp.com/v3/businesses/search\"\nname = []\nrating = []\nreview_count = []\naddress = []\ncity = []\nstate = []\nzip_ = []\nphone = []\n\n# Sending 100 requests and each request will return 50 restaurants\nfor i in range(0, 100):\n \n for j in range(50):\n\n try:\n# Define the parameters\n params = {\"term\": \"restaurants\", \"location\": \"San Francisco\", \"radius\": 40000, \n \"categories\": \"food\", \"limit\": 50, \"offset\":(i*5)}\n print(params)\n\n\n# Make a request to the Yelp API\n response = requests.get(url = endpoint, params = params, headers = headers)\n data_response = response.json()\n\n# Add the total counts of fast food stores to \"total\"\n print(data_response[\"businesses\"][j][\"name\"])\n name.append(data_response[\"businesses\"][j][\"name\"])\n print(data_response[\"businesses\"][j][\"rating\"])\n rating.append(data_response[\"businesses\"][j][\"rating\"])\n print(data_response[\"businesses\"][j][\"review_count\"])\n review_count.append(data_response[\"businesses\"][j][\"review_count\"])\n print(data_response[\"businesses\"][j][\"location\"][\"address1\"])\n address.append(data_response[\"businesses\"][j][\"location\"][\"address1\"])\n print(data_response[\"businesses\"][j][\"location\"][\"city\"])\n city.append(data_response[\"businesses\"][j][\"location\"][\"city\"])\n print(data_response[\"businesses\"][j][\"location\"][\"state\"])\n state.append(data_response[\"businesses\"][j][\"location\"][\"state\"])\n print(data_response[\"businesses\"][j][\"location\"][\"zip_code\"])\n zip_.append(data_response[\"businesses\"][j][\"location\"][\"zip_code\"])\n print(data_response[\"businesses\"][j][\"phone\"])\n phone.append(data_response[\"businesses\"][j][\"phone\"])\n \n \n \n except KeyError:\n print(\"no restaurant found!\")\n \n# print(json.dumps(data, indent=4, sort_keys=True))", "_____no_output_____" ], [ "# Extract data from Yelp API by location = zip code\n\n# Yelp API key is stored in ykey\nheaders = {\"Authorization\": \"bearer %s\" % ykey}\nendpoint = \"https://api.yelp.com/v3/businesses/search\"\nname = []\nrating = []\nreview_count = []\naddress = []\ncity = []\nstate = []\nzip_ = []\nphone = []\n\nfor k in zip_codes:\n \n for i in range(0, 20):\n \n for j in range(50):\n\n try:\n# Define the parameters\n params = {\"term\": \"restaurants\", \"location\": k, \"radius\": 5000, \n \"categories\": \"food\", \"limit\": 50, \"offset\":(i*5)}\n print(params)\n\n\n# Make a request to the Yelp API\n response = requests.get(url = endpoint, params = params, headers = headers)\n data_response = response.json()\n\n# Add the total counts of fast food stores to \"total\"\n print(data_response[\"businesses\"][j][\"name\"])\n name.append(data_response[\"businesses\"][j][\"name\"])\n print(data_response[\"businesses\"][j][\"rating\"])\n rating.append(data_response[\"businesses\"][j][\"rating\"])\n print(data_response[\"businesses\"][j][\"review_count\"])\n review_count.append(data_response[\"businesses\"][j][\"review_count\"])\n print(data_response[\"businesses\"][j][\"location\"][\"address1\"])\n address.append(data_response[\"businesses\"][j][\"location\"][\"address1\"])\n print(data_response[\"businesses\"][j][\"location\"][\"city\"])\n city.append(data_response[\"businesses\"][j][\"location\"][\"city\"])\n print(data_response[\"businesses\"][j][\"location\"][\"state\"])\n state.append(data_response[\"businesses\"][j][\"location\"][\"state\"])\n print(data_response[\"businesses\"][j][\"location\"][\"zip_code\"])\n zip_.append(data_response[\"businesses\"][j][\"location\"][\"zip_code\"])\n print(data_response[\"businesses\"][j][\"phone\"])\n phone.append(data_response[\"businesses\"][j][\"phone\"])\n \n \n \n except KeyError:\n print(\"no restaurant found!\")\n \n# print(json.dumps(data, indent=4, sort_keys=True))", "_____no_output_____" ], [ "# Assign keys to the json data\nkeys = {\"name\":name, \"rating\":rating, \"reviews\":review_count,\n \"address\":address, \"city\":city, \"state\":state, \"zip_code\":zip_, \"phone\":phone}\n\nprint(len(name))\n\n# Create a data frame for the json data\nyelp_df = pd.DataFrame(keys)\nyelp_df.head()", "_____no_output_____" ], [ "# Save the Yelp API data into a csv file for future work\nyelp_df.to_csv(\"Resources/yelp_api.csv\", index=False, header=True)", "_____no_output_____" ], [ "# Cleaning the data for merging in the database\n\nyelp_df['zip_code'].dtype\n\nyelp_df['name'] = yelp_df['name'].str.lower()\nyelp_df['address'] = yelp_df['address'].str.lower()\n\nyelp_df['zip_code'] = yelp_df['zip_code'].astype(str)\nyelp_df['phone'] = yelp_df['phone'].astype(str)\n\nyelp_df['zip'] = yelp_df['zip_code'].map(lambda x: str(x)[:-2])\nyelp_df['phone'] = yelp_df['phone'].map(lambda x: str(x)[:-2])\n\nyelp_df = yelp_df.drop(['zip_code'], axis=1)\n\nyelp_df.head()\n\n# print(len(yelp_df))", "_____no_output_____" ] ], [ [ "## Storing the data to SQLite database:\n\n#### There are two ways to store the data into SQLite database,\n#### 1. Using pandas method \"dataframe.to_sql()\"\n#### 2. Create metadata base and append data from data frames to the specific tables in the database\n#### This project use the second method to append data because to_sql() method does not allow database to create primary key for the data.\n\n## Storing the data to MySQL:\n\n#### The data is also stored in MySQL database and the sql commands are saved in a separated file", "_____no_output_____" ] ], [ [ "# Import SQL Alchemy\nfrom sqlalchemy import create_engine\n\n# Import and establish Base for which classes will be constructed \nfrom sqlalchemy.ext.declarative import declarative_base\nBase = declarative_base()\n\n# Import modules to declare columns and column data types\nfrom sqlalchemy import Column, Integer, String, Float", "_____no_output_____" ], [ "# Loading the csv file back to pandas dataframe\ninspect_csvpath = os.path.join(\".\", \"Resources\", \"Restaurant_Scores_-_LIVES_Standard.csv\")\ninspection_scores = pd.read_csv(inspect_csvpath)\n\nyelp_csvpath = os.path.join(\".\", \"Resources\", \"yelp_api.csv\")\nyelp_0 = pd.read_csv(yelp_csvpath)", "_____no_output_____" ], [ "# Create the inspection class\nclass inspection(Base):\n __tablename__ = 'inspection'\n id = Column(Integer, primary_key=True)\n business_id = Column(Integer)\n name = Column(String(255))\n address = Column(String(255))\n business_city = Column(String(255))\n business_state = Column(String(255))\n inspection_id = Column(String(255))\n inspection_date = Column(String(255))\n inspection_score = Column(Float)\n inspection_type = Column(String(500))\n violation_id = Column(String(255))\n violation_description = Column(String(800))\n risk_category = Column(String(255))\n zip = Column(String(255))\n phone = Column(String(255))", "_____no_output_____" ], [ "# Create a connection to a SQLite database\nengine = create_engine('sqlite:///ELT_Project.db')", "_____no_output_____" ], [ "Base.metadata.create_all(engine)", "_____no_output_____" ], [ "# To push the objects made and query the server we use a Session object\nfrom sqlalchemy.orm import Session\nsession = Session(bind=engine)", "_____no_output_____" ], [ "# Appending the dataframe into database\n\nfor i in range(len(inspection_df['name'])):\n inspect = inspection(business_id = inspection_scores['business_id'][i],\n address = inspection_scores['address'][i],\n business_city = inspection_scores['business_city'][i],\n business_state = inspection_scores['business_state'][i],\n inspection_id = inspection_scores['inspection_id'][i],\n inspection_date = inspection_scores['inspection_date'][i],\n inspection_score = inspection_scores['inspection_score'][i],\n inspection_type = inspection_scores['inspection_type'][i],\n violation_id = inspection_scores['violation_id'][i],\n violation_description = inspection_scores['violation_description'][i],\n risk_category = inspection_scores['risk_category'][i],\n zip = inspection_scores['zip'][i],\n phone = inspection_scores['phone'][i])\n session.add(inspect)\n session.commit()", "_____no_output_____" ], [ "# Create the inspection class\nclass yelp(Base):\n __tablename__ = 'yelp'\n id = Column(Integer, primary_key=True)\n name = Column(String(255))\n rating = Column(Float)\n reviews = Column(Integer)\n address = Column(String(255))\n city = Column(String(255))\n state = Column(String(255))\n phone = Column(String(255))\n zip = Column(String(255))", "_____no_output_____" ], [ "# Appending the dataframe into database\n\nfor j in range(len(yelp_df['name'])):\n y = yelp(name = yelp_df['name'][j],\n rating = yelp_df['rating'][j],\n reviews = yelp_df['reviews'][j],\n address = yelp_df['address'][j],\n city = yelp_df['city'][j],\n state = yelp_df['state'][j],\n phone = yelp_df['phone'][j],\n zip = yelp_df['zip'][j])\n \n print(y)\n session.add(y)\n session.commit()", "_____no_output_____" ], [ "# Checking the data in the database engine\nengine.execute(\"SELECT * FROM inspection\").fetchall()", "_____no_output_____" ], [ "engine.execute(\"SELECT * FROM yelp\").fetchall()", "_____no_output_____" ], [ "# Checking the table names\ninspector = inspect(engine)\ninspector.get_table_names()", "_____no_output_____" ], [ "# checking the header names in the inspection scores table\ncolumns = inspector.get_columns('inspection')\nfor i in columns:\n print(i['name'], i['type'])", "_____no_output_____" ], [ "# Checking the header names in the yelp rating table\ncolumns = inspector.get_columns('yelp')\nfor j in columns:\n print(j[\"name\"], j[\"type\"])", "_____no_output_____" ] ], [ [ "## Analysis on restaurant inspection scores and customer-based rating\n\n#### Using matplotly for ploting the joined data.\n#### After joining the data, only 122 business can be matched by the business name and it's zip code\n", "_____no_output_____" ] ], [ [ "joined_df = pd.merge(inspection_df, yelp_df, on=['name', 'zip'])\n# joined_df.head(100)\n# print(len(joined_df))\njoined_df['name'].nunique()", "_____no_output_____" ], [ "# Cleaning the data in the joined data frame\njoined_df = joined_df.dropna(subset=['inspection_score'])\njoined_df = joined_df.drop_duplicates(subset='business_id', keep='first')\njoined_df.head(10)", "_____no_output_____" ], [ "# Plotting the inspection scores from the joined data frame\nax_1 = joined_df.plot(x='name', y='inspection_score', style='o',\n title=\"Inspection Scores\")\nfig_1 = ax_1.get_figure()\nfig_1.savefig('./Images/Inspection_Scores.png')", "_____no_output_____" ], [ "# Plotting the yelp rating from the joined data frame\nax_2 = joined_df.plot(x='name', y='rating', style='^',\n title=\"Yelp Rating\")\nfig_2 = ax_2.get_figure()\nfig_2.savefig('./Images/Yelp_Scores.png')", "_____no_output_____" ], [ "# Plotting the inspection scores and yelp rating\nplt.scatter(joined_df['rating'], joined_df['inspection_score'])\nplt.title(\"Inspection Scores Vs. Yelp Rating\")\nplt.xlabel(\"Yelp Rating (Scale: 0 - 5)\")\nplt.ylabel(\"Inspection Score\")\nplt.savefig('./Images/inspection_scores_vs_yelp_rating.png')", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]