From 4b5202929e6ac83772b9273d224f12f5d0e26afe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20BREDIN?= Date: Fri, 2 May 2014 03:37:32 -0700 Subject: [PATCH 001/458] Initial commit --- .gitignore | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ LICENSE | 21 +++++++++++++++++++++ README.md | 2 ++ 3 files changed, 77 insertions(+) create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 README.md diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..51cbe852 --- /dev/null +++ b/.gitignore @@ -0,0 +1,54 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] + +# C extensions +*.so + +# Distribution / packaging +.Python +env/ +bin/ +build/ +develop-eggs/ +dist/ +eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +*.egg-info/ +.installed.cfg +*.egg + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.cache +nosetests.xml +coverage.xml + +# Translations +*.mo + +# Mr Developer +.mr.developer.cfg +.project +.pydevproject + +# Rope +.ropeproject + +# Django stuff: +*.log +*.pot + +# Sphinx documentation +docs/_build/ + diff --git a/LICENSE b/LICENSE new file mode 100644 index 00000000..b75405ba --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014 Hervé BREDIN + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 00000000..7c29f3e0 --- /dev/null +++ b/README.md @@ -0,0 +1,2 @@ +pyannote.core +============= From 0cc8c2f000d1a0ca9ea37144e215e41414c429b2 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Fri, 2 May 2014 13:01:42 +0200 Subject: [PATCH 002/458] feat: versioneer --- .gitattributes | 1 + LICENSE | 2 +- MANIFEST.in | 2 + pyannote/__init__.py | 26 ++ pyannote/core/__init__.py | 28 ++ pyannote/core/_version.py | 188 ++++++++ setup.py | 63 +++ versioneer.py | 885 ++++++++++++++++++++++++++++++++++++++ 8 files changed, 1194 insertions(+), 1 deletion(-) create mode 100644 .gitattributes create mode 100644 MANIFEST.in create mode 100755 pyannote/__init__.py create mode 100644 pyannote/core/__init__.py create mode 100644 pyannote/core/_version.py create mode 100755 setup.py create mode 100644 versioneer.py diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..0dc1436b --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +pyannote/core/_version.py export-subst diff --git a/LICENSE b/LICENSE index b75405ba..95b7d221 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ The MIT License (MIT) -Copyright (c) 2014 Hervé BREDIN +Copyright (c) 2014 CNRS (Hervé BREDIN - http://herve.niderb.fr) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 00000000..786ec9f6 --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,2 @@ +include versioneer.py +include pyannote/core/_version.py diff --git a/pyannote/__init__.py b/pyannote/__init__.py new file mode 100755 index 00000000..a24dabf6 --- /dev/null +++ b/pyannote/__init__.py @@ -0,0 +1,26 @@ +#!/usr/bin/env python +# encoding: utf-8 + +# The MIT License (MIT) + +# Copyright (c) 2014 CNRS (Hervé BREDIN - http://herve.niderb.fr) + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +__import__('pkg_resources').declare_namespace(__name__) diff --git a/pyannote/core/__init__.py b/pyannote/core/__init__.py new file mode 100644 index 00000000..f9dc425b --- /dev/null +++ b/pyannote/core/__init__.py @@ -0,0 +1,28 @@ +#!/usr/bin/env python +# encoding: utf-8 + +# The MIT License (MIT) + +# Copyright (c) 2014 CNRS (Hervé BREDIN - http://herve.niderb.fr) + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from ._version import get_versions +__version__ = get_versions()['version'] +del get_versions diff --git a/pyannote/core/_version.py b/pyannote/core/_version.py new file mode 100644 index 00000000..21fff3e6 --- /dev/null +++ b/pyannote/core/_version.py @@ -0,0 +1,188 @@ + +# This file helps to compute a version number in source trees obtained from +# git-archive tarball (such as those provided by githubs download-from-tag +# feature). Distribution tarballs (build by setup.py sdist) and build +# directories (produced by setup.py build) will contain a much shorter file +# that just contains the computed version number. + +# This file is released into the public domain. Generated by +# versioneer-0.10 (https://github.com/warner/python-versioneer) + +# these strings will be replaced by git during git-archive +git_refnames = "$Format:%d$" +git_full = "$Format:%H$" + + +import subprocess +import sys +import errno + + +def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False): + assert isinstance(commands, list) + p = None + for c in commands: + try: + # remember shell=False, so use git.cmd on windows, not just git + p = subprocess.Popen([c] + args, cwd=cwd, stdout=subprocess.PIPE, + stderr=(subprocess.PIPE if hide_stderr + else None)) + break + except EnvironmentError: + e = sys.exc_info()[1] + if e.errno == errno.ENOENT: + continue + if verbose: + print("unable to run %s" % args[0]) + print(e) + return None + else: + if verbose: + print("unable to find command, tried %s" % (commands,)) + return None + stdout = p.communicate()[0].strip() + if sys.version >= '3': + stdout = stdout.decode() + if p.returncode != 0: + if verbose: + print("unable to run %s (error)" % args[0]) + return None + return stdout + + +import sys +import re +import os.path + +def get_expanded_variables(versionfile_abs): + # the code embedded in _version.py can just fetch the value of these + # variables. When used from setup.py, we don't want to import + # _version.py, so we do it with a regexp instead. This function is not + # used from _version.py. + variables = {} + try: + f = open(versionfile_abs,"r") + for line in f.readlines(): + if line.strip().startswith("git_refnames ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + variables["refnames"] = mo.group(1) + if line.strip().startswith("git_full ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + variables["full"] = mo.group(1) + f.close() + except EnvironmentError: + pass + return variables + +def versions_from_expanded_variables(variables, tag_prefix, verbose=False): + refnames = variables["refnames"].strip() + if refnames.startswith("$Format"): + if verbose: + print("variables are unexpanded, not using") + return {} # unexpanded, so not in an unpacked git-archive tarball + refs = set([r.strip() for r in refnames.strip("()").split(",")]) + # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of + # just "foo-1.0". If we see a "tag: " prefix, prefer those. + TAG = "tag: " + tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) + if not tags: + # Either we're using git < 1.8.3, or there really are no tags. We use + # a heuristic: assume all version tags have a digit. The old git %d + # expansion behaves like git log --decorate=short and strips out the + # refs/heads/ and refs/tags/ prefixes that would let us distinguish + # between branches and tags. By ignoring refnames without digits, we + # filter out many common branch names like "release" and + # "stabilization", as well as "HEAD" and "master". + tags = set([r for r in refs if re.search(r'\d', r)]) + if verbose: + print("discarding '%s', no digits" % ",".join(refs-tags)) + if verbose: + print("likely tags: %s" % ",".join(sorted(tags))) + for ref in sorted(tags): + # sorting will prefer e.g. "2.0" over "2.0rc1" + if ref.startswith(tag_prefix): + r = ref[len(tag_prefix):] + if verbose: + print("picking %s" % r) + return { "version": r, + "full": variables["full"].strip() } + # no suitable tags, so we use the full revision id + if verbose: + print("no suitable tags, using full revision id") + return { "version": variables["full"].strip(), + "full": variables["full"].strip() } + +def versions_from_vcs(tag_prefix, root, verbose=False): + # this runs 'git' from the root of the source tree. This only gets called + # if the git-archive 'subst' variables were *not* expanded, and + # _version.py hasn't already been rewritten with a short version string, + # meaning we're inside a checked out source tree. + + if not os.path.exists(os.path.join(root, ".git")): + if verbose: + print("no .git in %s" % root) + return {} + + GITS = ["git"] + if sys.platform == "win32": + GITS = ["git.cmd", "git.exe"] + stdout = run_command(GITS, ["describe", "--tags", "--dirty", "--always"], + cwd=root) + if stdout is None: + return {} + if not stdout.startswith(tag_prefix): + if verbose: + print("tag '%s' doesn't start with prefix '%s'" % (stdout, tag_prefix)) + return {} + tag = stdout[len(tag_prefix):] + stdout = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) + if stdout is None: + return {} + full = stdout.strip() + if tag.endswith("-dirty"): + full += "-dirty" + return {"version": tag, "full": full} + + +def versions_from_parentdir(parentdir_prefix, root, verbose=False): + # Source tarballs conventionally unpack into a directory that includes + # both the project name and a version string. + dirname = os.path.basename(root) + if not dirname.startswith(parentdir_prefix): + if verbose: + print("guessing rootdir is '%s', but '%s' doesn't start with prefix '%s'" % + (root, dirname, parentdir_prefix)) + return None + return {"version": dirname[len(parentdir_prefix):], "full": ""} + +tag_prefix = "" +parentdir_prefix = "pyannote.core-" +versionfile_source = "pyannote/core/_version.py" + +def get_versions(default={"version": "unknown", "full": ""}, verbose=False): + # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have + # __file__, we can work backwards from there to the root. Some + # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which + # case we can only use expanded variables. + + variables = { "refnames": git_refnames, "full": git_full } + ver = versions_from_expanded_variables(variables, tag_prefix, verbose) + if ver: + return ver + + try: + root = os.path.abspath(__file__) + # versionfile_source is the relative path from the top of the source + # tree (where the .git directory might live) to this file. Invert + # this to find the root from __file__. + for i in range(len(versionfile_source.split("/"))): + root = os.path.dirname(root) + except NameError: + return default + + return (versions_from_vcs(tag_prefix, root, verbose) + or versions_from_parentdir(parentdir_prefix, root, verbose) + or default) + diff --git a/setup.py b/setup.py new file mode 100755 index 00000000..50cce78d --- /dev/null +++ b/setup.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python +# encoding: utf-8 + +# The MIT License (MIT) + +# Copyright (c) 2014 CNRS (Hervé BREDIN - http://herve.niderb.fr) + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import versioneer +versioneer.versionfile_source = 'pyannote/core/_version.py' +versioneer.versionfile_build = versioneer.versionfile_source +versioneer.tag_prefix = '' +versioneer.parentdir_prefix = 'pyannote.core-' + +from setuptools import setup, find_packages + +setup( + + # package + namespace_packages = ['pyannote'], + packages=find_packages(), + install_requires=[ + 'banyan >=0.1.5', + 'numpy >=1.7.1', + 'pandas >=0.13.1', + ], + + # versioneer + version=versioneer.get_version(), + cmdclass=versioneer.get_cmdclass(), + + # PyPI + name='pyannote.core', + description=('PyAnnote core'), + author='Hervé Bredin', + author_email='bredin@limsi.fr', + url='http://herve.niderb.fr/', + classifiers=[ + "Development Status :: 4 - Beta", + "Intended Audience :: Science/Research", + "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)", + "Natural Language :: English", + "Programming Language :: Python :: 2.7", + "Topic :: Scientific/Engineering" + ], +) diff --git a/versioneer.py b/versioneer.py new file mode 100644 index 00000000..2cacf9b7 --- /dev/null +++ b/versioneer.py @@ -0,0 +1,885 @@ + +# Version: 0.10 + +""" +The Versioneer +============== + +* like a rocketeer, but for versions! +* https://github.com/warner/python-versioneer +* Brian Warner +* License: Public Domain +* Compatible With: python2.6, 2.7, and 3.2, 3.3 + +[![Build Status](https://travis-ci.org/warner/python-versioneer.png?branch=master)](https://travis-ci.org/warner/python-versioneer) + +This is a tool for managing a recorded version number in distutils-based +python projects. The goal is to remove the tedious and error-prone "update +the embedded version string" step from your release process. Making a new +release should be as easy as recording a new tag in your version-control +system, and maybe making new tarballs. + + +## Quick Install + +* `pip install versioneer` to somewhere to your $PATH +* run `versioneer-installer` in your source tree: this installs `versioneer.py` +* follow the instructions below (also in the `versioneer.py` docstring) + +## Version Identifiers + +Source trees come from a variety of places: + +* a version-control system checkout (mostly used by developers) +* a nightly tarball, produced by build automation +* a snapshot tarball, produced by a web-based VCS browser, like github's + "tarball from tag" feature +* a release tarball, produced by "setup.py sdist", distributed through PyPI + +Within each source tree, the version identifier (either a string or a number, +this tool is format-agnostic) can come from a variety of places: + +* ask the VCS tool itself, e.g. "git describe" (for checkouts), which knows + about recent "tags" and an absolute revision-id +* the name of the directory into which the tarball was unpacked +* an expanded VCS variable ($Id$, etc) +* a `_version.py` created by some earlier build step + +For released software, the version identifier is closely related to a VCS +tag. Some projects use tag names that include more than just the version +string (e.g. "myproject-1.2" instead of just "1.2"), in which case the tool +needs to strip the tag prefix to extract the version identifier. For +unreleased software (between tags), the version identifier should provide +enough information to help developers recreate the same tree, while also +giving them an idea of roughly how old the tree is (after version 1.2, before +version 1.3). Many VCS systems can report a description that captures this, +for example 'git describe --tags --dirty --always' reports things like +"0.7-1-g574ab98-dirty" to indicate that the checkout is one revision past the +0.7 tag, has a unique revision id of "574ab98", and is "dirty" (it has +uncommitted changes. + +The version identifier is used for multiple purposes: + +* to allow the module to self-identify its version: `myproject.__version__` +* to choose a name and prefix for a 'setup.py sdist' tarball + +## Theory of Operation + +Versioneer works by adding a special `_version.py` file into your source +tree, where your `__init__.py` can import it. This `_version.py` knows how to +dynamically ask the VCS tool for version information at import time. However, +when you use "setup.py build" or "setup.py sdist", `_version.py` in the new +copy is replaced by a small static file that contains just the generated +version data. + +`_version.py` also contains `$Revision$` markers, and the installation +process marks `_version.py` to have this marker rewritten with a tag name +during the "git archive" command. As a result, generated tarballs will +contain enough information to get the proper version. + + +## Installation + +First, decide on values for the following configuration variables: + +* `versionfile_source`: + + A project-relative pathname into which the generated version strings should + be written. This is usually a `_version.py` next to your project's main + `__init__.py` file. If your project uses `src/myproject/__init__.py`, this + should be `src/myproject/_version.py`. This file should be checked in to + your VCS as usual: the copy created below by `setup.py versioneer` will + include code that parses expanded VCS keywords in generated tarballs. The + 'build' and 'sdist' commands will replace it with a copy that has just the + calculated version string. + +* `versionfile_build`: + + Like `versionfile_source`, but relative to the build directory instead of + the source directory. These will differ when your setup.py uses + 'package_dir='. If you have `package_dir={'myproject': 'src/myproject'}`, + then you will probably have `versionfile_build='myproject/_version.py'` and + `versionfile_source='src/myproject/_version.py'`. + +* `tag_prefix`: + + a string, like 'PROJECTNAME-', which appears at the start of all VCS tags. + If your tags look like 'myproject-1.2.0', then you should use + tag_prefix='myproject-'. If you use unprefixed tags like '1.2.0', this + should be an empty string. + +* `parentdir_prefix`: + + a string, frequently the same as tag_prefix, which appears at the start of + all unpacked tarball filenames. If your tarball unpacks into + 'myproject-1.2.0', this should be 'myproject-'. + +This tool provides one script, named `versioneer-installer`. That script does +one thing: write a copy of `versioneer.py` into the current directory. + +To versioneer-enable your project: + +* 1: Run `versioneer-installer` to copy `versioneer.py` into the top of your + source tree. + +* 2: add the following lines to the top of your `setup.py`, with the + configuration values you decided earlier: + + import versioneer + versioneer.versionfile_source = 'src/myproject/_version.py' + versioneer.versionfile_build = 'myproject/_version.py' + versioneer.tag_prefix = '' # tags are like 1.2.0 + versioneer.parentdir_prefix = 'myproject-' # dirname like 'myproject-1.2.0' + +* 3: add the following arguments to the setup() call in your setup.py: + + version=versioneer.get_version(), + cmdclass=versioneer.get_cmdclass(), + +* 4: now run `setup.py versioneer`, which will create `_version.py`, and + will modify your `__init__.py` to define `__version__` (by calling a + function from `_version.py`). It will also modify your `MANIFEST.in` to + include both `versioneer.py` and the generated `_version.py` in sdist + tarballs. + +* 5: commit these changes to your VCS. To make sure you won't forget, + `setup.py versioneer` will mark everything it touched for addition. + +## Post-Installation Usage + +Once established, all uses of your tree from a VCS checkout should get the +current version string. All generated tarballs should include an embedded +version string (so users who unpack them will not need a VCS tool installed). + +If you distribute your project through PyPI, then the release process should +boil down to two steps: + +* 1: git tag 1.0 +* 2: python setup.py register sdist upload + +If you distribute it through github (i.e. users use github to generate +tarballs with `git archive`), the process is: + +* 1: git tag 1.0 +* 2: git push; git push --tags + +Currently, all version strings must be based upon a tag. Versioneer will +report "unknown" until your tree has at least one tag in its history. This +restriction will be fixed eventually (see issue #12). + +## Version-String Flavors + +Code which uses Versioneer can learn about its version string at runtime by +importing `_version` from your main `__init__.py` file and running the +`get_versions()` function. From the "outside" (e.g. in `setup.py`), you can +import the top-level `versioneer.py` and run `get_versions()`. + +Both functions return a dictionary with different keys for different flavors +of the version string: + +* `['version']`: condensed tag+distance+shortid+dirty identifier. For git, + this uses the output of `git describe --tags --dirty --always` but strips + the tag_prefix. For example "0.11-2-g1076c97-dirty" indicates that the tree + is like the "1076c97" commit but has uncommitted changes ("-dirty"), and + that this commit is two revisions ("-2-") beyond the "0.11" tag. For + released software (exactly equal to a known tag), the identifier will only + contain the stripped tag, e.g. "0.11". + +* `['full']`: detailed revision identifier. For Git, this is the full SHA1 + commit id, followed by "-dirty" if the tree contains uncommitted changes, + e.g. "1076c978a8d3cfc70f408fe5974aa6c092c949ac-dirty". + +Some variants are more useful than others. Including `full` in a bug report +should allow developers to reconstruct the exact code being tested (or +indicate the presence of local changes that should be shared with the +developers). `version` is suitable for display in an "about" box or a CLI +`--version` output: it can be easily compared against release notes and lists +of bugs fixed in various releases. + +In the future, this will also include a +[PEP-0440](http://legacy.python.org/dev/peps/pep-0440/) -compatible flavor +(e.g. `1.2.post0.dev123`). This loses a lot of information (and has no room +for a hash-based revision id), but is safe to use in a `setup.py` +"`version=`" argument. It also enables tools like *pip* to compare version +strings and evaluate compatibility constraint declarations. + +The `setup.py versioneer` command adds the following text to your +`__init__.py` to place a basic version in `YOURPROJECT.__version__`: + + from ._version import get_versions + __version = get_versions()['version'] + del get_versions + +## Updating Versioneer + +To upgrade your project to a new release of Versioneer, do the following: + +* install the new Versioneer (`pip install -U versioneer` or equivalent) +* re-run `versioneer-installer` in your source tree to replace `versioneer.py` +* edit `setup.py`, if necessary, to include any new configuration settings indicated by the release notes +* re-run `setup.py versioneer` to replace `SRC/_version.py` +* commit any changed files + +## Future Directions + +This tool is designed to make it easily extended to other version-control +systems: all VCS-specific components are in separate directories like +src/git/ . The top-level `versioneer.py` script is assembled from these +components by running make-versioneer.py . In the future, make-versioneer.py +will take a VCS name as an argument, and will construct a version of +`versioneer.py` that is specific to the given VCS. It might also take the +configuration arguments that are currently provided manually during +installation by editing setup.py . Alternatively, it might go the other +direction and include code from all supported VCS systems, reducing the +number of intermediate scripts. + + +## License + +To make Versioneer easier to embed, all its code is hereby released into the +public domain. The `_version.py` that it creates is also in the public +domain. + +""" + +import os, sys, re +from distutils.core import Command +from distutils.command.sdist import sdist as _sdist +from distutils.command.build import build as _build + +versionfile_source = None +versionfile_build = None +tag_prefix = None +parentdir_prefix = None + +VCS = "git" + + +LONG_VERSION_PY = ''' +# This file helps to compute a version number in source trees obtained from +# git-archive tarball (such as those provided by githubs download-from-tag +# feature). Distribution tarballs (build by setup.py sdist) and build +# directories (produced by setup.py build) will contain a much shorter file +# that just contains the computed version number. + +# This file is released into the public domain. Generated by +# versioneer-0.10 (https://github.com/warner/python-versioneer) + +# these strings will be replaced by git during git-archive +git_refnames = "%(DOLLAR)sFormat:%%d%(DOLLAR)s" +git_full = "%(DOLLAR)sFormat:%%H%(DOLLAR)s" + + +import subprocess +import sys +import errno + + +def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False): + assert isinstance(commands, list) + p = None + for c in commands: + try: + # remember shell=False, so use git.cmd on windows, not just git + p = subprocess.Popen([c] + args, cwd=cwd, stdout=subprocess.PIPE, + stderr=(subprocess.PIPE if hide_stderr + else None)) + break + except EnvironmentError: + e = sys.exc_info()[1] + if e.errno == errno.ENOENT: + continue + if verbose: + print("unable to run %%s" %% args[0]) + print(e) + return None + else: + if verbose: + print("unable to find command, tried %%s" %% (commands,)) + return None + stdout = p.communicate()[0].strip() + if sys.version >= '3': + stdout = stdout.decode() + if p.returncode != 0: + if verbose: + print("unable to run %%s (error)" %% args[0]) + return None + return stdout + + +import sys +import re +import os.path + +def get_expanded_variables(versionfile_abs): + # the code embedded in _version.py can just fetch the value of these + # variables. When used from setup.py, we don't want to import + # _version.py, so we do it with a regexp instead. This function is not + # used from _version.py. + variables = {} + try: + f = open(versionfile_abs,"r") + for line in f.readlines(): + if line.strip().startswith("git_refnames ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + variables["refnames"] = mo.group(1) + if line.strip().startswith("git_full ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + variables["full"] = mo.group(1) + f.close() + except EnvironmentError: + pass + return variables + +def versions_from_expanded_variables(variables, tag_prefix, verbose=False): + refnames = variables["refnames"].strip() + if refnames.startswith("$Format"): + if verbose: + print("variables are unexpanded, not using") + return {} # unexpanded, so not in an unpacked git-archive tarball + refs = set([r.strip() for r in refnames.strip("()").split(",")]) + # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of + # just "foo-1.0". If we see a "tag: " prefix, prefer those. + TAG = "tag: " + tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) + if not tags: + # Either we're using git < 1.8.3, or there really are no tags. We use + # a heuristic: assume all version tags have a digit. The old git %%d + # expansion behaves like git log --decorate=short and strips out the + # refs/heads/ and refs/tags/ prefixes that would let us distinguish + # between branches and tags. By ignoring refnames without digits, we + # filter out many common branch names like "release" and + # "stabilization", as well as "HEAD" and "master". + tags = set([r for r in refs if re.search(r'\d', r)]) + if verbose: + print("discarding '%%s', no digits" %% ",".join(refs-tags)) + if verbose: + print("likely tags: %%s" %% ",".join(sorted(tags))) + for ref in sorted(tags): + # sorting will prefer e.g. "2.0" over "2.0rc1" + if ref.startswith(tag_prefix): + r = ref[len(tag_prefix):] + if verbose: + print("picking %%s" %% r) + return { "version": r, + "full": variables["full"].strip() } + # no suitable tags, so we use the full revision id + if verbose: + print("no suitable tags, using full revision id") + return { "version": variables["full"].strip(), + "full": variables["full"].strip() } + +def versions_from_vcs(tag_prefix, root, verbose=False): + # this runs 'git' from the root of the source tree. This only gets called + # if the git-archive 'subst' variables were *not* expanded, and + # _version.py hasn't already been rewritten with a short version string, + # meaning we're inside a checked out source tree. + + if not os.path.exists(os.path.join(root, ".git")): + if verbose: + print("no .git in %%s" %% root) + return {} + + GITS = ["git"] + if sys.platform == "win32": + GITS = ["git.cmd", "git.exe"] + stdout = run_command(GITS, ["describe", "--tags", "--dirty", "--always"], + cwd=root) + if stdout is None: + return {} + if not stdout.startswith(tag_prefix): + if verbose: + print("tag '%%s' doesn't start with prefix '%%s'" %% (stdout, tag_prefix)) + return {} + tag = stdout[len(tag_prefix):] + stdout = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) + if stdout is None: + return {} + full = stdout.strip() + if tag.endswith("-dirty"): + full += "-dirty" + return {"version": tag, "full": full} + + +def versions_from_parentdir(parentdir_prefix, root, verbose=False): + # Source tarballs conventionally unpack into a directory that includes + # both the project name and a version string. + dirname = os.path.basename(root) + if not dirname.startswith(parentdir_prefix): + if verbose: + print("guessing rootdir is '%%s', but '%%s' doesn't start with prefix '%%s'" %% + (root, dirname, parentdir_prefix)) + return None + return {"version": dirname[len(parentdir_prefix):], "full": ""} + +tag_prefix = "%(TAG_PREFIX)s" +parentdir_prefix = "%(PARENTDIR_PREFIX)s" +versionfile_source = "%(VERSIONFILE_SOURCE)s" + +def get_versions(default={"version": "unknown", "full": ""}, verbose=False): + # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have + # __file__, we can work backwards from there to the root. Some + # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which + # case we can only use expanded variables. + + variables = { "refnames": git_refnames, "full": git_full } + ver = versions_from_expanded_variables(variables, tag_prefix, verbose) + if ver: + return ver + + try: + root = os.path.abspath(__file__) + # versionfile_source is the relative path from the top of the source + # tree (where the .git directory might live) to this file. Invert + # this to find the root from __file__. + for i in range(len(versionfile_source.split("/"))): + root = os.path.dirname(root) + except NameError: + return default + + return (versions_from_vcs(tag_prefix, root, verbose) + or versions_from_parentdir(parentdir_prefix, root, verbose) + or default) + +''' + + +import subprocess +import sys +import errno + + +def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False): + assert isinstance(commands, list) + p = None + for c in commands: + try: + # remember shell=False, so use git.cmd on windows, not just git + p = subprocess.Popen([c] + args, cwd=cwd, stdout=subprocess.PIPE, + stderr=(subprocess.PIPE if hide_stderr + else None)) + break + except EnvironmentError: + e = sys.exc_info()[1] + if e.errno == errno.ENOENT: + continue + if verbose: + print("unable to run %s" % args[0]) + print(e) + return None + else: + if verbose: + print("unable to find command, tried %s" % (commands,)) + return None + stdout = p.communicate()[0].strip() + if sys.version >= '3': + stdout = stdout.decode() + if p.returncode != 0: + if verbose: + print("unable to run %s (error)" % args[0]) + return None + return stdout + + +import sys +import re +import os.path + +def get_expanded_variables(versionfile_abs): + # the code embedded in _version.py can just fetch the value of these + # variables. When used from setup.py, we don't want to import + # _version.py, so we do it with a regexp instead. This function is not + # used from _version.py. + variables = {} + try: + f = open(versionfile_abs,"r") + for line in f.readlines(): + if line.strip().startswith("git_refnames ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + variables["refnames"] = mo.group(1) + if line.strip().startswith("git_full ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + variables["full"] = mo.group(1) + f.close() + except EnvironmentError: + pass + return variables + +def versions_from_expanded_variables(variables, tag_prefix, verbose=False): + refnames = variables["refnames"].strip() + if refnames.startswith("$Format"): + if verbose: + print("variables are unexpanded, not using") + return {} # unexpanded, so not in an unpacked git-archive tarball + refs = set([r.strip() for r in refnames.strip("()").split(",")]) + # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of + # just "foo-1.0". If we see a "tag: " prefix, prefer those. + TAG = "tag: " + tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) + if not tags: + # Either we're using git < 1.8.3, or there really are no tags. We use + # a heuristic: assume all version tags have a digit. The old git %d + # expansion behaves like git log --decorate=short and strips out the + # refs/heads/ and refs/tags/ prefixes that would let us distinguish + # between branches and tags. By ignoring refnames without digits, we + # filter out many common branch names like "release" and + # "stabilization", as well as "HEAD" and "master". + tags = set([r for r in refs if re.search(r'\d', r)]) + if verbose: + print("discarding '%s', no digits" % ",".join(refs-tags)) + if verbose: + print("likely tags: %s" % ",".join(sorted(tags))) + for ref in sorted(tags): + # sorting will prefer e.g. "2.0" over "2.0rc1" + if ref.startswith(tag_prefix): + r = ref[len(tag_prefix):] + if verbose: + print("picking %s" % r) + return { "version": r, + "full": variables["full"].strip() } + # no suitable tags, so we use the full revision id + if verbose: + print("no suitable tags, using full revision id") + return { "version": variables["full"].strip(), + "full": variables["full"].strip() } + +def versions_from_vcs(tag_prefix, root, verbose=False): + # this runs 'git' from the root of the source tree. This only gets called + # if the git-archive 'subst' variables were *not* expanded, and + # _version.py hasn't already been rewritten with a short version string, + # meaning we're inside a checked out source tree. + + if not os.path.exists(os.path.join(root, ".git")): + if verbose: + print("no .git in %s" % root) + return {} + + GITS = ["git"] + if sys.platform == "win32": + GITS = ["git.cmd", "git.exe"] + stdout = run_command(GITS, ["describe", "--tags", "--dirty", "--always"], + cwd=root) + if stdout is None: + return {} + if not stdout.startswith(tag_prefix): + if verbose: + print("tag '%s' doesn't start with prefix '%s'" % (stdout, tag_prefix)) + return {} + tag = stdout[len(tag_prefix):] + stdout = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) + if stdout is None: + return {} + full = stdout.strip() + if tag.endswith("-dirty"): + full += "-dirty" + return {"version": tag, "full": full} + + +def versions_from_parentdir(parentdir_prefix, root, verbose=False): + # Source tarballs conventionally unpack into a directory that includes + # both the project name and a version string. + dirname = os.path.basename(root) + if not dirname.startswith(parentdir_prefix): + if verbose: + print("guessing rootdir is '%s', but '%s' doesn't start with prefix '%s'" % + (root, dirname, parentdir_prefix)) + return None + return {"version": dirname[len(parentdir_prefix):], "full": ""} +import os.path +import sys + +# os.path.relpath only appeared in Python-2.6 . Define it here for 2.5. +def os_path_relpath(path, start=os.path.curdir): + """Return a relative version of a path""" + + if not path: + raise ValueError("no path specified") + + start_list = [x for x in os.path.abspath(start).split(os.path.sep) if x] + path_list = [x for x in os.path.abspath(path).split(os.path.sep) if x] + + # Work out how much of the filepath is shared by start and path. + i = len(os.path.commonprefix([start_list, path_list])) + + rel_list = [os.path.pardir] * (len(start_list)-i) + path_list[i:] + if not rel_list: + return os.path.curdir + return os.path.join(*rel_list) + +def do_vcs_install(manifest_in, versionfile_source, ipy): + GITS = ["git"] + if sys.platform == "win32": + GITS = ["git.cmd", "git.exe"] + files = [manifest_in, versionfile_source, ipy] + try: + me = __file__ + if me.endswith(".pyc") or me.endswith(".pyo"): + me = os.path.splitext(me)[0] + ".py" + versioneer_file = os_path_relpath(me) + except NameError: + versioneer_file = "versioneer.py" + files.append(versioneer_file) + present = False + try: + f = open(".gitattributes", "r") + for line in f.readlines(): + if line.strip().startswith(versionfile_source): + if "export-subst" in line.strip().split()[1:]: + present = True + f.close() + except EnvironmentError: + pass + if not present: + f = open(".gitattributes", "a+") + f.write("%s export-subst\n" % versionfile_source) + f.close() + files.append(".gitattributes") + run_command(GITS, ["add", "--"] + files) + +SHORT_VERSION_PY = """ +# This file was generated by 'versioneer.py' (0.10) from +# revision-control system data, or from the parent directory name of an +# unpacked source archive. Distribution tarballs contain a pre-generated copy +# of this file. + +version_version = '%(version)s' +version_full = '%(full)s' +def get_versions(default={}, verbose=False): + return {'version': version_version, 'full': version_full} + +""" + +DEFAULT = {"version": "unknown", "full": "unknown"} + +def versions_from_file(filename): + versions = {} + try: + f = open(filename) + except EnvironmentError: + return versions + for line in f.readlines(): + mo = re.match("version_version = '([^']+)'", line) + if mo: + versions["version"] = mo.group(1) + mo = re.match("version_full = '([^']+)'", line) + if mo: + versions["full"] = mo.group(1) + f.close() + return versions + +def write_to_version_file(filename, versions): + f = open(filename, "w") + f.write(SHORT_VERSION_PY % versions) + f.close() + print("set %s to '%s'" % (filename, versions["version"])) + +def get_root(): + try: + return os.path.dirname(os.path.abspath(__file__)) + except NameError: + return os.path.dirname(os.path.abspath(sys.argv[0])) + +def get_versions(default=DEFAULT, verbose=False): + # returns dict with two keys: 'version' and 'full' + assert versionfile_source is not None, "please set versioneer.versionfile_source" + assert tag_prefix is not None, "please set versioneer.tag_prefix" + assert parentdir_prefix is not None, "please set versioneer.parentdir_prefix" + # I am in versioneer.py, which must live at the top of the source tree, + # which we use to compute the root directory. py2exe/bbfreeze/non-CPython + # don't have __file__, in which case we fall back to sys.argv[0] (which + # ought to be the setup.py script). We prefer __file__ since that's more + # robust in cases where setup.py was invoked in some weird way (e.g. pip) + root = get_root() + versionfile_abs = os.path.join(root, versionfile_source) + + # extract version from first of _version.py, 'git describe', parentdir. + # This is meant to work for developers using a source checkout, for users + # of a tarball created by 'setup.py sdist', and for users of a + # tarball/zipball created by 'git archive' or github's download-from-tag + # feature. + + variables = get_expanded_variables(versionfile_abs) + if variables: + ver = versions_from_expanded_variables(variables, tag_prefix) + if ver: + if verbose: print("got version from expanded variable %s" % ver) + return ver + + ver = versions_from_file(versionfile_abs) + if ver: + if verbose: print("got version from file %s %s" % (versionfile_abs,ver)) + return ver + + ver = versions_from_vcs(tag_prefix, root, verbose) + if ver: + if verbose: print("got version from git %s" % ver) + return ver + + ver = versions_from_parentdir(parentdir_prefix, root, verbose) + if ver: + if verbose: print("got version from parentdir %s" % ver) + return ver + + if verbose: print("got version from default %s" % ver) + return default + +def get_version(verbose=False): + return get_versions(verbose=verbose)["version"] + +class cmd_version(Command): + description = "report generated version string" + user_options = [] + boolean_options = [] + def initialize_options(self): + pass + def finalize_options(self): + pass + def run(self): + ver = get_version(verbose=True) + print("Version is currently: %s" % ver) + + +class cmd_build(_build): + def run(self): + versions = get_versions(verbose=True) + _build.run(self) + # now locate _version.py in the new build/ directory and replace it + # with an updated value + target_versionfile = os.path.join(self.build_lib, versionfile_build) + print("UPDATING %s" % target_versionfile) + os.unlink(target_versionfile) + f = open(target_versionfile, "w") + f.write(SHORT_VERSION_PY % versions) + f.close() + +if 'cx_Freeze' in sys.modules: # cx_freeze enabled? + from cx_Freeze.dist import build_exe as _build_exe + + class cmd_build_exe(_build_exe): + def run(self): + versions = get_versions(verbose=True) + target_versionfile = versionfile_source + print("UPDATING %s" % target_versionfile) + os.unlink(target_versionfile) + f = open(target_versionfile, "w") + f.write(SHORT_VERSION_PY % versions) + f.close() + _build_exe.run(self) + os.unlink(target_versionfile) + f = open(versionfile_source, "w") + f.write(LONG_VERSION_PY % {"DOLLAR": "$", + "TAG_PREFIX": tag_prefix, + "PARENTDIR_PREFIX": parentdir_prefix, + "VERSIONFILE_SOURCE": versionfile_source, + }) + f.close() + +class cmd_sdist(_sdist): + def run(self): + versions = get_versions(verbose=True) + self._versioneer_generated_versions = versions + # unless we update this, the command will keep using the old version + self.distribution.metadata.version = versions["version"] + return _sdist.run(self) + + def make_release_tree(self, base_dir, files): + _sdist.make_release_tree(self, base_dir, files) + # now locate _version.py in the new base_dir directory (remembering + # that it may be a hardlink) and replace it with an updated value + target_versionfile = os.path.join(base_dir, versionfile_source) + print("UPDATING %s" % target_versionfile) + os.unlink(target_versionfile) + f = open(target_versionfile, "w") + f.write(SHORT_VERSION_PY % self._versioneer_generated_versions) + f.close() + +INIT_PY_SNIPPET = """ +from ._version import get_versions +__version__ = get_versions()['version'] +del get_versions +""" + +class cmd_update_files(Command): + description = "install/upgrade Versioneer files: __init__.py SRC/_version.py" + user_options = [] + boolean_options = [] + def initialize_options(self): + pass + def finalize_options(self): + pass + def run(self): + print(" creating %s" % versionfile_source) + f = open(versionfile_source, "w") + f.write(LONG_VERSION_PY % {"DOLLAR": "$", + "TAG_PREFIX": tag_prefix, + "PARENTDIR_PREFIX": parentdir_prefix, + "VERSIONFILE_SOURCE": versionfile_source, + }) + f.close() + + ipy = os.path.join(os.path.dirname(versionfile_source), "__init__.py") + try: + old = open(ipy, "r").read() + except EnvironmentError: + old = "" + if INIT_PY_SNIPPET not in old: + print(" appending to %s" % ipy) + f = open(ipy, "a") + f.write(INIT_PY_SNIPPET) + f.close() + else: + print(" %s unmodified" % ipy) + + # Make sure both the top-level "versioneer.py" and versionfile_source + # (PKG/_version.py, used by runtime code) are in MANIFEST.in, so + # they'll be copied into source distributions. Pip won't be able to + # install the package without this. + manifest_in = os.path.join(get_root(), "MANIFEST.in") + simple_includes = set() + try: + for line in open(manifest_in, "r").readlines(): + if line.startswith("include "): + for include in line.split()[1:]: + simple_includes.add(include) + except EnvironmentError: + pass + # That doesn't cover everything MANIFEST.in can do + # (http://docs.python.org/2/distutils/sourcedist.html#commands), so + # it might give some false negatives. Appending redundant 'include' + # lines is safe, though. + if "versioneer.py" not in simple_includes: + print(" appending 'versioneer.py' to MANIFEST.in") + f = open(manifest_in, "a") + f.write("include versioneer.py\n") + f.close() + else: + print(" 'versioneer.py' already in MANIFEST.in") + if versionfile_source not in simple_includes: + print(" appending versionfile_source ('%s') to MANIFEST.in" % + versionfile_source) + f = open(manifest_in, "a") + f.write("include %s\n" % versionfile_source) + f.close() + else: + print(" versionfile_source already in MANIFEST.in") + + # Make VCS-specific changes. For git, this means creating/changing + # .gitattributes to mark _version.py for export-time keyword + # substitution. + do_vcs_install(manifest_in, versionfile_source, ipy) + +def get_cmdclass(): + cmds = {'version': cmd_version, + 'versioneer': cmd_update_files, + 'build': cmd_build, + 'sdist': cmd_sdist, + } + if 'cx_Freeze' in sys.modules: # cx_freeze enabled? + cmds['build_exe'] = cmd_build_exe + del cmds['build'] + + return cmds From 32ac1524610377ec51b02d4f99f07ec3ed25e928 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Fri, 2 May 2014 18:54:39 +0200 Subject: [PATCH 003/458] doc: initial import with IPython Notebook --- README.md | 2 + doc/index.ipynb | 70 +++ doc/pyannote.core.segment.ipynb | 691 +++++++++++++++++++++++ doc/pyannote.core.timeline.ipynb | 916 +++++++++++++++++++++++++++++++ pyannote/core/__init__.py | 15 + pyannote/core/annotation.py | 858 +++++++++++++++++++++++++++++ pyannote/core/feature.py | 391 +++++++++++++ pyannote/core/interval_tree.py | 296 ++++++++++ pyannote/core/mapping.py | 497 +++++++++++++++++ pyannote/core/matrix.py | 272 +++++++++ pyannote/core/notebook.py | 205 +++++++ pyannote/core/scores.py | 640 +++++++++++++++++++++ pyannote/core/segment.py | 521 ++++++++++++++++++ pyannote/core/timeline.py | 584 ++++++++++++++++++++ 14 files changed, 5958 insertions(+) create mode 100644 doc/index.ipynb create mode 100644 doc/pyannote.core.segment.ipynb create mode 100644 doc/pyannote.core.timeline.ipynb create mode 100755 pyannote/core/annotation.py create mode 100755 pyannote/core/feature.py create mode 100644 pyannote/core/interval_tree.py create mode 100755 pyannote/core/mapping.py create mode 100755 pyannote/core/matrix.py create mode 100644 pyannote/core/notebook.py create mode 100644 pyannote/core/scores.py create mode 100755 pyannote/core/segment.py create mode 100755 pyannote/core/timeline.py diff --git a/README.md b/README.md index 7c29f3e0..cbe09ae6 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,4 @@ pyannote.core ============= + +[Documentation](http://nbviewer.ipython.org/github/hbredin/pyannote.core/blob/develop/index.ipynb) \ No newline at end of file diff --git a/doc/index.ipynb b/doc/index.ipynb new file mode 100644 index 00000000..dc855f93 --- /dev/null +++ b/doc/index.ipynb @@ -0,0 +1,70 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:3e295104febcaf8e546ee8ee6c91f6991a7dba086959f3caef5ab40c92b01eb4" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Documentation for `pyannote.core`" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Install" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "pyannote.core package can be installed the easy way:\n", + "```bash\n", + "$ pip install pyannote.core\n", + "```" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Available data structures" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[Segment](pyannote.core.segment.ipynb) (`pyannote.core.segment`)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[Timeline](pyannote.core.timeline.ipynb) (`pyannote.core.timeline`)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[Annotation](pyannote.core.annotation) (`pyannote.core.annotation`)" + ] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/doc/pyannote.core.segment.ipynb b/doc/pyannote.core.segment.ipynb new file mode 100644 index 00000000..950087e0 --- /dev/null +++ b/doc/pyannote.core.segment.ipynb @@ -0,0 +1,691 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:4b89a8137927ed8e28131e6997066577a66c6d70295168c40ee78ed5be351488" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "%pylab inline\n", + "from pyannote.core.notebook import set_notebook_crop" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Segment (`pyannote.core.segment.Segment`)" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from pyannote.core import Segment" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**`Segment`** instances are used to describe temporal fragments (e.g. of an audio file)." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# start time in seconds\n", + "s = 1.\n", + "# end time in seconds\n", + "e = 9.\n", + "segment = Segment(start=s, end=e)\n", + "segment" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n", + "prompt_number": 3, + "text": [ + "" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**`Segment`** instances are nothing more than 2-tuples augmented with several useful methods and properties." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "start, end = segment\n", + "print 'from %f to %f' % (start, end)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "from 1.000000 to 9.000000\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "print 'Segment %s ends at %g seconds.' % (segment, segment.end)\n", + "print 'Its duration is %g seconds.' % (segment.duration)\n", + "print 'Its middle stands as %g seconds.' % (segment.middle)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Segment [1.000 --> 9.000] ends at 9 seconds.\n", + "Its duration is 8 seconds.\n", + "Its middle stands as 5 seconds.\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Intersection" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "other_segment = Segment(4, 13)\n", + "if segment.intersects(other_segment):\n", + " print 'Segment %s intersects other segment %s.' % (segment, other_segment)\n", + " intersection = segment & other_segment\n", + " print 'Their intersection is %s.' % (str(intersection))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Segment [1.000 --> 9.000] intersects other segment [4.000 --> 13.000].\n", + "Their intersection is [4.000 --> 9.000].\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "set_notebook_crop(Segment(0, 15))\n", + "segment" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAASUVORK5CYII=\n", + "prompt_number": 7, + "text": [ + "" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "other_segment" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSUVORK5CYII=\n", + "prompt_number": 8, + "text": [ + "" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "segment & other_segment" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSUVORK5CYII=\n", + "prompt_number": 9, + "text": [ + "" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "other_segment = Segment(13, 20)\n", + "if not (segment & other_segment):\n", + " print 'Those two segments do not intersect.'" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Those two segments do not intersect.\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "set_notebook_crop(Segment(0, 30))\n", + "segment" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\neAAAgHn/Akvxa1ETAfiaAAAAAElFTkSuQmCC\n", + "prompt_number": 11, + "text": [ + "" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "other_segment" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nPAoPAAAw3r8wHWtRgNHViAAAAABJRU5ErkJggg==\n", + "prompt_number": 12, + "text": [ + "" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Inclusion" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "other_segment = Segment(5, 6)\n", + "if other_segment in segment:\n", + " print '%s in included in %s' % (other_segment, segment)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "[5.000 --> 6.000] in included in [1.000 --> 9.000]\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "t = 23.\n", + "if not segment.overlaps(t):\n", + " print '%s does not contain time %f' % (segment, t)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "[1.000 --> 9.000] does not contain time 23.000000\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Other operations" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "other_segment = Segment(10, 30)\n", + "print 'Union of %s and %s is %s' % (segment, other_segment, segment | other_segment)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Union of [1.000 --> 9.000] and [10.000 --> 30.000] is [1.000 --> 30.000]\n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "other_segment = Segment(14, 15)\n", + "print 'Gap between %s and %s is %s' % (segment, other_segment, segment ^ other_segment)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Gap between [1.000 --> 9.000] and [14.000 --> 15.000] is [9.000 --> 14.000]\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Need help?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can always try the following... \n", + "Who knows? It might give you the information you are looking for!" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "help(Segment)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Help on class Segment in module pyannote.core.segment:\n", + "\n", + "class Segment(Segment)\n", + " | Temporal interval defined by its `start` and `end` times.\n", + " | \n", + " | Multiple segment operators are available -- including intersection (&),\n", + " | inclusion (in), emptiness test, start/end time shifting (+, -, >>, <<).\n", + " | They are illustrated in **Examples** section.\n", + " | \n", + " | Comparison of two segments is also available (==, !=, <, <=, >, >=).\n", + " | Two segments are equal iff they have identical start and end times.\n", + " | Segment S is smaller than segment T iff S.start < T.start or if they have\n", + " | the same start time and S.end < T.start.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | start, end : float\n", + " | `start` and `end` times, in seconds.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | segment : Segment\n", + " | New segment with `start` and `end` times.\n", + " | \n", + " | Examples\n", + " | --------\n", + " | Create a new temporal interval between 00:13.000 and 00:37.000.\n", + " | \n", + " | >>> segment = Segment(start=13., end=37)\n", + " | >>> print segment\n", + " | [13.000 --> 37.000]\n", + " | \n", + " | Inclusion, intersection, union & gap\n", + " | \n", + " | >>> s1 = Segment(1, 2)\n", + " | >>> s2 = Segment(0, 3)\n", + " | >>> if s1 in s2:\n", + " | ... print \"Segment %s is included in segment %s.\" % (s1, s2)\n", + " | Segment [1.000 --> 2.000] is included in segment [0.000 --> 3.000].\n", + " | >>> s3 = Segment(2, 5)\n", + " | >>> print s1 & s3\n", + " | \u2205\n", + " | >>> print s2 & s3\n", + " | [2.000 --> 3.000]\n", + " | >>> print s2 | s3\n", + " | [0.000 --> 5.000]\n", + " | >>> print s1 ^ Segment(5, 7)\n", + " | [2.000 --> 5.000]\n", + " | \n", + " | Test whether segment is empty or not.\n", + " | \n", + " | >>> if not Segment(10, 10):\n", + " | ... print \"Segment is empty.\"\n", + " | Segment is empty.\n", + " | \n", + " | Comparison\n", + " | \n", + " | >>> s1 = Segment(1, 3)\n", + " | >>> s2 = Segment(1, 3)\n", + " | >>> s3 = Segment(2, 6)\n", + " | >>> s4 = Segment(1, 2)\n", + " | >>> for s in sorted([s1, s2, s3, s4]):\n", + " | ... print s\n", + " | [1.000 --> 2.000]\n", + " | [1.000 --> 3.000]\n", + " | [1.000 --> 3.000]\n", + " | [2.000 --> 6.000]\n", + " | \n", + " | Method resolution order:\n", + " | Segment\n", + " | Segment\n", + " | __builtin__.tuple\n", + " | __builtin__.object\n", + " | \n", + " | Methods defined here:\n", + " | \n", + " | __and__(self, other)\n", + " | Use the expression 'segment & other'\n", + " | \n", + " | Returns\n", + " | -------\n", + " | segment : Segment\n", + " | Intersection of the two segments\n", + " | \n", + " | __contains__(self, other)\n", + " | Use the expression 'other in segment'\n", + " | \n", + " | Returns\n", + " | -------\n", + " | contains : bool\n", + " | True if other segment is fully included, False otherwise\n", + " | \n", + " | __nonzero__(self)\n", + " | Use the expression 'if segment'\n", + " | \n", + " | Returns\n", + " | -------\n", + " | valid : bool\n", + " | False is segment is empty, True otherwise.\n", + " | \n", + " | __or__(self, other)\n", + " | Use the expression 'segment | other'\n", + " | \n", + " | Returns\n", + " | -------\n", + " | segment : Segment\n", + " | Shortest segment that contains both segments\n", + " | \n", + " | __repr__(self)\n", + " | \n", + " | __str__(self)\n", + " | Use the expression str(segment)\n", + " | \n", + " | __xor__(self, other)\n", + " | Use the expression 'segment ^ other'\n", + " | \n", + " | Returns\n", + " | -------\n", + " | segment : Segment\n", + " | Gap between the two segments\n", + " | \n", + " | _get_duration(self)\n", + " | \n", + " | _get_middle(self)\n", + " | \n", + " | _pretty(self, seconds)\n", + " | \n", + " | _repr_png_(self)\n", + " | \n", + " | copy(self)\n", + " | Duplicate segment.\n", + " | \n", + " | intersects(self, other)\n", + " | Check whether two segments intersect each other\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | other : Segment\n", + " | Other segment\n", + " | \n", + " | Returns\n", + " | -------\n", + " | intersects : bool\n", + " | True if segments intersect, False otherwise\n", + " | \n", + " | overlaps(self, t)\n", + " | \n", + " | pretty(self)\n", + " | Human-readable representation of segments\n", + " | \n", + " | to_json(self)\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Static methods defined here:\n", + " | \n", + " | __new__(cls, start=0.0, end=0.0)\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors defined here:\n", + " | \n", + " | __dict__\n", + " | dictionary for instance variables (if defined)\n", + " | \n", + " | duration\n", + " | \n", + " | middle\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Methods inherited from Segment:\n", + " | \n", + " | __getnewargs__(self)\n", + " | Return self as a plain tuple. Used by copy and pickle.\n", + " | \n", + " | __getstate__(self)\n", + " | Exclude the OrderedDict from pickling\n", + " | \n", + " | _asdict(self)\n", + " | Return a new OrderedDict which maps field names to their values\n", + " | \n", + " | _replace(_self, **kwds)\n", + " | Return a new Segment object replacing specified fields with new values\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Class methods inherited from Segment:\n", + " | \n", + " | _make(cls, iterable, new=, len=) from __builtin__.type\n", + " | Make a new Segment object from a sequence or iterable\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors inherited from Segment:\n", + " | \n", + " | end\n", + " | Alias for field number 1\n", + " | \n", + " | start\n", + " | Alias for field number 0\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Data and other attributes inherited from Segment:\n", + " | \n", + " | _fields = ('start', 'end')\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Methods inherited from __builtin__.tuple:\n", + " | \n", + " | __add__(...)\n", + " | x.__add__(y) <==> x+y\n", + " | \n", + " | __eq__(...)\n", + " | x.__eq__(y) <==> x==y\n", + " | \n", + " | __ge__(...)\n", + " | x.__ge__(y) <==> x>=y\n", + " | \n", + " | __getattribute__(...)\n", + " | x.__getattribute__('name') <==> x.name\n", + " | \n", + " | __getitem__(...)\n", + " | x.__getitem__(y) <==> x[y]\n", + " | \n", + " | __getslice__(...)\n", + " | x.__getslice__(i, j) <==> x[i:j]\n", + " | \n", + " | Use of negative indices is not supported.\n", + " | \n", + " | __gt__(...)\n", + " | x.__gt__(y) <==> x>y\n", + " | \n", + " | __hash__(...)\n", + " | x.__hash__() <==> hash(x)\n", + " | \n", + " | __iter__(...)\n", + " | x.__iter__() <==> iter(x)\n", + " | \n", + " | __le__(...)\n", + " | x.__le__(y) <==> x<=y\n", + " | \n", + " | __len__(...)\n", + " | x.__len__() <==> len(x)\n", + " | \n", + " | __lt__(...)\n", + " | x.__lt__(y) <==> x x*n\n", + " | \n", + " | __ne__(...)\n", + " | x.__ne__(y) <==> x!=y\n", + " | \n", + " | __rmul__(...)\n", + " | x.__rmul__(n) <==> n*x\n", + " | \n", + " | __sizeof__(...)\n", + " | T.__sizeof__() -- size of T in memory, in bytes\n", + " | \n", + " | count(...)\n", + " | T.count(value) -> integer -- return number of occurrences of value\n", + " | \n", + " | index(...)\n", + " | T.index(value, [start, [stop]]) -> integer -- return first index of value.\n", + " | Raises ValueError if the value is not present.\n", + "\n" + ] + } + ], + "prompt_number": 17 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/doc/pyannote.core.timeline.ipynb b/doc/pyannote.core.timeline.ipynb new file mode 100644 index 00000000..0299f7b9 --- /dev/null +++ b/doc/pyannote.core.timeline.ipynb @@ -0,0 +1,916 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:fcfc25daecf48fefb64137a273ce8cffa7ee7f2e7702fbcb7ea7b2288c284058" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": true, + "input": [ + "%pylab inline\n", + "from pyannote.core.notebook import set_notebook_crop" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Timeline (`pyannote.core.timeline.Timeline`)" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from pyannote.core import Timeline" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**`Timeline`** instances are used to describe sets of temporal fragments (e.g. of an audio file). \n", + "One can optionally store an identifier of the associated multimedia document using **`uri`** keyword argument. " + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "timeline = Timeline(uri='MyAudioFile')" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Temporal fragments can be added to the timeline in any order and may be overlapping." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from pyannote.core import Segment\n", + "timeline.add(Segment(6, 8))\n", + "timeline.add(Segment(0.5, 3))\n", + "timeline.add(Segment(8.5, 10))\n", + "timeline.add(Segment(1, 4))\n", + "timeline.add(Segment(5, 7))\n", + "timeline.add(Segment(7, 8))" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 4 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "They are automatically sorted internally (by start time first)." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "for segment in timeline:\n", + " print segment" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "[0.500 --> 3.000]\n", + "[1.000 --> 4.000]\n", + "[5.000 --> 7.000]\n", + "[6.000 --> 8.000]\n", + "[7.000 --> 8.000]\n", + "[8.500 --> 10.000]\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "print \"Timeline contains %d segments\" % len(timeline)\n", + "print \"The second segment of timeline is %s\" % (str(timeline[1]))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Timeline contains 6 segments\n", + "The second segment of timeline is [1.000 --> 4.000]\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One can visualize **`Timeline`** instances in IPython Notebook." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "timeline" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nA+loAO1Y+gAAAABJRU5ErkJggg==\n", + "prompt_number": 7, + "text": [ + ", , , , , ])>" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Coverage, extent and gaps" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The **extent** of a timeline is the segment of minimum duration that contains every segments of the timeline." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "timeline.extent()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "prompt_number": 8, + "text": [ + "" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The **coverage** of a timeline is the timeline with the minimum number of segments with exactly the same time span as the original timeline." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "timeline.coverage()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", + "prompt_number": 9, + "text": [ + ", , ])>" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One can also retrieve **gaps** in a timeline." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "timeline.gaps()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nev8BJPSydF74CroAAAAASUVORK5CYII=\n", + "prompt_number": 10, + "text": [ + ", ])>" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "timeline.gaps(focus=Segment(0, 10.5))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n", + "prompt_number": 11, + "text": [ + ", , , ])>" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Cropping" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the **crop** method, it is possible to select a subpart of timeline." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "selection = Segment(3,7)\n", + "selection" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "prompt_number": 12, + "text": [ + "" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "timeline" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nA+loAO1Y+gAAAABJRU5ErkJggg==\n", + "prompt_number": 13, + "text": [ + ", , , , , ])>" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In **intersection** mode, segments are cut in half if needed." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "timeline.crop(selection, mode='intersection')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAACLxJREFUeJzt3VtIVOsfxvFnppkgOhel1RhGR52sJowgqKbSrMCIkuhE\nYqeLMDpCQRdaFx3oovNVRBhFFhUlFV5EKZENUQZFBUY4MB3pgIEYpdPsi73/snfs4s92nHfmXd8P\nLHRmxHkWP3Ee15rl64rFYjEBAABYzG06AAAAQGej8AAAAOtReAAAgPUoPAAAwHoUHgAAYD0KDwAA\nsJ7ndw8Gg0HV1tYmKgsAAMB/Nn36dNXU1PzrY789wlNbW6tYLBb3raysrFO+LxtzSMWNOSTHxhyS\nY2MOybGl6hx+d5CGU1oAAMB6FB4AAGA9I4UnGAyaeFr8hDkkB+aQHJhDcmAOycHGObhisdgv19Jy\nuVz6zcMAAABJ43e9hVNaAADAehQeAABgPQoPAACwHoUHAABYj8IDAACsR+EBAADWo/AAAADrUXgA\nAID1KDwAAMB6FB4AAGA9Cg9SWnm56QQdxz4gXpgD8GuspYWU5nJJqf4jyj4gXpgDnI61tAAAgKN5\nTAcAOsrlMp0AEnMAkNwoPEh5qX4I35aikOpzsIEtP0tAZ+CUFlJaWZnpBB3HPiBemAPwa7xpGQAA\nWIE3LQMAAEej8AAAAOtReAAAgPUoPAAAwHoUHgAAYD0KDwAAsB6FBwAAWI/CAwAArEfhAQAA1qPw\nAAAA61F4AACA9Sg8ACCpvNx0go6zYR+AzsLioQAgyeWSUv3XnQ37AHQEi4cCAABH85gOAADJwuUy\nnQBAZ6HwAMBfUv10EIUN+DVOaQEAAOtReABAUlmZ6QQdZ8M+AJ2Fq7QAAIAVuEoLAAA4GoUHAABY\nj8IDAACsR+EBAADWo/AAAADrUXgAAID1KDwAAMB6FB4AAGA9Cg8AALAehQcAAFjPSOGpqakx8bT4\nCXNIDswhOTCH5MAckoONc6DwOBhzSA7MITkwh+TAHJKDjXPglBYAALAehQcAAFjPFfvVOuqSgsGg\namtrE5kHAADgP5k+ffovT8f9tvAAAADYgFNaAADAehQeAABgvYQXnurqao0ZM0YjR47U/v37E/30\nkBSJRDRjxgz5/X6NHTtWR44cMR3JsaLRqAKBgAoLC01HcaympiYVFRUpKytL2dnZCoVCpiM50t69\ne+X3+5WTk6Nly5bp27dvpiM5wqpVq5SWlqacnJz2+z5//qz8/HyNGjVKs2fPVlNTk8GE8ZPQwhON\nRlVaWqrq6mo9e/ZM586d0/PnzxMZAZK8Xq8OHjyop0+fKhQK6fjx48zBkMOHDys7O1sul8t0FMfa\nuHGj5s2bp+fPn+vx48fKysoyHclxwuGwTpw4ofr6ej158kTRaFSVlZWmYzlCSUmJqqur/3Hfvn37\nlJ+fr4aGBs2aNUv79u0zlC6+Elp47t+/rxEjRigzM1Ner1dLlizR1atXExkBktLT0zVhwgRJUo8e\nPZSVlaU3b94YTuU8r1690o0bN7RmzRpx7YAZX7580Z07d7Rq1SpJksfjUe/evQ2ncp5evXrJ6/Wq\npaVFbW1tamlp0ZAhQ0zHcoSpU6eqb9++/7ivqqpKxcXFkqTi4mJduXLFRLS4S2jhef36tTIyMtpv\n+3w+vX79OpER8JNwOKxHjx5p8uTJpqM4zubNm3XgwAG53byVzpTGxkYNGDBAJSUlmjhxotauXauW\nlhbTsRynX79+2rp1q4YOHarBgwerT58+ysvLMx3Lsd6/f6+0tDRJUlpamt6/f284UXwk9Dcth+2T\nS3Nzs4qKinT48GH16NHDdBxHuXbtmgYOHKhAIMDRHYPa2tpUX1+v9evXq76+Xt27d7fm8H0qefny\npQ4dOqRwOKw3b96oublZZ8+eNR0L+vN125bX7oQWniFDhigSibTfjkQi8vl8iYyAv7S2tmrRokVa\nsWKFFixYYDqO49TV1amqqkrDhg3T0qVLdevWLa1cudJ0LMfx+Xzy+XyaNGmSJKmoqEj19fWGUznP\ngwcPNGXKFPXv318ej0cLFy5UXV2d6ViOlZaWpnfv3kmS3r59q4EDBxpOFB8JLTy5ubl68eKFwuGw\nvn//rvPnz2v+/PmJjABJsVhMq1evVnZ2tjZt2mQ6jiPt2bNHkUhEjY2Nqqys1MyZM3X69GnTsRwn\nPT1dGRkZamhokCTdvHlTfr/fcCrnGTNmjEKhkL5+/apYLKabN28qOzvbdCzHmj9/vioqKiRJFRUV\n1vxR7Enok3k8OnbsmAoKChSNRrV69WquiDDg7t27OnPmjMaNG6dAICDpz0tC58yZYziZc9lyyDgV\nHT16VMuXL9f37981fPhwnTp1ynQkxxk/frxWrlyp3Nxcud1uTZw4UevWrTMdyxGWLl2q2tpaffz4\nURkZGdq9e7d27NihxYsX6+TJk8rMzNSFCxdMx4wLlpYAAADW4/IQAABgPQoPAACwHoUHAABYj8ID\nAACsR+EBAADWo/AAAADrUXgAdNinT58UCAQUCAQ0aNAg+Xw+BQIB9ezZU6WlpabjAQD/hwdAfO3a\ntUs9e/bUli1bTEcBgHYc4QEQd//7O6qmpkaFhYWSpPLychUXF2vatGnKzMzU5cuXtW3bNo0bN05z\n585VW1ubJOnhw4cKBoPKzc3VnDlz2tf0AYCOoPAASJjGxkbdvn1bVVVVWrFihfLz8/X48WN169ZN\n169fV2trqzZs2KBLly7pwYMHKikp0c6dO03HBmCBhK6lBcC5XC6X5s6dqy5dumjs2LH68eOHCgoK\nJEk5OTkKh8NqaGjQ06dPlZeXJ0mKRqMaPHiwydgALEHhAZAwXbt2lSS53W55vd72+91ut9ra2hSL\nxeT3+1VXV2cqIgBLcUoLQEL8P9dHjB49Wh8+fFAoFJIktba26tmzZ50dDYADUHgAxJ3L5Wr/+G+f\n//1r/n7b6/Xq4sWL2r59uyZMmKBAIKB79+4lLjgAa3FZOgAAsB5HeAAAgPUoPAAAwHoUHgAAYD0K\nDwAAsB6FBwAAWI/CAwAArEfhAQAA1qPwAAAA6/0Bi1TQbGVWiNUAAAAASUVORK5CYII=\n", + "prompt_number": 14, + "text": [ + ", , ])>" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In **strict** mode, only segments fully included in selection are kept." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "timeline.crop(selection, mode='strict')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "prompt_number": 15, + "text": [ + "])>" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In **loose** mode, any segment with a non-empty intersection is kept unchanged even though it starts before or end after the selection." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "timeline.crop(selection, mode='loose')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "prompt_number": 16, + "text": [ + ", , ])>" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Union of timeline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The **update** (in place) and **union** (copy) methods can be used to combine two timelines." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "set_notebook_crop(Segment(0, 6))\n", + "first_timeline = Timeline([Segment(0, 1), Segment(2, 3), Segment(4, 5)])\n", + "first_timeline" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nBwAAWI/BAwAArMfgAQAA1mPwAAAA6/0H6BLF15r2IE4AAAAASUVORK5CYII=\n", + "prompt_number": 17, + "text": [ + ", , ])>" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "second_timeline = Timeline([Segment(1.5, 4.5)])\n", + "second_timeline" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "prompt_number": 18, + "text": [ + "])>" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "new_timeline = first_timeline.union(second_timeline)\n", + "new_timeline" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n4QEAANb7F37d489ChsegAAAAAElFTkSuQmCC\n", + "prompt_number": 19, + "text": [ + ", , , ])>" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Intersection of timelines" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "second_timeline.crop(first_timeline)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nvf8AUzC72aFpEn0AAAAASUVORK5CYII=\n", + "prompt_number": 20, + "text": [ + ", ])>" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**co_iter** method allow to iterator over pairs of intersecting segments." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "for s_first, s_second in first_timeline.co_iter(second_timeline):\n", + " print s_first, s_second" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "[2.000 --> 3.000] [1.500 --> 4.500]\n", + "[4.000 --> 5.000] [1.500 --> 4.500]\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Need help?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can always try the following... \n", + "Who knows? It might give you the information you are looking for!" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "help(Timeline)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Help on class Timeline in module pyannote.core.timeline:\n", + "\n", + "class Timeline(__builtin__.object)\n", + " | Ordered set of segments.\n", + " | \n", + " | A timeline can be seen as an ordered set of non-empty segments (Segment).\n", + " | Segments can overlap -- though adding an already exisiting segment to a\n", + " | timeline does nothing.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | segments : Segment iterator, optional\n", + " | initial set of segments\n", + " | uri : string, optional\n", + " | name of segmented resource\n", + " | \n", + " | Returns\n", + " | -------\n", + " | timeline : Timeline\n", + " | New timeline\n", + " | \n", + " | Examples\n", + " | --------\n", + " | Create a new empty timeline\n", + " | \n", + " | >>> timeline = Timeline()\n", + " | >>> if not timeline:\n", + " | ... print \"Timeline is empty.\"\n", + " | Timeline is empty.\n", + " | \n", + " | Add one segment (+=)\n", + " | \n", + " | >>> segment = Segment(0, 1)\n", + " | >>> timeline.add(segment)\n", + " | >>> if len(timeline) == 1:\n", + " | ... print \"Timeline contains only one segment.\"\n", + " | Timeline contains only one segment.\n", + " | \n", + " | Add all segments from another timeline\n", + " | \n", + " | >>> other_timeline = Timeline([Segment(0.5, 3), Segment(6, 8)])\n", + " | >>> timeline.update(other_timeline)\n", + " | \n", + " | Get timeline extent, coverage & duration\n", + " | \n", + " | >>> extent = timeline.extent()\n", + " | >>> print extent\n", + " | [0 --> 8]\n", + " | >>> coverage = timeline.coverage()\n", + " | >>> print coverage\n", + " | [\n", + " | [0 --> 3]\n", + " | [6 --> 8]\n", + " | ]\n", + " | >>> duration = timeline.duration()\n", + " | >>> print \"Timeline covers a total of %g seconds.\" % duration\n", + " | Timeline covers a total of 5 seconds.\n", + " | \n", + " | Iterate over (sorted) timeline segments\n", + " | \n", + " | >>> for segment in timeline:\n", + " | ... print segment\n", + " | [0 --> 1]\n", + " | [0.5 --> 3]\n", + " | [6 --> 8]\n", + " | \n", + " | Segmentation\n", + " | \n", + " | >>> segmentation = timeline.segmentation()\n", + " | >>> print segmentation\n", + " | [\n", + " | [0 --> 0.5]\n", + " | [0.5 --> 1]\n", + " | [1 --> 3]\n", + " | [6 --> 8]\n", + " | ]\n", + " | \n", + " | Gaps\n", + " | \n", + " | >>> timeline = timeline.copy()\n", + " | >>> print timeline\n", + " | [\n", + " | [0 --> 1]\n", + " | [0.5 --> 3]\n", + " | [6 --> 8]\n", + " | ]\n", + " | >>> print timeline.gaps()\n", + " | [\n", + " | [3 --> 6]\n", + " | ]\n", + " | >>> segment = Segment(0, 10)\n", + " | >>> print timeline.gaps(segment)\n", + " | [\n", + " | [3 --> 6]\n", + " | [8 --> 10]\n", + " | ]\n", + " | \n", + " | Methods defined here:\n", + " | \n", + " | __contains__(self, included)\n", + " | Inclusion\n", + " | \n", + " | Use expression 'segment in timeline' or 'other_timeline in timeline'\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | included : `Segment` or `Timeline`\n", + " | \n", + " | Returns\n", + " | -------\n", + " | contains : bool\n", + " | True if every segment in `included` exists in timeline,\n", + " | False otherwise\n", + " | \n", + " | __eq__(self, other)\n", + " | \n", + " | __getitem__(self, k)\n", + " | Returns kth segment\n", + " | \n", + " | __init__(self, segments=None, uri=None)\n", + " | \n", + " | __iter__(self)\n", + " | \n", + " | __len__(self)\n", + " | \n", + " | __ne__(self, other)\n", + " | \n", + " | __nonzero__(self)\n", + " | \n", + " | __repr__(self)\n", + " | \n", + " | __str__(self)\n", + " | Human-friendly representation\n", + " | \n", + " | add(self, segment)\n", + " | Add segment\n", + " | \n", + " | co_iter(self, other)\n", + " | \n", + " | copy(self, segment_func=None)\n", + " | Duplicate timeline.\n", + " | \n", + " | If segment_func is provided, apply it to each segment first.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | segment_func : function\n", + " | \n", + " | Returns\n", + " | -------\n", + " | timeline : Timeline\n", + " | A (possibly modified) copy of the timeline\n", + " | \n", + " | Examples\n", + " | --------\n", + " | \n", + " | >>> timeline = Timeline(uri=\"MyVideo.avi\")\n", + " | >>> timeline += [Segment(0, 1), Segment(2, 3)]\n", + " | >>> cp = timeline.copy()\n", + " | >>> print cp.uri\n", + " | MyVideo.avi\n", + " | >>> print cp\n", + " | [\n", + " | [0 --> 1]\n", + " | [2 --> 3]\n", + " | ]\n", + " | \n", + " | coverage(self)\n", + " | Timeline coverage\n", + " | \n", + " | The coverage of timeline is the timeline with the minimum number of\n", + " | segments with exactly the same time span as the original timeline.\n", + " | It is (by definition) unique and does not contain any overlapping\n", + " | segments.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | coverage : Timeline\n", + " | Timeline coverage\n", + " | \n", + " | crop(self, other, mode='intersection', mapping=False)\n", + " | \n", + " | duration(self)\n", + " | Timeline duration\n", + " | \n", + " | Returns\n", + " | -------\n", + " | duration : float\n", + " | Duration of timeline coverage, in seconds.\n", + " | \n", + " | empty(self)\n", + " | Empty copy of a timeline.\n", + " | \n", + " | Examples\n", + " | --------\n", + " | \n", + " | >>> timeline = Timeline(uri=\"MyVideo.avi\")\n", + " | >>> timeline += [Segment(0, 1), Segment(2, 3)]\n", + " | >>> empty = timeline.empty()\n", + " | >>> print empty.uri\n", + " | MyVideo.avi\n", + " | >>> print empty\n", + " | [\n", + " | ]\n", + " | \n", + " | extent(self)\n", + " | Timeline extent\n", + " | \n", + " | The extent of a timeline is the segment of minimum duration that\n", + " | contains every segments of the timeline. It is unique, by definition.\n", + " | The extent of an empty timeline is an empty segment.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | extent : Segment\n", + " | Timeline extent\n", + " | \n", + " | Examples\n", + " | --------\n", + " | \n", + " | >>> timeline = Timeline(uri=\"MyVideo.avi\")\n", + " | >>> timeline += [Segment(0, 1), Segment(9, 10)]\n", + " | >>> print timeline.extent()\n", + " | [0 --> 10]\n", + " | \n", + " | gaps(self, focus=None)\n", + " | Timeline gaps\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | focus : None, Segment or Timeline\n", + " | \n", + " | Returns\n", + " | -------\n", + " | gaps : Timeline\n", + " | Timeline made of all gaps from original timeline, and delimited\n", + " | by provided segment or timeline.\n", + " | \n", + " | Raises\n", + " | ------\n", + " | TypeError when `focus` is neither None, Segment nor Timeline\n", + " | \n", + " | Examples\n", + " | --------\n", + " | \n", + " | index(self, segment)\n", + " | Index of segment\n", + " | \n", + " | Parameter\n", + " | ---------\n", + " | segment : Segment\n", + " | \n", + " | Raises\n", + " | ------\n", + " | ValueError if the segment is not present\n", + " | \n", + " | overlapping(self, timestamp)\n", + " | Get list of segments overlapping `timestamp`\n", + " | \n", + " | segmentation(self)\n", + " | Non-overlapping timeline\n", + " | \n", + " | Create the unique timeline with same coverage and same set of segment\n", + " | boundaries as original timeline, but with no overlapping segments.\n", + " | \n", + " | A picture is worth a thousand words:\n", + " | \n", + " | Original timeline:\n", + " | |------| |------| |----|\n", + " | |--| |-----| |----------|\n", + " | \n", + " | Non-overlapping timeline\n", + " | |-|--|-| |-|---|--| |--|----|--|\n", + " | \n", + " | Returns\n", + " | -------\n", + " | timeline : Timeline\n", + " | \n", + " | Examples\n", + " | --------\n", + " | \n", + " | >>> timeline = Timeline()\n", + " | >>> timeline += [Segment(0, 1), Segment(1, 2), Segment(2,3)]\n", + " | >>> timeline += [Segment(2, 4), Segment(6, 7)]\n", + " | >>> print timeline.segmentation()\n", + " | [\n", + " | [0 --> 1]\n", + " | [1 --> 2]\n", + " | [2 --> 3]\n", + " | [3 --> 4]\n", + " | [6 --> 7]\n", + " | ]\n", + " | \n", + " | to_json(self)\n", + " | \n", + " | union(self, other)\n", + " | Create new timeline made of union of segments\n", + " | \n", + " | update(self, timeline)\n", + " | Add `timeline` segments\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors defined here:\n", + " | \n", + " | __dict__\n", + " | dictionary for instance variables (if defined)\n", + " | \n", + " | __weakref__\n", + " | list of weak references to the object (if defined)\n", + "\n" + ] + } + ], + "prompt_number": 22 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/pyannote/core/__init__.py b/pyannote/core/__init__.py index f9dc425b..63b71c5a 100644 --- a/pyannote/core/__init__.py +++ b/pyannote/core/__init__.py @@ -26,3 +26,18 @@ from ._version import get_versions __version__ = get_versions()['version'] del get_versions + +PYANNOTE_URI = 'uri' +PYANNOTE_MODALITY = 'modality' +PYANNOTE_SEGMENT = 'segment' +PYANNOTE_TRACK = 'track' +PYANNOTE_LABEL = 'label' +PYANNOTE_SCORE = 'score' +PYANNOTE_IDENTITY = 'identity' + +from segment import Segment +from timeline import Timeline +from annotation import Annotation +from scores import Scores + +from notebook import set_notebook_crop \ No newline at end of file diff --git a/pyannote/core/annotation.py b/pyannote/core/annotation.py new file mode 100755 index 00000000..30f71a3d --- /dev/null +++ b/pyannote/core/annotation.py @@ -0,0 +1,858 @@ +#!/usr/bin/env python +# encoding: utf-8 + +# The MIT License (MIT) + +# Copyright (c) 2014 CNRS (Hervé BREDIN - http://herve.niderb.fr) + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import itertools +import operator +import warnings + +import numpy as np + +from . import PYANNOTE_URI, PYANNOTE_MODALITY, PYANNOTE_SEGMENT, PYANNOTE_TRACK, PYANNOTE_LABEL +from banyan import SortedDict +from interval_tree import TimelineUpdator +from segment import Segment +from timeline import Timeline + +# ignore Banyan warning +warnings.filterwarnings( + 'ignore', 'Key-type optimization', + Warning, 'pyannote.core.annotation' +) + + +class Unknown(object): + nextID = 0 + + @classmethod + def reset(cls): + cls.nextID = 0 + + @classmethod + def next(cls): + cls.nextID += 1 + return cls.nextID + + def __init__(self, format='Inconnu_%05d'): + super(Unknown, self).__init__() + self.ID = Unknown.next() + self._format = format + + def __str__(self): + return self._format % self.ID + + def __repr__(self): + return str(self) + + def __hash__(self): + return hash(self.ID) + + def __eq__(self, other): + if isinstance(other, Unknown): + return self.ID == other.ID + else: + return False + + +class Annotation(object): + """Annotation + + Parameters + ---------- + uri : string, optional + uniform resource identifier of annotated document + modality : string, optional + name of annotated modality + + """ + + @classmethod + def from_df(cls, df, uri=None, modality=None, aggfunc=np.mean): + """ + + Parameters + ---------- + df : DataFrame + Must contain the following columns: 'segment', 'track' and 'label' + uri : str, optional + Resource identifier + modality : str, optional + Modality + aggfunc : func + Value aggregation function in case of duplicate (segment, track, + label) tuples + + Returns + ------- + + """ + annotation = cls(uri=uri, modality=modality) + for _, (segment, track, label) in df[[SEGMENT, TRACK, LABEL]].iterrows(): + annotation[segment, track] = label + return annotation + + def __init__(self, uri=None, modality=None): + super(Annotation, self).__init__() + + self._uri = uri + self.modality = modality + + # sorted dictionary + # keys: annotated segments + # values: {track: label} dictionary + self._tracks = SortedDict(key_type=(float, float), + updator=TimelineUpdator) + + # dictionary + # key: label + # value: timeline + self._labels = {} + self._labelNeedsUpdate = {} + + # timeline meant to store all annotated segments + self._timeline = Timeline(uri=uri) + self._timelineNeedsUpdate = True + + def _get_uri(self): + return self._uri + + def _set_uri(self, uri): + # update uri for all internal timelines + for _, timeline in self._labels.iteritems(): + timeline.uri = uri + self._uri = uri + + uri = property(_get_uri, fset=_set_uri, doc="Resource identifier") + + def _updateLabels(self): + + # (re-)initialize changed label timeline + for l, needsUpdate in self._labelNeedsUpdate.iteritems(): + if needsUpdate: + self._labels[l] = Timeline(uri=self.uri) + + # fill changed label timeline + for segment, track, l in self.itertracks(label=True): + if self._labelNeedsUpdate[l]: + self._labels[l].add(segment) + + self._labelNeedsUpdate = {l: False for l in self._labels} + + # remove "ghost" labels (i.e. label with empty timeline) + labels = self._labels.keys() + for l in labels: + if not self._labels[l]: + self._labels.pop(l) + self._labelNeedsUpdate.pop(l) + + def __len__(self): + """Number of segments""" + return self._tracks.length() + + def __nonzero__(self): + return self._tracks.length() > 0 + + def itersegments(self): + """Segment iterator""" + return iter(self._tracks) + + def itertracks(self, label=False): + for segment, tracks in self._tracks.items(): + for track, lbl in tracks.iteritems(): + if label: + yield segment, track, lbl + else: + yield segment, track + + def _updateTimeline(self): + self._timeline = Timeline(segments=self._tracks, uri=self.uri) + self._timelineNeedsUpdate = False + + def get_timeline(self): + """Get timeline made of annotated segments""" + if self._timelineNeedsUpdate: + self._updateTimeline() + return self._timeline + + def __eq__(self, other): + return self._tracks == other._tracks + + def __ne__(self, other): + return self._tracks != other._tracks + + def __contains__(self, included): + """Inclusion + + Use expression 'segment in annotation' or 'timeline in annotation' + + Parameters + ---------- + included : `Segment` or `Timeline` + + Returns + ------- + contains : bool + True if every segment in `included` exists in annotation + False otherwise + + """ + return included in self.get_timeline() + + def crop(self, other, mode='intersection'): + """Crop annotation + + Parameters + ---------- + other : `Segment` or `Timeline` + + mode : {'strict', 'loose', 'intersection'} + In 'strict' mode, only segments fully included in focus coverage + are kept. In 'loose' mode, any intersecting segment is kept + unchanged. In 'intersection' mode, only intersecting segments are + kept and replaced by their actual intersection with the focus. + + Returns + ------- + cropped : Annotation + + Remarks + ------- + In 'intersection' mode, the best is done to keep the track names + unchanged. However, in some cases where two original segments are + cropped into the same resulting segments, conflicting track names are + modified to make sure no track is lost. + """ + + if isinstance(other, Segment): + other = Timeline(segments=[other], uri=self.uri) + cropped = self.crop(other, mode=mode) + + elif isinstance(other, Timeline): + + cropped = self.__class__(uri=self.uri, modality=self.modality) + + if mode == 'loose': + # TODO + # update co_iter to yield (segment, tracks), (segment, tracks) + # instead of segment, segment + # This would avoid calling ._tracks.get(segment) + for segment, _ in self.get_timeline().co_iter(other): + for track, label in self._tracks[segment].iteritems(): + cropped[segment, track] = label + + elif mode == 'strict': + # TODO + # see above + for segment, other_segment in self.get_timeline().co_iter(other): + if segment in other_segment: + for track, label in self._tracks[segment].iteritems(): + cropped[segment, track] = label + + elif mode == 'intersection': + # see above + for segment, other_segment in self.get_timeline().co_iter(other): + intersection = segment & other_segment + for track, label in self._tracks[segment].iteritems(): + track = cropped.new_track(intersection, + candidate=track) + cropped[intersection, track] = label + + else: + raise NotImplementedError("unsupported mode: '%s'" % mode) + + return cropped + + def get_tracks(self, segment): + """Set of tracks for query segment + + Parameters + ---------- + segment : `Segment` + Query segment + + Returns + ------- + tracks : set + Set of tracks for query segment + """ + return set(self._tracks.get(segment, {})) + + def has_track(self, segment, track): + """Check whether a given track exists + + Parameters + ---------- + segment : `Segment` + Query segment + track : + Query track + + Returns + ------- + exists : bool + True if track exists for segment + """ + return track in self._tracks.get(segment, {}) + + def get_track_by_name(self, track): + """Get all tracks with given name + + Parameters + ---------- + track : any valid track name + Requested name track + + Returns + ------- + tracks : list + List of (segment, track) tuples + """ + raise NotImplementedError('') + + def copy(self): + + # create new empty annotation + copied = self.__class__(uri=self.uri, modality=self.modality) + + # deep copy internal track dictionary + _tracks = [(key, dict(value)) for (key, value) in self._tracks.items()] + copied._tracks = SortedDict(items=_tracks, + key_type=(float, float), + updator=TimelineUpdator) + + # deep copy internal label timelines + _labels = {key: timeline.copy() + for (key, timeline) in self._labels.iteritems()} + copied._labels = _labels + + # deep copy need-update indicator + copied._labelNeedsUpdate = dict(self._labelNeedsUpdate) + + copied._timelineNeedsUpdate = self._timelineNeedsUpdate + + return copied + + def retrack(self): + """ + """ + retracked = self.__class__(uri=self.uri, modality=self.modality) + for n, (s, _, label) in enumerate(self.itertracks(label=True)): + retracked[s, n] = label + return retracked + + def new_track(self, segment, candidate=None, prefix=None): + """Track name generator + + Parameters + ---------- + segment : Segment + prefix : str, optional + candidate : any valid track name + + Returns + ------- + track : str + New track name + """ + + # obtain list of existing tracks for segment + existing_tracks = set(self._tracks.get(segment, {})) + + # if candidate is provided, check whether it already exists + # in case it does not, use it + if (candidate is not None) and (candidate not in existing_tracks): + return candidate + + # no candidate was provided or the provided candidate already exists + # we need to create a brand new one + + # by default (if prefix is not provided) + # use modality as prefix (eg. speaker1, speaker2, ...) + if prefix is None: + prefix = '' if self.modality is None else str(self.modality) + + # find first non-existing track name for segment + # eg. if speaker1 exists, try speaker2, then speaker3, ... + count = 1 + while ('%s%d' % (prefix, count)) in existing_tracks: + count += 1 + + # return first non-existing track name + return '%s%d' % (prefix, count) + + def __str__(self): + """Human-friendly representation""" + # TODO: use pandas.DataFrame + return "\n".join(["%s %s %s" % (s, t, l) + for s, t, l in self.itertracks(label=True)]) + + def __delitem__(self, key): + + # del annotation[segment] + if isinstance(key, Segment): + + # Pop segment out of dictionary + # and get corresponding tracks + # Raises KeyError if segment does not exist + tracks = self._tracks.pop(key) + + # mark timeline as modified + self._timelineNeedsUpdate = True + + # mark every label in tracks as modified + for track, label in tracks.iteritems(): + self._labelNeedsUpdate[label] = True + + # del annotation[segment, track] + elif isinstance(key, tuple) and len(key) == 2: + + # get segment tracks as dictionary + # if segment does not exist, get empty dictionary + # Raises KeyError if segment does not exist + tracks = self._tracks[key[0]] + + # pop track out of tracks dictionary + # and get corresponding label + # Raises KeyError if track does not exist + label = tracks.pop(key[1]) + + # mark label as modified + self._labelNeedsUpdate[label] = True + + # if tracks dictionary is now empty, + # remove segment as well + if not tracks: + self._tracks.pop(key[0]) + self._timelineNeedsUpdate = True + + else: + raise KeyError('') + + # label = annotation[segment, track] + def __getitem__(self, key): + return self._tracks[key[0]][key[1]] + + # annotation[segment, track] = label + def __setitem__(self, key, label): + + if key[0] not in self._tracks: + self._tracks[key[0]] = {} + self._timelineNeedsUpdate = True + + self._tracks[key[0]][key[1]] = label + self._labelNeedsUpdate[label] = True + + def empty(self): + return self.__class__(uri=self.uri, modality=self.modality) + + def labels(self, unknown=True): + """List of labels + + Parameters + ---------- + unknown : bool, optional + When False, do not return Unknown instances + When True, return any label (even Unknown instances) + + Returns + ------- + labels : list + Sorted list of labels + + Remarks + ------- + Labels are sorted based on their string representation. + """ + + if any([lnu for lnu in self._labelNeedsUpdate.values()]): + self._updateLabels() + + labels = sorted(self._labels, key=str) + + if not unknown: + labels = [l for l in labels if not isinstance(l, Unknown)] + + return labels + + def get_labels(self, segment, unknown=True, unique=True): + """Local set of labels + + Parameters + ---------- + segment : Segment + Segments to get label from. + unknown : bool, optional + When False, do not return Unknown instances + When True, return any label (even Unknown instances) + unique : bool, optional + When False, return the list of (possibly repeated) labels. + When True (default), return the set of labels + Returns + ------- + labels : set + Set of labels for `segment` if it exists, empty set otherwise. + + Examples + -------- + + >>> annotation = Annotation() + >>> segment = Segment(0, 2) + >>> annotation[segment, 'speaker1'] = 'Bernard' + >>> annotation[segment, 'speaker2'] = 'John' + >>> print sorted(annotation.get_labels(segment)) + set(['Bernard', 'John']) + >>> print annotation.get_labels(Segment(1, 2)) + set([]) + + """ + + labels = self._tracks.get(segment, {}).values() + + if not unknown: + labels = [l for l in labels if not isinstance(l, Unknown)] + + if unique: + labels = set(labels) + + return labels + + def subset(self, labels, invert=False): + """Annotation subset + + Extract annotation subset based on labels + + Parameters + ---------- + labels : set + Set of labels + invert : bool, optional + If invert is True, extract all but requested `labels` + + Returns + ------- + subset : `Annotation` + Annotation subset. + """ + + if not isinstance(labels, set): + raise TypeError('labels must be provided as a set of labels.') + + if invert: + labels = set(self.labels()) - labels + else: + labels = labels & set(self.labels()) + + sub = self.__class__(uri=self.uri, modality=self.modality) + for segment, track, label in self.itertracks(label=True): + if label in labels: + sub[segment, track] = label + + return sub + + def label_timeline(self, label): + """Get timeline for a given label + + Parameters + ---------- + label : + + Returns + ------- + timeline : :class:`Timeline` + Timeline made of all segments annotated with `label` + + """ + if label not in self.labels(): + return Timeline(uri=self.uri) + + if self._labelNeedsUpdate[label]: + self._updateLabels() + + for l, hasChanged in self._labelNeedsUpdate.iteritems(): + if hasChanged: + self._labels[l] = Timeline(uri=self.uri) + + for segment, track, l in self.itertracks(label=True): + if self._labelNeedsUpdate[l]: + self._labels[l].add(segment) + + self._labelNeedsUpdate = {l: False for l in self._labels} + + return self._labels[label] + + def label_coverage(self, label): + """ + + Parameters + ---------- + label : + + Returns + ------- + + """ + if label not in self.labels(): + return Timeline(uri=self.uri) + + return self.label_timeline(label).coverage() + + def label_duration(self, label): + + if label not in self.labels(): + return 0. + + return self.label_timeline(label).duration() + + def chart(self, percent=False): + """ + Label chart based on their duration + + Parameters + ---------- + percent : bool, optional + Return total duration percentage (rather than raw duration) + + Returns + ------- + chart : (label, duration) iterable + Sorted from longest to shortest. + + """ + + chart = sorted([(label, self.label_duration(label)) + for label in self.labels()], + key=lambda x: x[1], reverse=True) + + if percent: + total = np.sum([duration for _, duration in chart]) + chart = [(label, duration/total) for (label, duration) in chart] + + return chart + + def argmax(self, segment=None, known_first=False): + """Get most frequent label + + + Parameters + ---------- + segment : Segment, optional + Section of annotation where to look for the most frequent label. + Defaults to whole annotation extent. + known_first: bool, optional + If True, artificially reduces the duration of intersection of + `Unknown` labels so that 'known' labels are returned first. + + Returns + ------- + label : any existing label or None + Label with longest intersection + + Examples + -------- + + >>> annotation = Annotation(modality='speaker') + >>> annotation[Segment(0, 10), 'speaker1'] = 'Alice' + >>> annotation[Segment(8, 20), 'speaker1'] = 'Bob' + >>> print "%s is such a talker!" % annotation.argmax() + Bob is such a talker! + >>> segment = Segment(22, 23) + >>> if not annotation.argmax(segment): + ... print "No label intersecting %s" % segment + No label intersection [22 --> 23] + + """ + + # if annotation is empty, obviously there is no most frequent label + if not self: + return None + + # if segment is not provided, just look for the overall most frequent + # label (ie. set segment to the extent of the annotation) + if segment is None: + segment = self.get_timeline().extent() + + # compute intersection duration for each label + durations = {lbl: self.label_timeline(lbl).crop(segment, mode='intersection').duration() + for lbl in self.labels()} + + # artifically reduce intersection duration of Unknown labels + # so that 'known' labels are returned first + if known_first: + maxduration = max(durations.values()) + for lbl in durations.keys(): + if isinstance(lbl, Unknown): + durations[lbl] = durations[lbl] - maxduration + + # find the most frequent label + label = max(durations.iteritems(), key=operator.itemgetter(1))[0] + + # in case all durations were zero, there is no most frequent label + return label if durations[label] > 0 else None + + def __rshift__(self, timeline): + """Tag a timeline + + Use expression 'tagged = annotation >> timeline' + + Shortcut for : + >>> tagger = DirectTagger() + >>> tagged = tagger(annotation, timeline) + + Parameters + ---------- + timeline : :class:`pyannote.base.timeline.Timeline` + + Returns + ------- + tagged : :class:`pyannote.base.annotation.Annotation` + Tagged timeline - one track per intersecting label. + + """ + from pyannote.algorithm.tagging import DirectTagger + if not isinstance(timeline, Timeline): + raise TypeError('direct tagging (>>) only works with timelines.') + return DirectTagger()(self, timeline) + + def translate(self, translation): + """Translate labels + + Parameters + ---------- + translation: dict + Label translation. + Labels with no associated translation are kept unchanged. + + Returns + ------- + translated : :class:`Annotation` + New annotation with translated labels. + """ + + assert isinstance(translation, dict) + + # create an empty copy + translated = self.empty() + + for segment, track, label in self.itertracks(label=True): + # only transform labels that have an actual translation + # in the provided dictionary, keep the others as they are. + translated[segment, track] = translation.get(label, label) + + return translated + + def __mod__(self, translation): + return self.translate(translation) + + def anonymize_labels(self): + """Anonmyize labels + + Create a new annotation where labels are anonymized, ie. each label + is replaced by a unique `Unknown` instance. + + Returns + ------- + anonymized : :class:`Annotation` + New annotation with anonymized labels. + + """ + translation = {label: Unknown() for label in self.labels()} + return self % translation + + def anonymize_tracks(self): + """ + Anonymize tracks + + Create a new annotation where each track is anonymized, i.e. the label + of each track is set to a unique `Unknown` instance + + Returns + ------- + anonymized : `Annotation` + Anonymized annotation + + """ + anonymized = self.empty() + for s, t, _ in self.itertracks(label=True): + anonymized[s, t] = Unknown() + return anonymized + + def smooth(self): + """Smooth annotation + + Create new annotation where contiguous tracks with same label are + merged into one longer track. + + Returns + ------- + annotation : Annotation + New annotation where contiguous tracks with same label are merged + into one long track. + + Remarks + ------- + Track names are lost in the process. + + """ + + smoothed = self.empty() + + n = 0 + for label in self.labels(): + coverage = self.label_coverage(label) + for segment in coverage: + smoothed[segment, n] = label + n = n+1 + + return smoothed + + def co_iter(self, other): + """ + Parameters + ---------- + other : Annotation + + Generates + --------- + (segment, track), (other_segment, other_track) + """ + + for s, S in self.get_timeline().co_iter(other.get_timeline()): + tracks = self.get_tracks(s) + other_tracks = other.get_tracks(S) + for t, T in itertools.product(tracks, other_tracks): + yield (s, t), (S, T) + + def to_json(self): + annotation = [{PYANNOTE_SEGMENT: s.to_json(), PYANNOTE_TRACK: t, PYANNOTE_LABEL: l} + for s, t, l in self.itertracks(label=True)] + return {PYANNOTE_URI: self.uri, PYANNOTE_MODALITY: self.modality, 'tracks': annotation} + + def _repr_png_(self): + from pyannote.core.notebook import repr_annotation + return repr_annotation(self) + + +if __name__ == "__main__": + import doctest + doctest.testmod() diff --git a/pyannote/core/feature.py b/pyannote/core/feature.py new file mode 100755 index 00000000..c79b16ef --- /dev/null +++ b/pyannote/core/feature.py @@ -0,0 +1,391 @@ +#!/usr/bin/env python +# encoding: utf-8 + +# The MIT License (MIT) + +# Copyright (c) 2014 CNRS (Hervé BREDIN - http://herve.niderb.fr) + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +""" + +Features. + +""" + +import numpy as np +from segment import Segment, SlidingWindow +from timeline import Timeline + + +class BaseSegmentFeature(object): + + """ + Base class for any segment/feature iterator. + """ + + def __init__(self, uri=None): + super(BaseSegmentFeature, self).__init__() + self.__uri = uri + + def __get_uri(self): + return self.__uri + + def __set_uri(self, value): + self.__uri = value + uri = property(fget=__get_uri, fset=__set_uri) + """Path to (or any identifier of) described resource""" + + def __iter__(self): + """Segment/feature vector iterator + + Use expression 'for segment, feature_vector in segment_feature' + + This method must be implemented by subclass. + + """ + raise NotImplementedError('Missing method "__iter__".') + + +class BasePrecomputedSegmentFeature(BaseSegmentFeature): + + """'Segment iterator'-driven precomputed feature iterator. + + Parameters + ---------- + data : numpy array + Feature vectors stored in such a way that data[i] is ith feature vector. + segment_iterator : :class:`SlidingWindow` or :class:`Timeline` + Segment iterator. + Its length must correspond to `data` length. + uri : string, optional + name of (audio or video) described resource + + """ + + def __init__(self, data, segment_iterator, uri=None): + # make sure data does not contain NaN nor inf + data = np.asarray_chkfinite(data) + + # make sure segment_iterator is actually one of those + if not isinstance(segment_iterator, (SlidingWindow, Timeline)): + raise TypeError("segment_iterator must 'Timeline' or " + "'SlidingWindow'.") + + # make sure it iterates the correct number of segments + try: + N = len(segment_iterator) + except Exception: + # an exception is raised by `len(sliding_window)` + # in case sliding window has infinite end. + # this is acceptable, no worry... + pass + else: + n = data.shape[0] + if n != N: + raise ValueError("mismatch between number of segments (%d) " + "and number of feature vectors (%d)." % (N, n)) + + super(BasePrecomputedSegmentFeature, self).__init__(uri=uri) + self.__data = data + self._segment_iterator = segment_iterator + + def __get_data(self): + return self.__data + data = property(fget=__get_data) + """Raw feature data (numpy array)""" + + def __iter__(self): + """Feature vector iterator + + Use expression 'for segment, feature_vector in periodic_feature' + + """ + + # get number of feature vectors + n = self.__data.shape[0] + + for i, segment in enumerate(self._segment_iterator): + + # make sure we do not iterate too far... + if i >= n: + break + + # yield current segment and corresponding feature vector + yield segment, self.__data[i] + + def _segmentToRange(self, segment): + """ + Parameters + ---------- + segment : :class:`pyannote.base.segment.Segment` + + Returns + ------- + i, n : int + + """ + raise NotImplementedError('Missing method "_segmentToRange".') + + def _rangeToSegment(self, i, n): + """ + Parameters + ---------- + i, n : int + + Returns + ------- + segment : :class:`pyannote.base.segment.Segment` + + """ + raise NotImplementedError('Missing method "_rangeToSegment".') + + def __call__(self, subset, mode='loose'): + """ + Use expression 'feature(subset)' + + Parameters + ---------- + subset : :class:`pyannote.base.segment.Segment` or + :class:`pyannote.base.timeline.Timeline` + + Returns + ------- + data : numpy array + + """ + + if not isinstance(subset, (Segment, Timeline)): + raise TypeError('') + + if isinstance(subset, Segment): + i, n = self._segmentToRange(subset) + indices = range(i, i + n) + + elif isinstance(subset, Timeline): + indices = [] + for segment in subset.coverage(): + i, n = self._segmentToRange(segment) + indices += range(i, i + n) + + return np.take(self.__data, indices, axis=0, out=None, mode='clip') + + +class PeriodicPrecomputedFeature(BasePrecomputedSegmentFeature): + + """'Sliding window'-driven precomputed feature iterator. + + Parameters + ---------- + data : numpy array + Feature vectors stored in such a way that data[i] is + ith feature vector. + sliding_window : :class:`SlidingWindow` + Sliding window. Its length must correspond to `data` length + (or it can be infinite -- ie. sliding_window.end = None) + uri : string, optional + name of (audio or video) described resource + + Examples + -------- + >>> data = ... + >>> sliding_window = SlidingWindow( ... ) + >>> feature_iterator = PeriodicPrecomputedFeature(data, sliding_window) + >>> for segment, feature_vector in feature_iterator: + ... pass + + """ + + def __init__(self, data, sliding_window, uri=None): + + super(PeriodicPrecomputedFeature, self).__init__( + data, sliding_window, uri=uri + ) + + def __get_sliding_window(self): + return self._segment_iterator + sliding_window = property(fget=__get_sliding_window) + + def _segmentToRange(self, segment): + """ + Parameters + ---------- + segment : :class:`pyannote.base.segment.Segment` + + Returns + ------- + i, n : int + + """ + return self.sliding_window.segmentToRange(segment) + + def _rangeToSegment(self, i, n): + """ + Parameters + ---------- + i, n : int + + Returns + ------- + segment : :class:`pyannote.base.segment.Segment` + + """ + return self.sliding_window.rangeToSegment(i, n) + + +class TimelinePrecomputedFeature(BasePrecomputedSegmentFeature): + + """Timeline-driven precomputed feature iterator. + + Parameters + ---------- + data : numpy array + Feature vectors stored in such a way that data[i] is ith feature vector. + timeline : :class:`Timeline` + Timeline whose length must correspond to `data` length + uri : string, optional + name of (audio or video) described resource + + Examples + -------- + >>> data = ... + >>> timeline = Timeline( ... ) + >>> feature_iterator = TimelinePrecomputedFeature(data, timeline) + >>> for segment, feature_vector in feature_iterator: + ... pass + + + """ + + def __init__(self, data, timeline, uri=None): + super(TimelinePrecomputedFeature, self).__init__(data, timeline, + uri=uri) + + def __get_timeline(self): + return self._segment_iterator + timeline = property(fget=__get_timeline) + + def _segmentToRange(self, segment): + timeline = self.timeline.crop(segment, mode='loose') + if timeline: + # index of first segment in sub-timeline + first_segment = timeline[0] + i = self.timeline.index(first_segment) + # number of segments in sub-timeline + n = len(timeline) + else: + i = 0 + n = 0 + + return i, n + + def _rangeToSegment(self, i, n): + first_segment = self.timeline[i] + last_segment = self.timeline[i + n] + return first_segment | last_segment + + +class SlidingWindowFeature(object): + + """Periodic feature vectors + + Parameters + ---------- + data : (nSamples, nFeatures) numpy array + + sliding_window : SlidingWindow + + + """ + + def __init__(self, data, sliding_window): + super(SlidingWindowFeature, self).__init__() + self.sliding_window = sliding_window + self.data = data + + def getNumber(self): + """Number of feature vectors""" + return self.data.shape[0] + + def getDimension(self): + """Dimension of feature vectors""" + return self.data.shape[1] + + def getExtent(self): + return self.sliding_window.rangeToSegment(0, self.getNumber()) + + def __getitem__(self, i): + """Get ith feature vector""" + return self.data[i] + + def iterfeatures(self, window=False): + """Feature vector iterator + + Parameters + ---------- + window : bool, optional + When True, yield both feature vector and corresponding window. + Default is to only yield feature vector + + """ + nSamples = self.data.shape[0] + for i in xrange(nSamples): + if window: + yield self.data[i], self.sliding_window[i] + else: + yield self.data[i] + + def crop(self, focus): + """Get set of feature vector for given segment + + Parameters + ---------- + focus : Segment or Timeline + + Returns + ------- + data : numpy array + (nSamples, nFeatures) numpy array + """ + + n = self.getNumber() + + if isinstance(focus, Segment): + firstFrame, frameNumber = self.sliding_window.segmentToRange(focus) + indices = range( + min(n, max(0, firstFrame)), + min(n, max(0, firstFrame+frameNumber)) + ) + + if isinstance(focus, Timeline): + indices = [] + for segment in focus.coverage(): + firstFrame, frameNumber = self.sliding_window.segmentToRange( + segment) + indices += range( + min(n, max(0, firstFrame)), + min(n, max(0, firstFrame+frameNumber)) + ) + + return np.take(self.data, indices, axis=0, out=None, mode='clip') + + +if __name__ == "__main__": + import doctest + doctest.testmod() diff --git a/pyannote/core/interval_tree.py b/pyannote/core/interval_tree.py new file mode 100644 index 00000000..9e1bf6c8 --- /dev/null +++ b/pyannote/core/interval_tree.py @@ -0,0 +1,296 @@ +#!/usr/bin/env python +# encoding: utf-8 + +# The MIT License (MIT) + +# Copyright (c) 2014 CNRS (Hervé BREDIN - http://herve.niderb.fr) + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# ===================================================================== +# Helper functions +# ===================================================================== + +def _kth(node, k): + """Look for kth element of tree rooted at node""" + + if not node: + raise IndexError("index out of range") + + elif node.left: + + # if there are more than k elements in left child + # then the kth element should be found in left child + if k < node.left.metadata.num: + return _kth(node.left, k) + + # if there are less than k elements in left child + # then the kth element should be found in right child + elif k > node.left.metadata.num: + return _kth(node.right, k-1-node.left.metadata.num) + + # if there are exactly k elements in left child + # then the kth (0-indexed) element is in root node + else: + return node.key + + elif k == 0: + return node.key + + else: + return _kth(node.right, k-1) + + +def _index(node, segment, k): + """Look for segment in tree rooted at node""" + + if not node: + raise ValueError("%s is not in timeline" % repr(segment)) + + elif segment < node.key: + return _index(node.left, segment, k) + + elif segment > node.key: + return _index(node.right, + segment, + k+1+(node.left.metadata.num if node.left else 0)) + + else: + return k + (node.left.metadata.num if node.left else 0) + + +def _debug(node, depth): + """Print debug""" + + if node: + _debug(node.right, depth+4) + print " " * depth + repr(node.key) + " " + repr(node.metadata) + _debug(node.left, depth+4) + + +def _dfs(node): + """Depth-first search key iterator""" + + if not node: + return + + for key in _dfs(node.left): + yield key + + yield node.key + + for key in _dfs(node.right): + yield key + + +def _overlapping(node, t): + + segments = [] + + if not node: + return segments + + if node.left: + if node.left.metadata.extent.overlaps(t): + segments.extend(_overlapping(node.left, t)) + + if node.key.overlaps(t): + segments.append(node.key) + + if node.right: + if node.right.metadata.extent.overlaps(t): + segments.extend(_overlapping(node.right, t)) + + return segments + + +def _intersecting(node, segment): + """Returns segments intersecting query segment.""" + + # empty list of segments + segments = [] + + # search left child if it exists + if node.left: + + # if left child extent may intersect query `segment` + # look for intersecting segments in left child + left_extent = node.left.metadata.extent + if left_extent.intersects(segment): + + # if left child extent is fully included in query `segment` + # then every segment intersects query `segment` + if left_extent in segment: + segments.extend([key for key in _dfs(node.left)]) + + # otherwise, only some of them intersects it + # and we must look for them + else: + segments.extend(_intersecting(node.left, segment)) + + # add root segment if it intersects query `segment` + if node.key.intersects(segment): + segments.append(node.key) + + # search right child if it exists + if node.right: + + # if right child extent may intersect query `segment` + # look for intersecting segments in right child + right_extent = node.right.metadata.extent + if right_extent.intersects(segment): + + # if right child extent is fully included in query `segment` + # then every segment intersects query `segment` + if right_extent in segment: + segments.extend([key for key in _dfs(node.right)]) + + # otherwise, only some of them intersects it + # and we must look for them + else: + segments.extend(_intersecting(node.right, segment)) + + # segments are naturally ordered (depth-first search) + return segments + + +def _co_iter(node1, node2): + """Generator of all pairs of intersecting segments""" + + # stop as soon as one tree is empty + if not node1 or not node2: + return + + # stop as as soon as trees do not overlap + if not node1.metadata.extent.intersects(node2.metadata.extent): + return + + # ---- + # if left tree #1 is not empty, process it + # ---- + if node1.left: + + # find overlapping segments in left tree #1 and left tree #2 + for (segment1, segment2) in _co_iter(node1.left, node2.left): + yield segment1, segment2 + + # find segments of left tree #1 overlapping current segment #2 + segment2 = node2.key + for segment1 in _intersecting(node1.left, segment2): + yield segment1, segment2 + + # find overlapping segments in left tree #1 and right tree #2 + for (segment1, segment2) in _co_iter(node1.left, node2.right): + yield segment1, segment2 + + # ---- + # find segments of tree #2 intersecting current segment #1 + # ---- + segment1 = node1.key + + # find segments of left tree #2 overlapping current segment #1 + if node2.left: + for segment2 in _intersecting(node2.left, segment1): + yield segment1, segment2 + + # check if current segments #1 and #2 intersects + segment2 = node2.key + if segment1.intersects(segment2): + yield segment1, segment2 + + # find segments of right tree #2 overlapping current segment #1 + if node2.right: + for segment2 in _intersecting(node2.right, segment1): + yield segment1, segment2 + + # ---- + # if right tree #1 is not empty, process it + # ---- + if node1.right: + + for (segment1, segment2) in _co_iter(node1.right, node2.left): + yield segment1, segment2 + + segment2 = node2.key + for segment1 in _intersecting(node1.right, segment2): + yield segment1, segment2 + + for (segment1, segment2) in _co_iter(node1.right, node2.right): + yield segment1, segment2 + + +# ===================================================================== +# Banyan SortedSet updator +# ===================================================================== + +class TimelineUpdator(object): + + class Metadata(object): + + def update(self, key, key_fn, left, right): + + # number of segments in tree + self.num = 1 + if left: + self.num += left.num + if right: + self.num += right.num + + # extent of tree + self.extent = key + if left: + self.extent = self.extent | left.extent + if right: + self.extent = self.extent | right.extent + + def __repr__(self): + return '{extent: %s, num: %d}' % (repr(self.extent), self.num) + + def length(self): + if self.root: + return self.root.metadata.num + else: + return 0 + + def kth(self, k): + """Get kth segment""" + if k < 0: + return _kth(self.root, self.root.num+k) + else: + return _kth(self.root, k) + + def index(self, segment): + return _index(self.root, segment, 0) + + def extent(self): + return self.root.metadata.extent + + def debug(self): + _debug(self.root, 0) + + def overlapping(self, t): + """Get list of segments overlapping time t""" + return _overlapping(self.root, t) + + def intersecting(self, segment): + return _intersecting(self.root, segment) + + def co_iter(self, other): + for segment, other_segment in _co_iter(self.root, other.root): + yield segment, other_segment diff --git a/pyannote/core/mapping.py b/pyannote/core/mapping.py new file mode 100755 index 00000000..ada92df5 --- /dev/null +++ b/pyannote/core/mapping.py @@ -0,0 +1,497 @@ +#!/usr/bin/env python +# encoding: utf-8 + +# The MIT License (MIT) + +# Copyright (c) 2014 CNRS (Hervé BREDIN - http://herve.niderb.fr) + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +class NoMatch(object): + """ + Parameters + ---------- + format : str, optional + + """ + + nextID = 0 + """ + Keep track of the number of instances since last reset + """ + + @classmethod + def reset(cls): + """Reset counter""" + cls.nextID = 0 + + @classmethod + def next(cls): + """Increment & get counter""" + cls.nextID += 1 + return cls.nextID + + def __init__(self, format='NoMatch%03d'): + super(NoMatch, self).__init__() + self.ID = NoMatch.next() + self.format = format + + def __str__(self): + return self.format % self.ID + + def __repr__(self): + return 'Ø' + + def __hash__(self): + return hash(self.ID) + + def __eq__(self, other): + if isinstance(other, NoMatch): + return self.ID == other.ID + else: + return False + +class MElement(object): + + def __init__(self, modality, element): + super(MElement, self).__init__() + self.modality = modality + self.element = element + + def __eq__(self, other): + return (self.element == other.element) & \ + (self.modality == other.modality) + + def __hash__(self): + return hash(self.element) + + def __str__(self): + return '%s (%s)' % (self.element, self.modality) + + def __repr__(self): + return str(self) + +class Mapping(object): + """Many-to-many label mapping + + Parameters + ---------- + left : str, optional + Left-hand side modality. Defaults to 'left'. + right : str + Right-hand side modality. Defaults to 'right'. + + Returns + ------- + mapping : Mapping + + Examples + -------- + + >>> mapping = Mapping('speaker', 'face') + >>> mapping += (('A', 'B', 'C'), ('a', 'b')) + >>> mapping += (('D', ), ('c', 'd', e)) + >>> print mapping + ( + A B C --> a b + D --> c d e + ) + + """ + def __init__(self, left="left", right="right"): + super(Mapping, self).__init__() + + # left & right modality + self.__left = left + self.__right = right + + # left-to-right one-to-many label mapping + # { left_label --> sorted_right_labels_tuple } + # + self._left_to_right = {} + + # right-to-left one-to-many label mapping + # { right_label --> sorted_left_labels_tuple } + self._right_to_left = {} + + # left-to-right many-to-many label mapping + # { sorted_left_labels_tuple --> sorted_right_labels_tuple } + self._many_to_many = {} + + def __get_left(self): + return self.__left + left = property(fget=__get_left) + """Left-hand side modality""" + + def __get_right(self): + return self.__right + right = property(fget=__get_right) + """Right-hand side modality""" + + def __get_left_set(self): + return set(self._left_to_right) + left_set = property(fget=__get_left_set) + """Left-hand side set of labels""" + + def __get_right_set(self): + return set(self._right_to_left) + right_set = property(fget=__get_right_set) + """Right-hand side set of labels""" + + # Normalize left_right argument to + # ( tuple(sorted_left_labels), tuple(sorted_right_labels) ) + def _check_and_normalize(self, left_right): + + if not isinstance(left_right, (tuple, list)) or len(left_right) != 2: + raise ValueError('expected 2-tuple of list of labels') + + left = left_right[0] + right = left_right[1] + + if left is None: + left = tuple() + elif isinstance(left, (list, tuple, set)): + left = tuple(sorted(left)) + else: + raise ValueError('expected list, tuple or set for left part.') + + if right is None: + right = tuple() + elif isinstance(right, (list, tuple, set)): + right = tuple(sorted(right)) + else: + raise ValueError('expected list, tuple or set for right part.') + + return left, right + + def empty(self): + """Empty copy""" + M = type(self)(self.left, self.right) + return M + + def copy(self): + """Duplicate mapping""" + + # starts with an empty mapping + mapping = self.empty() + + # add + for left, right in self: + mapping += (left, right) + return mapping + + def __add__(self, other): + """ + + Use expression 'mapping + (left_labels, right_labels)' + or 'mapping + other_mapping' + + Parameters + ---------- + other : Mapping or couple of labels + + Returns + ------- + mapping : Mapping + + Examples + -------- + + >>> mapping1 = Mapping() + >>> mapping1 += (('A', 'B', 'C'), ('a', 'b')) + >>> mapping2 = Mapping() + >>> mapping2 += (('D',), ('c', 'd', 'e')) + >>> mapping = mapping1 + mapping2 + >>> print mapping + ( + A B C --> a b + D --> c d e + ) + + """ + + mapping = self.copy() + mapping += other + return mapping + + def __iadd__(self, other): + """ + + Use expression 'mapping += (left_labels, right_labels)' + or 'mapping += other_mapping' + + Examples + -------- + + >>> mapping = Mapping() + >>> mapping += (('A', 'B', 'C'), ('a', 'b')) + >>> print mapping + ( + A B C --> a b + ) + >>> other_mapping = Mapping() + >>> other_mapping += (('D',), ('c', 'd', 'e')) + >>> mapping += other_mapping + >>> print mapping + ( + A B C --> a b + D --> c d e + ) + + Raises + ------ + ValueError + + """ + + if isinstance(other, Mapping): + if other.left != self.left or other.right != self.right: + raise ValueError('incompatible mapping modalities') + + for left, right in other: + self += (left, right) + return self + + left, right = self._check_and_normalize(other) + + already_mapped = set(left) & self.left_set + if already_mapped: + already_mapped = already_mapped.pop() + raise ValueError('%s (%s) is already mapped to %s.' % \ + (already_mapped, self.left, \ + self._left_to_right[already_mapped])) + + already_mapped = set(right) & self.right_set + if already_mapped: + already_mapped = already_mapped.pop() + raise ValueError('%s (%s) is already mapped to %s.' % \ + (already_mapped, self.right, \ + self._right_to_left[already_mapped])) + + for label in left: + self._left_to_right[label] = right + for label in right: + self._right_to_left[label] = left + + if left == tuple(): + left = NoMatch() + if right == tuple(): + right = NoMatch() + self._many_to_many[left] = right + + return self + + # --- iterator --- + + def __iter__(self): + """Left/right mapping iterator + + Examples + -------- + + >>> mapping = Mapping() + >>> mapping += (('A', 'B', 'C'), ('a', 'b')) + >>> mapping += (('D',), ('c', 'd', 'e')) + >>> for left, right in mapping: + ... print '%s --> %s' % (' '.join(sorted(left)), \ + ' '.join(sorted(right))) + A B C --> a b + D --> c d e + + """ + + for left, right in self._many_to_many.iteritems(): + + if isinstance(left, NoMatch): + left = set([]) + else: + left = set(left) + + if isinstance(right, NoMatch): + right = set([]) + else: + right = set(right) + + yield left, right + + def __contains__(self, label): + """Use expression 'label in mapping'""" + return label in self.left_set + + def __hash__(self): + """Use expression hash(mapping)""" + return hash(tuple(sorted(self.left_set))) + \ + hash(tuple(sorted(self.right_set))) + + def __eq__(self, other): + """Use expression 'mapping == other_mapping'""" + return self._left_to_right == other._left_to_right and \ + self._right_to_left == other._right_to_left + + def to_partition(self): + + partition = {} + C = 0 + for left, right in self: + partition.update({MElement(self.left, element): C \ + for element in left}) + partition.update({MElement(self.right, element): C \ + for element in right}) + C += 1 + return partition + + def to_expected_partition(self): + + left = self.left_set + right = self.right_set + expected = {element:e for e, element in enumerate(left | right)} + + partition = {} + for element in left: + partition[MElement(self.left, element)] = expected[element] + for element in right: + partition[MElement(self.right, element)] = expected[element] + + return partition + + def to_dict(self, reverse=False): + if reverse: + return {(tuple(left) if left else NoMatch()): \ + (tuple(right) if right else NoMatch()) \ + for right, left in self} + else: + return {(tuple(left) if left else NoMatch()): \ + (tuple(right) if right else NoMatch()) \ + for left, right in self} + + def to_expected_dict(self, reverse=False): + + left = self.left_set + right = self.right_set + both = left & right + + expected_dict = {} + for element in both: + expected_dict[element] = element + for element in left-both: + expected_dict[element] = NoMatch() + for element in right-both: + expected_dict[NoMatch()] = element + + if reverse: + return {value:key for key, value in expected_dict.iteritems()} + else: + return expected_dict + + def __getitem__(self, key): + return self._left_to_right[key] + + def __str__(self): + """Human-readable representation + + Examples + -------- + + >>> mapping = Mapping() + >>> mapping += (('A', 'B', 'C'), ('a', 'b')) + >>> mapping += (('D',), ('c', 'd', 'e')) + >>> print mapping + ( + A B C --> a b + D --> c d e + ) + """ + + string = "(\n" + for left, right in self: + left = [str(i) for i in left] + right = [str(i) for i in right] + string += ' %s <--> %s\n' % (' '.join(sorted(left)), \ + ' '.join(sorted(right))) + string += ")" + return string + +class ManyToOneMapping(Mapping): + """Many-to-one mapping""" + + def _check_and_normalize(self, mapping): + """ + Extra verification for many-to-one mapping + """ + elements1, elements2 = super(ManyToOneMapping, self)\ + ._check_and_normalize(mapping) + + if len(elements2) > 1: + raise ValueError('Right mapping part (%s) must contain only one element.' % elements2) + + return elements1, elements2 + + @classmethod + def fromMapping(cls, mapping): + M = cls(mapping.left, mapping.right) + for l, r in mapping: + M += (l, r) + return M + + def __getitem__(self, key): + right = self._left_to_right[key] + if right: + return right[0] + else: + return None + + def __call__(self, key): + return self[key] + +class OneToOneMapping(ManyToOneMapping): + """One-to-one mapping""" + + def _check_and_normalize(self, mapping): + """ + Extra verification for one-to-one mapping + """ + elements1, elements2 = super(OneToOneMapping, self)._check_and_normalize(mapping) + + if len(elements1) > 1: + raise ValueError('Left mapping part (%s) must contain only one element.' % elements1) + + return elements1, elements2 + + @classmethod + def fromMapping(cls, mapping): + M = cls(mapping.left, mapping.right) + for l, r in mapping: + M += (l, r) + return M + + def to_dict(self, reverse=False, single=False): + D = super(OneToOneMapping, self).to_dict(reverse=reverse) + if single: + d = {left if isinstance(left, NoMatch) else left[0]: \ + right if isinstance(right, NoMatch) else right[0] \ + for left, right in D.iteritems()} + return d + else: + return D + + +if __name__ == "__main__": + import doctest + doctest.testmod() + diff --git a/pyannote/core/matrix.py b/pyannote/core/matrix.py new file mode 100755 index 00000000..6f2a21ae --- /dev/null +++ b/pyannote/core/matrix.py @@ -0,0 +1,272 @@ +#!/usr/bin/env python +# encoding: utf-8 + +# The MIT License (MIT) + +# Copyright (c) 2014 CNRS (Hervé BREDIN - http://herve.niderb.fr) + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import numpy as np +import pandas +from segment import SEGMENT_PRECISION + +class LabelMatrix(object): + + def __init__(self, data=None, dtype=None, rows=None, columns=None): + super(LabelMatrix, self).__init__() + if data is None and dtype is None: + dtype = np.float + self.df = pandas.DataFrame( + data=data, dtype=dtype, index=rows, columns=columns) + + def __setitem__(self, (row, col), value): + self.df = self.df.set_value(row, col, value) + return self + + def __getitem__(self, (row, col)): + return self.df.at[row, col] + + def get_rows(self): + return list(self.df.index) + + def get_columns(self): + return list(self.df.columns) + + def __get_shape(self): + return self.df.shape + shape = property(fget=__get_shape) + + def __nonzero__(self): + N, M = self.df.shape + return N*M != 0 + + def itervalues(self): + for row in self.get_rows(): + for col in self.get_columns(): + val = self.df.at[row, col] + if not np.isnan(val): + yield row, col, val + def iter_values(self): + for row in self.get_rows(): + for col in self.get_columns(): + val = self.df.at[row, col] + if not np.isnan(val): + yield row, col, val + + def argmax(self, axis=None): + """ + Labels of the maximum values along an axis. + + Parameters + ---------- + axis : int, optional + By default, labels are into the whole matrix, otherwise + along the specified axis (rows or columns) + + Returns + ------- + label_dict : dictionary of labels + Dictionary of labels into the matrix. + {col_label : max_row_label} if axis == 0 + {row_label : max_col_label} if axis == 1 + {max_row_label : max_col_label} if axis == None + """ + + if axis == 0: + return {c: r + for (c, r) in self.df.idxmax(axis=axis).iteritems()} + + elif axis == 1: + return {r: c + for (r, c) in self.df.idxmax(axis=axis).iteritems()} + + else: + values = [ + (_r, _c, self.df.loc[_r, _c]) + for (_c, _r) in self.df.idxmax(axis=0).iteritems() + ] + r, c, _ = sorted(values, key=lambda v: v[2])[-1] + return {r: c} + + def __neg__(self): + negated = LabelMatrix() + negated.df = -self.df + return negated + + def argmin(self, axis=None): + """ + Labels of the minimum values along an axis. + + Parameters + ---------- + axis : int, optional + By default, labels are into the whole matrix, otherwise + along the specified axis (rows or columns) + + Returns + ------- + label_dict : dictionary of labels + Dictionary of labels into the matrix. + {col_label : max_row_label} if axis == 0 + {row_label : max_col_label} if axis == 1 + {max_row_label : max_col_label} if axis == None + """ + + return (-self).argmax(axis=axis) + + def __get_T(self): + transposed = LabelMatrix() + transposed.df = self.df.T + return transposed + T = property(fget=__get_T) + + def remove_column(self, col): + del self.df[col] + return self + + def remove_row(self, row): + df = self.df.T + del df[row] + self.df = df.T + return self + + def copy(self): + copied = LabelMatrix() + copied.df = self.df.copy() + return copied + + def subset(self, rows=None, columns=None): + + if rows is None: + rows = set(self.get_rows()) + + if columns is None: + columns = set(self.get_columns()) + + remove_rows = set(self.get_rows()) - rows + remove_columns = set(self.get_columns()) - columns + + copied = self.copy() + for row in remove_rows: + copied = copied.remove_row(row) + for col in remove_columns: + copied = copied.remove_column(col) + + return copied + + def __gt__(self, value): + compared = LabelMatrix() + compared.df = self.df > value + return compared + + def __str__(self): + return str(self.df) + +def get_cooccurrence_matrix(R, C): + + rows = R.labels() + cols = C.labels() + nRows = len(rows) + nCols = len(cols) + + K = np.zeros((nRows, nCols), dtype=np.float) + for r, row in enumerate(rows): + row_coverage = R.label_coverage(row) + for c, col in enumerate(cols): + col_coverage = C.label_coverage(col) + coverage = row_coverage.crop(col_coverage, mode='intersection') + K[r, c] = coverage.duration() + + return LabelMatrix(data=K, rows=rows, columns=cols) + + +def get_tfidf_matrix(words, documents, idf=True, log=False): + """Term Frequency Inverse Document Frequency (TF-IDF) confusion matrix + + C[i, j] = TF(i, j) x IDF(i) where + - documents are J labels + - words are co-occurring I labels + + duration of word i in document j confusion[i, j] + TF(i, j) = --------------------------------------- = ------------------- + total duration of I words in document j sum confusion[:, j] + + number of J documents + IDF(i) = ---------------------------------------------- + number of J documents co-occurring with word i + + Nj + = ----------------------- + sum confusion[i, :] > 0 + + Parameters + --------- + words : :class:`pyannote.base.annotation.Annotation` + Every label occurrence is considered a word + (weighted by the duration of the segment) + documents : :class:`pyannote.base.annotation.Annotation` + Every label is considered a document. + idf : bool, optional + If `idf` is set to True, returns TF x IDF. + Otherwise, returns TF. Default is True + log : bool, optional + If `log` is True, returns TF x log IDF + """ + M = get_cooccurrence_matrix(words, documents) + Nw, Nd = M.shape + + if Nd == 0: + return M + + K = M.df.values + rows = M.get_rows() + cols = M.get_columns() + + # total duration of all words cooccurring with each document + # np.sum(self.M, axis=0)[j] = 0 ==> self.M[i, j] = 0 for all i + # so we can safely use np.maximum(1e-3, ...) to avoid DivideByZero + tf = K / np.tile( + np.maximum(SEGMENT_PRECISION, np.sum(K, axis=0)), + (Nw, 1) + ) + + # use IDF only if requested (default is True ==> use IDF) + if idf: + + # number of documents cooccurring with each word + # np.sum(self.M > 0, axis=1)[i] = 0 ==> tf[i, j] = 0 for all i + # and therefore tf.idf [i, j ] = 0 + # so we can safely use np.maximum(1, ...) to avoid DivideByZero + idf = np.tile( + float(Nd) / np.maximum(1, np.sum(K > 0, axis=1)), + (Nd, 1)).T + + # use log only if requested (defaults is False ==> do not use log) + if log: + idf = np.log(idf) + + else: + idf = 1. + + return LabelMatrix(data=tf * idf, rows=rows, columns=cols) + +if __name__ == "__main__": + import doctest + doctest.testmod() diff --git a/pyannote/core/notebook.py b/pyannote/core/notebook.py new file mode 100644 index 00000000..8dd256bd --- /dev/null +++ b/pyannote/core/notebook.py @@ -0,0 +1,205 @@ +#!/usr/bin/env python +# encoding: utf-8 + +# The MIT License (MIT) + +# Copyright (c) 2014 CNRS (Hervé BREDIN - http://herve.niderb.fr) + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from IPython.core.pylabtools import print_figure +import matplotlib.pyplot as plt +import itertools +import numpy as np + +from segment import Segment + +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +class Notebook: + pass + +_notebook = Notebook() +_notebook.extent = None + +def set_notebook_crop(segment=None, margin=0.1): + + if segment is None: + _notebook.extent = None + else: + assert isinstance(segment, Segment) + assert segment + duration = segment.duration + _notebook.extent = Segment( + segment.start-margin*duration, + segment.end+margin*duration + ) + +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +def _setup(): + fig, ax = plt.subplots() + ax.set_xlim(_notebook.extent) + ax.set_xlabel('Time') + ax.set_ylim((0, 1)) + ax.axes.get_yaxis().set_visible(False) + return fig, ax + +def _render(fig): + data = print_figure(fig, 'png') + plt.close(fig) + return data + +def _draw_segment(ax, segment, y, color, label=None): + if segment: + ax.hlines(y, segment.start, segment.end, color, lw=1) + ax.vlines(segment.start, y+0.05, y-0.05, color, lw=1) + ax.vlines(segment.end, y+0.05, y-0.05, color, lw=1) + +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +def repr_segment(segment): + + # remember current figure size + figsize = plt.rcParams['figure.figsize'] + # and update it for segment display + plt.rcParams['figure.figsize'] = (10, 1) + + if not _notebook.extent: + set_notebook_crop(segment=segment) + + fig, ax = _setup() + + y = 0.5 + color = 'b' + _draw_segment(ax, segment, y, color) + + data = _render(fig) + + # go back to previous figure size + plt.rcParams['figure.figsize'] = figsize + + return data + +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +def _y(segments): + """ + + Parameters + ---------- + segments : iterator + `Segment` iterator (sorted) + + Returns + ------- + y : np.array + y coordinates of each segment + + """ + + # up_to stores the largest end time + # displayed in each line (at the current iteration) + # (at the beginning, there is only one empty line) + up_to = [-np.inf] + + # y[k] indicates on which line to display kth segment + y = [] + + for segment in segments: + # so far, we do not know which line to use + found = False + # try each line until we find one that is ok + for i, u in enumerate(up_to): + # if segment starts after the previous one + # on the same line, then we add it to the line + if segment.start >= u: + found = True + y.append(i) + up_to[i] = segment.end + break + # in case we went out of lines, create a new one + if not found: + y.append(len(up_to)) + up_to.append(segment.end) + + # from line numbers to actual y coordinates + y = 1. - 1./(len(up_to)+1) * (1+np.array(y)) + + return y + +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +def repr_timeline(timeline): + + # remember current figure size + figsize = plt.rcParams['figure.figsize'] + # and update it for segment display + plt.rcParams['figure.figsize'] = (10, 1) + + if not _notebook.extent and timeline: + set_notebook_crop(segment=timeline.extent()) + + cropped = timeline.crop(_notebook.extent, mode='loose') + + fig, ax = _setup() + + color = 'b' + for segment, y in itertools.izip(cropped, _y(cropped)): + _draw_segment(ax, segment, y, color) + + data = _render(fig) + + # go back to previous figure size + plt.rcParams['figure.figsize'] = figsize + + return data + +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + +def repr_annotation(annotation): + + # remember current figure size + figsize = plt.rcParams['figure.figsize'] + # and update it for segment display + plt.rcParams['figure.figsize'] = (10, 2) + + if not _notebook.extent: + set_notebook_crop(segment=annotation.get_timeline().extent()) + + cropped = annotation.crop(_notebook.extent, mode='loose') + segments = [s for s, _ in cropped.itertracks()] + + fig, ax = _setup() + + for (segment, track, label), y in itertools.izip( + cropped.itertracks(label=True), _y(segments)): + color = 'b' # color = f(label) + _draw_segment(ax, segment, y, color, label=label) + + data = _render(fig) + + # go back to previous figure size + plt.rcParams['figure.figsize'] = figsize + + return data + +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + diff --git a/pyannote/core/scores.py b/pyannote/core/scores.py new file mode 100644 index 00000000..b07291dd --- /dev/null +++ b/pyannote/core/scores.py @@ -0,0 +1,640 @@ +#!/usr/bin/env python +# encoding: utf-8 + +# The MIT License (MIT) + +# Copyright (c) 2014 CNRS (Hervé BREDIN - http://herve.niderb.fr) + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import numpy as np +from pandas import MultiIndex, DataFrame, pivot_table + +from . import PYANNOTE_SEGMENT, PYANNOTE_TRACK, PYANNOTE_LABEL, PYANNOTE_SCORE +from annotation import Annotation, Unknown +from segment import Segment +from timeline import Timeline + + +class AnnotationMixin(object): + + def get_timeline(self): + if self._timelineHasChanged: + self._timeline = Timeline(segments=[s for s, _ in self._df.index], + uri=self.uri) + self._timelineHasChanged = False + return self._timeline + + def __len__(self): + """Number of annotated segments""" + return len(self.get_timeline()) + + def __nonzero__(self): + """False if annotation is empty""" + return len(self.get_timeline()) > 0 + + def __contains__(self, included): + """Check if segments are annotated + + Parameters + ---------- + included : `Segment` or `Timeline` + + Returns + ------- + contains : bool + True if every segment in `included` is annotated, False otherwise. + """ + return included in self.get_timeline() + + def __iter__(self): + """Iterate over sorted segments""" + return iter(self.get_timeline()) + + def __reversed__(self): + """Reverse iterate over sorted segments""" + return reversed(self.get_timeline()) + + def itersegments(self): + return iter(self.get_timeline()) + + def itertracks(self): + """Iterate over annotation as (segment, track) tuple""" + + # make sure segment/track pairs are sorted + self._df = self._df.sort_index() + + for (segment, track), _ in self._df.iterrows(): + yield segment, track + + def crop(self, focus, mode='strict'): + """Crop on focus + + Parameters + ---------- + focus : `Segment` or `Timeline` + + mode : {'strict', 'loose', 'intersection'} + In 'strict' mode, only segments fully included in focus coverage are + kept. In 'loose' mode, any intersecting segment is kept unchanged. + In 'intersection' mode, only intersecting segments are kept and + replaced by their actual intersection with the focus. + + Returns + ------- + cropped : same type as caller + Cropped version of the caller containing only tracks matching + the provided focus and mode. + + Remarks + ------- + In 'intersection' mode, the best is done to keep the track names + unchanged. However, in some cases where two original segments are + cropped into the same resulting segments, conflicting track names are + modified to make sure no track is lost. + + """ + if isinstance(focus, Segment): + + return self.crop(Timeline([focus], uri=self.uri), mode=mode) + + elif isinstance(focus, Timeline): + + # timeline made of all annotated segments + timeline = self.get_timeline() + + # focus coverage + # coverage = focus.coverage() + coverage = focus.segmentation() + + if mode in ['strict', 'loose']: + + # segments (strictly or loosely) included in requested coverage + included = timeline.crop(coverage, mode=mode) + + # boolean array: True if row must be kept, False otherwise + keep = [(s in included) for s, _ in self._df.index] + + # crop-crop + A = self.__class__(uri=self.uri, modality=self.modality) + A._df = self._df[keep] + + return A + + elif mode == 'intersection': + + # two original segments might be cropped into the same resulting + # segment -- therefore, we keep track of the mapping + intersection, mapping = timeline.crop(coverage, + mode=mode, mapping=True) + + # create new empty annotation + A = self.__class__(uri=self.uri, modality=self.modality) + + for cropped in intersection: + for original in mapping[cropped]: + for track in self.tracks(original): + # try to use original track name (candidate) + # if it already exists, create a brand new one + new_track = A.new_track(cropped, candidate=track) + # copy each value, column by column + for label in self._df.columns: + value = self._df.get_value((original, track), + label) + A._df = A._df.set_value((cropped, new_track), + label, value) + + return A + + else: + raise TypeError('') + + def tracks(self, segment): + """Set of tracks for query segment + + Parameters + ---------- + segment : `Segment` + Query segment + + Returns + ------- + tracks : set + Set of tracks for query segment + """ + + try: + df = self._df.xs(segment) + existing_tracks = set(df.index) + + except Exception, e: + existing_tracks = set([]) + + return existing_tracks + + def has_track(self, segment, track): + """Check whether a given track exists + + Parameters + ---------- + segment : `Segment` + Query segment + track : + Query track + + Returns + ------- + exists : bool + True if track exists for segment + """ + return (segment, track) in self._df.index + + def get_track_by_name(self, track): + """Get all tracks with given name + + Parameters + ---------- + track : any valid track name + Requested name track + + Returns + ------- + tracks : list + List of (segment, track) tuples + """ + try: + segments = list(self._df.xs(track, level=1).index) + except Exception, e: + segments = [] + return [(s, track) for s in segments] + + def copy(self): + A = self.__class__(uri=self.uri, modality=self.modality) + A._df = self._df.copy() + return A + + def retrack(self): + """ + """ + A = self.copy() + reindex = MultiIndex.from_tuples([(s, n) + for n, (s, _) in enumerate(A._df.index)]) + A._df.index = reindex + return A + + def new_track(self, segment, candidate=None, prefix=None): + """Track name generator + + Parameters + ---------- + segment : Segment + prefix : str, optional + candidate : any valid track name + + + Returns + ------- + track : str + New track name + """ + + # obtain list of existing tracks for segment + existing_tracks = self.tracks(segment) + + # if candidate is provided, check whether it already exists + # in case it does not, use it + if candidate is not None: + if candidate not in existing_tracks: + return candidate + + # no candidate was provided or the provided candidate already exists + # we need to create a brand new one + + # by default (if prefix is not provided) + # use modality as prefix (eg. speaker1, speaker2, ...) + if prefix is None: + prefix = '' if self.modality is None else str(self.modality) + + # find first non-existing track name for segment + # eg. if speaker1 exists, try speaker2, then speaker3, ... + count = 1 + while ('%s%d' % (prefix, count)) in existing_tracks: + count += 1 + + # return first non-existing track name + return '%s%d' % (prefix, count) + + def __str__(self): + """Human-friendly representation""" + if self: + self._df.sort_index(inplace=True) + return str(self._df) + else: + return "" + + +class Scores(AnnotationMixin, object): + """ + + Parameters + ---------- + uri : str, optional + + modality : str, optional + + Returns + ------- + scores : `Scores` + + Examples + -------- + + >>> s = Scores(uri='video', modality='speaker') + >>> s[Segment(0,1), 's1', 'A'] = 0.1 + >>> s[Segment(0,1), 's1', 'B'] = 0.2 + >>> s[Segment(0,1), 's1', 'C'] = 0.3 + >>> s[Segment(0,1), 's2', 'A'] = 0.4 + >>> s[Segment(0,1), 's2', 'B'] = 0.3 + >>> s[Segment(0,1), 's2', 'C'] = 0.2 + >>> s[Segment(2,3), 's1', 'A'] = 0.2 + >>> s[Segment(2,3), 's1', 'B'] = 0.1 + >>> s[Segment(2,3), 's1', 'C'] = 0.3 + + """ + @classmethod + def from_df( + cls, df, + uri=None, modality=None, aggfunc=np.mean + ): + """ + + Parameters + ---------- + df : DataFrame + Must contain the following columns: + 'segment', 'track', 'label' and 'value' + uri : str, optional + Resource identifier + modality : str, optional + Modality + aggfunc : func + Value aggregation function in case of duplicate (segment, track, + label) tuples + + Returns + ------- + + """ + A = cls(uri=uri, modality=modality) + A._df = pivot_table( + df, values=PYANNOTE_SCORE, + rows=[PYANNOTE_SEGMENT, PYANNOTE_TRACK], cols=PYANNOTE_LABEL, + aggfunc=aggfunc + ) + return A + + def __init__(self, uri=None, modality=None): + super(Scores, self).__init__() + + index = MultiIndex( + levels=[[], []], labels=[[], []], + names=[PYANNOTE_SEGMENT, PYANNOTE_TRACK] + ) + + self._df = DataFrame(index=index, dtype=np.float64) + self.modality = modality + self.uri = uri + self._timelineHasChanged = True + + # del scores[segment] + # del scores[segment, :] + # del scores[segment, track] + def __delitem__(self, key): + + if isinstance(key, Segment): + segment = key + self._df = self._df.drop(segment, axis=0) + self._timelineHasChanged = True + + elif isinstance(key, tuple) and len(key) == 2: + segment, track = key + self._df = self._df.drop((segment, track), axis=0) + self._timelineHasChanged = True + + else: + raise KeyError('') + + # value = scores[segment, track, label] + def __getitem__(self, key): + segment, track, label = key + return self._df.get_value((segment, track), label) + + def get_track_scores(self, segment, track): + """Get all scores for a given track. + + Parameters + ---------- + segment : Segment + track : hashable + segment, track must be a valid track + + Returns + ------- + scores : dict + {label: score} dictionary + """ + return {l: self._df.get_value((segment, track), l) for l in self._df} + + # scores[segment, track, label] = value + def __setitem__(self, key, value): + segment, track, label = key + self._df = self._df.set_value((segment, track), label, value) + self._timelineHasChanged = True + + def labels(self, unknown=True): + """List of labels + + Parameters + ---------- + unknown : bool, optional + When False, do not return Unknown instances + When True, return any label (even Unknown instances) + + Returns + ------- + labels : list + Sorted list of existing labels + + Remarks + ------- + Labels are sorted based on their string representation. + """ + labels = sorted(self._df.columns, key=str) + if unknown: + return labels + else: + return [l for l in labels if not isinstance(l, Unknown)] + + def itervalues(self): + """Iterate over annotation as (segment, track, label, value) tuple""" + + # make sure segment/track pairs are sorted + self._df = self._df.sort_index() + + # yield one (segment, track, label) tuple per loop + labels = self._df.columns + for (segment, track), columns in self._df.iterrows(): + for label in labels: + value = columns[label] + if np.isnan(value): + continue + else: + yield segment, track, label, value + + def _rank(self, invert): + + if invert: + direction = 1. + + else: + direction = -1. + + def nan_rank(data): + + # replace NaN by -inf or +inf depending on the requested direction + finite = np.isfinite(data) + fixed = np.where(finite, direction*data, -direction*np.inf) + + # do the actual argsort + indices = np.argsort(fixed) + # get rank from argsort + rank = np.argsort(indices) + + # special treatment for inverted NaN scores + # (we want ranks to start at 0 even in case of NaN) + if invert: + rank = np.where(finite, rank-(len(data)-np.sum(finite)), np.nan) + else: + rank = np.where(finite, rank, np.nan) + return rank + + return self._df.apply(nan_rank, axis=1) + + def rank(self, invert=False): + """ + + Parameters + ---------- + invert : bool, optional + By default, larger scores are better. + Set `invert` to True to indicate smaller scores are better. + + Returns + ------- + rank : `Scores` + + """ + A = self.__class__(uri=self.uri, modality=self.modality) + A._df = self._rank(invert) + return A + + def nbest(self, n, invert=False): + """ + + Parameters + ---------- + n : int + Size of n-best list + invert : bool, optional + By default, larger scores are better. + Set `invert` to True to indicate smaller scores are better. + + Returns + ------- + nbest : `Scores` + New scores where only n-best are kept. + + """ + df = self._df.copy() + nbest = self._rank(invert) < n + df[~nbest] = np.nan + + A = self.__class__(uri=self.uri, modality=self.modality) + A._df = df + + return A + + def subset(self, labels, invert=False): + """Scores subset + + Extract scores subset based on labels + + Parameters + ---------- + labels : set + Set of labels + invert : bool, optional + If invert is True, extract all but requested `labels` + + Returns + ------- + subset : `Scores` + Scores subset. + """ + + if not isinstance(labels, set): + raise TypeError('labels must be provided as a set of labels.') + + if invert: + labels = set(self.labels()) - labels + else: + labels = labels & set(self.labels()) + + A = self.__class__(uri=self.uri, modality=self.modality) + A._df = self._df[list(labels)] + + return A + + def to_annotation(self, threshold=-np.inf, posterior=False): + """ + + Parameters + ---------- + threshold : float, optional + Each track is annotated with the label with the highest score. + Yet, if the latter is smaller than `threshold`, label is replaced + with an `Unknown` instance. + posterior : bool, optional + If True, scores are posterior probabilities in open-set + identification. If top model posterior is higher than unknown + posterior, it is selected. Otherwise, label is replaced with an + `Unknown` instance. + """ + + annotation = Annotation(uri=self.uri, modality=self.modality) + if not self: + return annotation + + best = self.nbest(1, invert=False) + + if posterior: + + # compute unknown posterior + func = lambda p: 1. - np.nansum(p, axis=1) + Pu = self.apply(func, new_columns=['_']) + + # threshold best target posterior + # with unknown posterior and threshold + for segment, track, label, value in best.itervalues(): + + if value < Pu[segment, track, '_'] or value < threshold: + label = Unknown() + + annotation[segment, track] = label + + else: + + # threshold best target score with threshold + for segment, track, label, value in best.itervalues(): + if value < threshold: + label = Unknown() + annotation[segment, track] = label + + return annotation + + def map(self, func): + """Apply function to all values""" + A = self.__class__(uri=self.uri, modality=self.modality) + A._df = func(self._df) + return A + + def apply(self, data_func, new_index=None, new_columns=None): + """Apply `data_func` on internal numpy array + + Parameters + ---------- + data_func : func + Function expecting (index x columns) numpy array as input + new_index : iterable, optional + When provided, these will be the index of returned array. + new_columns : iterable, optional + When provided, these will be the columns of returned array. + """ + new_data = data_func(self._df.values) + + if new_index is None: + new_index = self._df.index + + if new_columns is None: + new_columns = self._df.columns + + df = DataFrame( + data=new_data, + index=new_index, + columns=new_columns) + + new_scores = self.__class__(uri=self.uri, modality=self.modality) + new_scores._df = df + + return new_scores + + +if __name__ == "__main__": + import doctest + doctest.testmod() diff --git a/pyannote/core/segment.py b/pyannote/core/segment.py new file mode 100755 index 00000000..2ec6ac6b --- /dev/null +++ b/pyannote/core/segment.py @@ -0,0 +1,521 @@ +#!/usr/bin/env python +# encoding: utf-8 + +# The MIT License (MIT) + +# Copyright (c) 2014 CNRS (Hervé BREDIN - http://herve.niderb.fr) + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from collections import namedtuple + +import numpy as np + +SEGMENT_PRECISION = 1e-6 + + +class Segment(namedtuple('Segment', ['start', 'end'])): + """ + Temporal interval defined by its `start` and `end` times. + + Multiple segment operators are available -- including intersection (&), + inclusion (in), emptiness test, start/end time shifting (+, -, >>, <<). + They are illustrated in **Examples** section. + + Comparison of two segments is also available (==, !=, <, <=, >, >=). + Two segments are equal iff they have identical start and end times. + Segment S is smaller than segment T iff S.start < T.start or if they have + the same start time and S.end < T.start. + + Parameters + ---------- + start, end : float + `start` and `end` times, in seconds. + + Returns + ------- + segment : Segment + New segment with `start` and `end` times. + + Examples + -------- + Create a new temporal interval between 00:13.000 and 00:37.000. + + >>> segment = Segment(start=13., end=37) + >>> print segment + [13.000 --> 37.000] + + Inclusion, intersection, union & gap + + >>> s1 = Segment(1, 2) + >>> s2 = Segment(0, 3) + >>> if s1 in s2: + ... print "Segment %s is included in segment %s." % (s1, s2) + Segment [1.000 --> 2.000] is included in segment [0.000 --> 3.000]. + >>> s3 = Segment(2, 5) + >>> print s1 & s3 + ∅ + >>> print s2 & s3 + [2.000 --> 3.000] + >>> print s2 | s3 + [0.000 --> 5.000] + >>> print s1 ^ Segment(5, 7) + [2.000 --> 5.000] + + Test whether segment is empty or not. + + >>> if not Segment(10, 10): + ... print "Segment is empty." + Segment is empty. + + Comparison + + >>> s1 = Segment(1, 3) + >>> s2 = Segment(1, 3) + >>> s3 = Segment(2, 6) + >>> s4 = Segment(1, 2) + >>> for s in sorted([s1, s2, s3, s4]): + ... print s + [1.000 --> 2.000] + [1.000 --> 3.000] + [1.000 --> 3.000] + [2.000 --> 6.000] + + """ + + def __new__(cls, start=0., end=0.): + # add default values + return super(Segment, cls).__new__(cls, start, end) + + def __nonzero__(self): + """Use the expression 'if segment' + + Returns + ------- + valid : bool + False is segment is empty, True otherwise. + + """ + return bool((self.end - self.start) > SEGMENT_PRECISION) + + def _get_duration(self): + return self.end-self.start if self else 0. + duration = property(fget=_get_duration) + """Get segment duration, in seconds.""" + + def _get_middle(self): + return .5*(self.start+self.end) + middle = property(fget=_get_middle) + """Get segment middle time, in seconds.""" + + def copy(self): + """Duplicate segment.""" + return Segment(start=self.start, end=self.end) + + # ------------------------------------------------------- # + # Inclusion (in), intersection (&), union (|) and gap (^) # + # ------------------------------------------------------- # + + def __contains__(self, other): + """Use the expression 'other in segment' + + Returns + ------- + contains : bool + True if other segment is fully included, False otherwise + + """ + return (self.start <= other.start) and (self.end >= other.end) + + def __and__(self, other): + """Use the expression 'segment & other' + + Returns + ------- + segment : Segment + Intersection of the two segments + + """ + start = max(self.start, other.start) + end = min(self.end, other.end) + return Segment(start=start, end=end) + + def intersects(self, other): + """Check whether two segments intersect each other + + Parameters + ---------- + other : Segment + Other segment + + Returns + ------- + intersects : bool + True if segments intersect, False otherwise + """ + if not self or not other: + return False + + return (self.start == other.start) or \ + (self.start < other.start and other.start < self.end-SEGMENT_PRECISION) or \ + (self.start > other.start and self.start < other.end-SEGMENT_PRECISION) + + def overlaps(self, t): + return self.start <= t and self.end >= t + + def __or__(self, other): + """Use the expression 'segment | other' + + Returns + ------- + segment : Segment + Shortest segment that contains both segments + + """ + # if segment is empty, union is the other one + if not self: + return other + # if other one is empty, union is self + if not other: + return self + + # otherwise, do what's meant to be... + start = min(self.start, other.start) + end = max(self.end, other.end) + return Segment(start=start, end=end) + + def __xor__(self, other): + """Use the expression 'segment ^ other' + + Returns + ------- + segment : Segment + Gap between the two segments + + """ + # if segment is empty, xor is not defined + if (not self) or (not other): + raise ValueError('') + + start = min(self.end, other.end) + end = max(self.start, other.start) + return Segment(start=start, end=end) + + def __str__(self): + """Use the expression str(segment)""" + if self: + return '[%.3f --> %.3f]' % (self.start, self.end) + else: + return '∅' + + def _pretty(self, seconds): + from datetime import timedelta + td = timedelta(seconds=seconds) + days = td.days + seconds = td.seconds + microseconds = td.microseconds + hours, remainder = divmod(seconds, 3600) + minutes, seconds = divmod(remainder, 60) + if abs(days) > 0: + return '%d:%02d:%02d:%02d.%03d' % (days, hours, minutes, + seconds, microseconds/1000) + else: + return '%02d:%02d:%02d.%03d' % (hours, minutes, seconds, + microseconds/1000) + + def pretty(self): + """Human-readable representation of segments""" + return '[%s --> %s]' % (self._pretty(self.start), + self._pretty(self.end)) + + def __repr__(self): + return '' % (self.start, self.end) + + def to_json(self): + return {'start': self.start, 'end': self.end} + + def _repr_png_(self): + from pyannote.core.notebook import repr_segment + return repr_segment(self) + + +class SlidingWindow(object): + """Sliding window + + Parameters + ---------- + duration : float > 0, optional + Window duration, in seconds. Default is 30 ms. + step : float > 0, optional + Step between two consecutive position, in seconds. Default is 10 ms. + start : float, optional + First start position of window, in seconds. Default is 0. + end : float > `start`, optional + Default is infinity (ie. window keeps sliding forever) + + Examples + -------- + + >>> sw = SlidingWindow(duration, step, start) + >>> frame_range = (a, b) + >>> frame_range == sw.toFrameRange(sw.toSegment(*frame_range)) + ... True + + >>> segment = Segment(A, B) + >>> new_segment = sw.toSegment(*sw.toFrameRange(segment)) + >>> abs(segment) - abs(segment & new_segment) < .5 * sw.step + + """ + + def __init__(self, duration=0.030, step=0.010, start=0.000, end=None): + super(SlidingWindow, self).__init__() + + # duration must be a float > 0 + if duration <= 0: + raise ValueError("'duration' must be a float > 0.") + self.__duration = duration + + # step must be a float > 0 + if step <= 0: + raise ValueError("'step' must be a float > 0.") + self.__step = step + + # start must be a float. + self.__start = start + + # if end is not provided, set it to infinity + if end is None: + self.__end = np.inf + else: + # end must be greater than start + if end <= start: + raise ValueError("'end' must be greater than 'start'.") + self.__end = end + + def __get_start(self): + return self.__start + start = property(fget=__get_start) + """Sliding window start time in seconds.""" + + def __get_end(self): + return self.__end + end = property(fget=__get_end) + """Sliding window end time in seconds.""" + + def __get_step(self): + return self.__step + step = property(fget=__get_step) + """Sliding window step in seconds.""" + + def __get_duration(self): + return self.__duration + duration = property(fget=__get_duration) + """Sliding window duration in seconds.""" + + def __closest_frame(self, t): + """Closest frame to timestamp. + + Parameters + ---------- + t : float + Timestamp, in seconds. + + Returns + ------- + index : int + Index of frame whose middle is the closest to `timestamp` + + """ + return int(np.rint((t-self.__start-.5*self.__duration)/self.__step)) + + def segmentToRange(self, segment): + """Convert segment to 0-indexed frame range + + Parameters + ---------- + segment : Segment + + Returns + ------- + i0 : int + Index of first frame + n : int + Number of frames + + Examples + -------- + + >>> window = SlidingWindow() + >>> print window.segmentToRange(Segment(10, 15)) + i0, n + + """ + # find closest frame to segment start + i0 = self.__closest_frame(segment.start) + # find closest frame to segment end + j0 = self.__closest_frame(segment.end) + # return frame range as (start_frame, number_of_frame) tuple + i0 = max(0, i0) + n = j0 - i0 + return i0, n + + def rangeToSegment(self, i0, n): + """Convert 0-indexed frame range to segment + + Each frame represents a unique segment of duration 'step', centered on + the middle of the frame. + + The very first frame (i0 = 0) is the exception. It is extended to the + sliding window start time. + + Parameters + ---------- + i0 : int + Index of first frame + n : int + Number of frames + + Returns + ------- + segment : Segment + + Examples + -------- + + >>> window = SlidingWindow() + >>> print window.rangeToSegment(3, 2) + [ --> ] + + """ + + # frame start time + # start = self.start + i0 * self.step + # frame middle time + # start += .5 * self.duration + # subframe start time + # start -= .5 * self.step + start = self.__start + (i0-.5)*self.__step + .5*self.__duration + duration = n*self.__step + end = start+duration + + # extend segment to the beginning of the timeline + if i0 == 0: + start = self.start + + return Segment(start, end) + + def __getitem__(self, i): + """ + Parameters + ---------- + i : int + Index of sliding window position + + Returns + ------- + segment : :class:`Segment` + Sliding window at ith position + + """ + + # window start time at ith position + start = self.__start + i*self.__step + + # in case segment starts after the end, + # return an empty segment + if start >= self.__end: + return None + + return Segment(start=start, end=start+self.__duration) + + def __iter__(self): + """Sliding window iterator + + Use expression 'for segment in sliding_window' + + Examples + -------- + + >>> window = SlidingWindow(end=0.1) + >>> for segment in window: + ... print segment + [0.000 --> 0.030] + [0.010 --> 0.040] + [0.020 --> 0.050] + [0.030 --> 0.060] + [0.040 --> 0.070] + [0.050 --> 0.080] + [0.060 --> 0.090] + [0.070 --> 0.100] + [0.080 --> 0.100] + [0.090 --> 0.100] + + """ + + # get window first position + i = 0 + window = self[i] + + # yield window while it's valid + while(window): + yield window + + # get window next position + i += 1 + window = self[i] + + def __len__(self): + """Number of positions + + Equivalent to len([segment for segment in window]) + + Returns + ------- + length : int + Number of positions taken by the sliding window + (from start times to end times) + + """ + if np.isinf(self.__end): + raise ValueError('infinite sliding window.') + + # start looking for last position + # based on frame closest to the end + i = self.__closest_frame(self.__end) + + while(self[i]): + i += 1 + length = i + + return length + + def copy(self): + """Duplicate sliding window""" + duration = self.duration + step = self.step + start = self.start + end = self.end + sliding_window = SlidingWindow( + duration=duration, step=step, start=start, end=end + ) + return sliding_window + +if __name__ == "__main__": + import doctest + doctest.testmod() diff --git a/pyannote/core/timeline.py b/pyannote/core/timeline.py new file mode 100755 index 00000000..d0c0344a --- /dev/null +++ b/pyannote/core/timeline.py @@ -0,0 +1,584 @@ +#!/usr/bin/env python +# encoding: utf-8 + +# The MIT License (MIT) + +# Copyright (c) 2014 CNRS (Hervé BREDIN - http://herve.niderb.fr) + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import warnings + +from banyan import SortedSet +from interval_tree import TimelineUpdator +from segment import Segment + + +# ignore Banyan warning +warnings.filterwarnings( + 'ignore', 'Key-type optimization', + Warning, 'pyannote.core.timeline' +) +warnings.filterwarnings( + 'ignore', 'Key-type optimization', + Warning, 'banyan' +) + + +# ===================================================================== +# Timeline class +# ===================================================================== + + +class Timeline(object): + """ + Ordered set of segments. + + A timeline can be seen as an ordered set of non-empty segments (Segment). + Segments can overlap -- though adding an already exisiting segment to a + timeline does nothing. + + Parameters + ---------- + segments : Segment iterator, optional + initial set of segments + uri : string, optional + name of segmented resource + + Returns + ------- + timeline : Timeline + New timeline + + Examples + -------- + Create a new empty timeline + + >>> timeline = Timeline() + >>> if not timeline: + ... print "Timeline is empty." + Timeline is empty. + + Add one segment (+=) + + >>> segment = Segment(0, 1) + >>> timeline.add(segment) + >>> if len(timeline) == 1: + ... print "Timeline contains only one segment." + Timeline contains only one segment. + + Add all segments from another timeline + + >>> other_timeline = Timeline([Segment(0.5, 3), Segment(6, 8)]) + >>> timeline.update(other_timeline) + + Get timeline extent, coverage & duration + + >>> extent = timeline.extent() + >>> print extent + [0 --> 8] + >>> coverage = timeline.coverage() + >>> print coverage + [ + [0 --> 3] + [6 --> 8] + ] + >>> duration = timeline.duration() + >>> print "Timeline covers a total of %g seconds." % duration + Timeline covers a total of 5 seconds. + + Iterate over (sorted) timeline segments + + >>> for segment in timeline: + ... print segment + [0 --> 1] + [0.5 --> 3] + [6 --> 8] + + Segmentation + + >>> segmentation = timeline.segmentation() + >>> print segmentation + [ + [0 --> 0.5] + [0.5 --> 1] + [1 --> 3] + [6 --> 8] + ] + + Gaps + + >>> timeline = timeline.copy() + >>> print timeline + [ + [0 --> 1] + [0.5 --> 3] + [6 --> 8] + ] + >>> print timeline.gaps() + [ + [3 --> 6] + ] + >>> segment = Segment(0, 10) + >>> print timeline.gaps(segment) + [ + [3 --> 6] + [8 --> 10] + ] + + """ + + def __init__(self, segments=None, uri=None): + + super(Timeline, self).__init__() + + # sorted set of segments (as an augmented red-black tree) + segments = [s for s in segments if s] if segments else [] + self._segments = SortedSet(items=segments, + key_type=(float, float), + updator=TimelineUpdator) + + # path to (or any identifier of) segmented resource + self.uri = uri + + def __len__(self): + return self._segments.length() + + def __nonzero__(self): + return self._segments.length() > 0 + + def __iter__(self): + return iter(self._segments) + + def __getitem__(self, k): + """Returns kth segment""" + return self._segments.kth(k) + + def __eq__(self, other): + return self._segments == other._segments + + def __ne__(self, other): + return self._segments != other._segments + + def index(self, segment): + """Index of segment + + Parameter + --------- + segment : Segment + + Raises + ------ + ValueError if the segment is not present + """ + return self._segments.index(segment) + + def add(self, segment): + """Add segment""" + if segment: + self._segments.add(segment) + + def update(self, timeline): + """Add `timeline` segments""" + self._segments.update(timeline._segments) + + def union(self, other): + """Create new timeline made of union of segments""" + segments = self._segments.union(other._segments) + return Timeline(segments=segments, uri=self.uri) + + def co_iter(self, other): + for segment, other_segment in self._segments.co_iter(other._segments): + yield segment, other_segment + + def crop(self, other, mode='intersection', mapping=False): + + if isinstance(other, Segment): + other = Timeline(segments=[other], uri=self.uri) + return self.crop(other, mode=mode, mapping=mapping) + + elif isinstance(other, Timeline): + + if mode == 'loose': + segments = [segment for segment, _ in self.co_iter(other)] + return Timeline(segments=segments, uri=self.uri) + + elif mode == 'strict': + segments = [segment + for segment, other_segment in self.co_iter(other) + if segment in other_segment] + return Timeline(segments=segments, uri=self.uri) + + elif mode == 'intersection': + if mapping: + mapping = {} + for segment, other_segment in self.co_iter(other): + inter = segment & other_segment + mapping[inter] = mapping.get(inter, list()) + [segment] + return Timeline(segments=mapping, uri=self.uri), mapping + else: + segments = [segment & other_segment + for segment, other_segment in self.co_iter(other)] + return Timeline(segments=segments, uri=self.uri) + + else: + raise NotImplementedError("unsupported mode: '%s'" % mode) + + def overlapping(self, timestamp): + """Get list of segments overlapping `timestamp`""" + return self._segments.overlapping(timestamp) + + def __str__(self): + """Human-friendly representation""" + + string = "[\n" + for segment in self._segments: + string += " %s\n" % str(segment) + string += "]" + return string + + def __repr__(self): + return "" % (self.uri, + list(self._segments)) + + def __contains__(self, included): + """Inclusion + + Use expression 'segment in timeline' or 'other_timeline in timeline' + + Parameters + ---------- + included : `Segment` or `Timeline` + + Returns + ------- + contains : bool + True if every segment in `included` exists in timeline, + False otherwise + + """ + + if isinstance(included, Segment): + return included in self._segments + + elif isinstance(included, Timeline): + return self._segments.issuperset(included._segments) + + else: + raise TypeError() + + def empty(self): + """Empty copy of a timeline. + + Examples + -------- + + >>> timeline = Timeline(uri="MyVideo.avi") + >>> timeline += [Segment(0, 1), Segment(2, 3)] + >>> empty = timeline.empty() + >>> print empty.uri + MyVideo.avi + >>> print empty + [ + ] + + """ + return Timeline(uri=self.uri) + + def copy(self, segment_func=None): + """Duplicate timeline. + + If segment_func is provided, apply it to each segment first. + + Parameters + ---------- + segment_func : function + + Returns + ------- + timeline : Timeline + A (possibly modified) copy of the timeline + + Examples + -------- + + >>> timeline = Timeline(uri="MyVideo.avi") + >>> timeline += [Segment(0, 1), Segment(2, 3)] + >>> cp = timeline.copy() + >>> print cp.uri + MyVideo.avi + >>> print cp + [ + [0 --> 1] + [2 --> 3] + ] + + """ + + # if segment_func is not provided + # just add every segment + if segment_func is None: + return Timeline(segments=self._segments, uri=self.uri) + + # if is provided + # apply it to each segment before adding them + else: + return Timeline(segments=[segment_func(s) for s in self._segments], + uri=self.uri) + + def extent(self): + """Timeline extent + + The extent of a timeline is the segment of minimum duration that + contains every segments of the timeline. It is unique, by definition. + The extent of an empty timeline is an empty segment. + + Returns + ------- + extent : Segment + Timeline extent + + Examples + -------- + + >>> timeline = Timeline(uri="MyVideo.avi") + >>> timeline += [Segment(0, 1), Segment(9, 10)] + >>> print timeline.extent() + [0 --> 10] + + """ + return self._segments.extent() + + def coverage(self): + """Timeline coverage + + The coverage of timeline is the timeline with the minimum number of + segments with exactly the same time span as the original timeline. + It is (by definition) unique and does not contain any overlapping + segments. + + Returns + ------- + coverage : Timeline + Timeline coverage + + """ + + # make sure URI attribute is kept. + coverage = Timeline(uri=self.uri) + + # The coverage of an empty timeline is an empty timeline. + if not self: + return coverage + + # Principle: + # * gather all segments with no gap between them + # * add one segment per resulting group (their union |) + # Note: + # Since segments are kept sorted internally, + # there is no need to perform an exhaustive segment clustering. + # We just have to consider them in their natural order. + + # Initialize new coverage segment + # as very first segment of the timeline + new_segment = self._segments.kth(0) + + for segment in self: + + # If there is no gap between new coverage segment and next segment, + if not (segment ^ new_segment): + # Extend new coverage segment using next segment + new_segment |= segment + + # If there actually is a gap, + else: + # Add new segment to the timeline coverage + coverage.add(new_segment) + # Initialize new coverage segment as next segment + # (right after the gap) + new_segment = segment + + # Add new segment to the timeline coverage + coverage.add(new_segment) + + return coverage + + def duration(self): + """Timeline duration + + Returns + ------- + duration : float + Duration of timeline coverage, in seconds. + + """ + + # The timeline duration is the sum of the durations + # of the segments in the timeline coverage. + return sum([s.duration for s in self.coverage()]) + + def gaps(self, focus=None): + """Timeline gaps + + Parameters + ---------- + focus : None, Segment or Timeline + + Returns + ------- + gaps : Timeline + Timeline made of all gaps from original timeline, and delimited + by provided segment or timeline. + + Raises + ------ + TypeError when `focus` is neither None, Segment nor Timeline + + Examples + -------- + + """ + if focus is None: + focus = self.extent() + + if not isinstance(focus, (Segment, Timeline)): + raise TypeError("unsupported operand type(s) for -':" + "%s and Timeline." % type(focus).__name__) + + # segment focus + if isinstance(focus, Segment): + + # starts with an empty timeline + timeline = self.empty() + + # `end` is meant to store the end time of former segment + # initialize it with beginning of provided segment `focus` + end = focus.start + + # focus on the intersection of timeline and provided segment + for segment in self.crop(focus, mode='intersection').coverage(): + + # add gap between each pair of consecutive segments + # if there is no gap, segment is empty, therefore not added + timeline.add(Segment(start=end, end=segment.start)) + + # keep track of the end of former segment + end = segment.end + + # add final gap (if not empty) + timeline.add(Segment(start=end, end=focus.end)) + + # other_timeline - timeline + elif isinstance(focus, Timeline): + + # starts with an empty timeline + timeline = self.empty() + + # add gaps for every segment in coverage of provided timeline + for segment in focus.coverage(): + timeline.update(self.gaps(focus=segment)) + + return timeline + + def segmentation(self): + """Non-overlapping timeline + + Create the unique timeline with same coverage and same set of segment + boundaries as original timeline, but with no overlapping segments. + + A picture is worth a thousand words: + + Original timeline: + |------| |------| |----| + |--| |-----| |----------| + + Non-overlapping timeline + |-|--|-| |-|---|--| |--|----|--| + + Returns + ------- + timeline : Timeline + + Examples + -------- + + >>> timeline = Timeline() + >>> timeline += [Segment(0, 1), Segment(1, 2), Segment(2,3)] + >>> timeline += [Segment(2, 4), Segment(6, 7)] + >>> print timeline.segmentation() + [ + [0 --> 1] + [1 --> 2] + [2 --> 3] + [3 --> 4] + [6 --> 7] + ] + + """ + # COMPLEXITY: O(n) + coverage = self.coverage() + + # COMPLEXITY: O(n.log n) + # get all boundaries (sorted) + # |------| |------| |----| + # |--| |-----| |----------| + # becomes + # | | | | | | | | | | | | + timestamps = set([]) + for (start, end) in self: + timestamps.add(start) + timestamps.add(end) + timestamps = sorted(timestamps) + + # create new partition timeline + # | | | | | | | | | | | | + # becomes + # |-|--|-| |-|---|--| |--|----|--| + + # start with an empty copy + timeline = Timeline(uri=self.uri) + + if len(timestamps) > 0: + segments = [] + start = timestamps[0] + for end in timestamps[1:]: + + # only add segments that are covered by original timeline + segment = Segment(start=start, end=end) + if segment and coverage.overlapping(segment.middle): + segments.append(segment) + # next segment... + + start = end + + timeline._segments.update(segments) + + return timeline + + def to_json(self): + return [s.to_json() for s in self] + + def _repr_png_(self): + from pyannote.core.notebook import repr_timeline + return repr_timeline(self) + + +if __name__ == "__main__": + import doctest + doctest.testmod() From bfab8f2d06282517f46ea7386f598eae5a57ea0a Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Fri, 2 May 2014 18:58:48 +0200 Subject: [PATCH 004/458] fix: link to documentation --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index cbe09ae6..30173e76 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ pyannote.core ============= -[Documentation](http://nbviewer.ipython.org/github/hbredin/pyannote.core/blob/develop/index.ipynb) \ No newline at end of file +[Documentation](http://nbviewer.ipython.org/github/hbredin/pyannote-core/blob/develop/doc/index.ipynb) \ No newline at end of file From 2b445412f1d74cb46b6e75d171039a55c67c5914 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Fri, 2 May 2014 22:14:12 +0200 Subject: [PATCH 005/458] feat: display annotation labels in IPython notebook --- pyannote/core/notebook.py | 35 +++++++++++++++++++++++++++++------ 1 file changed, 29 insertions(+), 6 deletions(-) diff --git a/pyannote/core/notebook.py b/pyannote/core/notebook.py index 8dd256bd..a7d90145 100644 --- a/pyannote/core/notebook.py +++ b/pyannote/core/notebook.py @@ -25,9 +25,12 @@ from IPython.core.pylabtools import print_figure import matplotlib.pyplot as plt +from matplotlib.cm import get_cmap import itertools +import codecs import numpy as np + from segment import Segment # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -37,6 +40,8 @@ class Notebook: _notebook = Notebook() _notebook.extent = None +_DEFAULT_NOTEBOOK_WIDTH = 10 +_notebook.width = _DEFAULT_NOTEBOOK_WIDTH def set_notebook_crop(segment=None, margin=0.1): @@ -51,6 +56,12 @@ def set_notebook_crop(segment=None, margin=0.1): segment.end+margin*duration ) +def set_notebook_width(inches=None): + if inches is None: + _notebook.width = _DEFAULT_NOTEBOOK_WIDTH + else: + _notebook.width = inches + # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def _setup(): @@ -70,7 +81,12 @@ def _draw_segment(ax, segment, y, color, label=None): if segment: ax.hlines(y, segment.start, segment.end, color, lw=1) ax.vlines(segment.start, y+0.05, y-0.05, color, lw=1) - ax.vlines(segment.end, y+0.05, y-0.05, color, lw=1) + ax.vlines(segment.end, y+0.05, y-0.05, color, lw=1) + if label: + text = ax.text(segment.middle, y+0.05, codecs.encode(unicode(label), 'ascii', 'replace'), + horizontalalignment='center', fontsize=10) + # text.draw() + # [[x0, y0], [x1, y1]] = text.get_window_extent().get_points() # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -79,7 +95,7 @@ def repr_segment(segment): # remember current figure size figsize = plt.rcParams['figure.figsize'] # and update it for segment display - plt.rcParams['figure.figsize'] = (10, 1) + plt.rcParams['figure.figsize'] = (_notebook.width, 1) if not _notebook.extent: set_notebook_crop(segment=segment) @@ -151,7 +167,7 @@ def repr_timeline(timeline): # remember current figure size figsize = plt.rcParams['figure.figsize'] # and update it for segment display - plt.rcParams['figure.figsize'] = (10, 1) + plt.rcParams['figure.figsize'] = (_notebook.width, 1) if not _notebook.extent and timeline: set_notebook_crop(segment=timeline.extent()) @@ -173,13 +189,12 @@ def repr_timeline(timeline): # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - def repr_annotation(annotation): # remember current figure size figsize = plt.rcParams['figure.figsize'] # and update it for segment display - plt.rcParams['figure.figsize'] = (10, 2) + plt.rcParams['figure.figsize'] = (_notebook.width, 2) if not _notebook.extent: set_notebook_crop(segment=annotation.get_timeline().extent()) @@ -187,11 +202,19 @@ def repr_annotation(annotation): cropped = annotation.crop(_notebook.extent, mode='loose') segments = [s for s, _ in cropped.itertracks()] + # one color per label + chart = cropped.chart() + cm = get_cmap('gist_rainbow') + colors = { + label: cm(1.*i/len(chart)) + for i, (label, _) in enumerate(chart) + } + fig, ax = _setup() for (segment, track, label), y in itertools.izip( cropped.itertracks(label=True), _y(segments)): - color = 'b' # color = f(label) + color = colors[label] # color = f(label) _draw_segment(ax, segment, y, color, label=label) data = _render(fig) From cd088aba5d3c08861dd7d1948c25ed005704cc4b Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Fri, 2 May 2014 22:14:55 +0200 Subject: [PATCH 006/458] feat(Annotation): a[segment] == a[segment, '_'] --- pyannote/core/annotation.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/pyannote/core/annotation.py b/pyannote/core/annotation.py index 30f71a3d..380a493b 100755 --- a/pyannote/core/annotation.py +++ b/pyannote/core/annotation.py @@ -451,11 +451,18 @@ class Annotation(object): # label = annotation[segment, track] def __getitem__(self, key): + + if isinstance(key, Segment): + key = (key, '_') + return self._tracks[key[0]][key[1]] # annotation[segment, track] = label def __setitem__(self, key, label): + if isinstance(key, Segment): + key = (key, '_') + if key[0] not in self._tracks: self._tracks[key[0]] = {} self._timelineNeedsUpdate = True From 1968358445a6f7c1b703e341cd75c31d0109382b Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Fri, 2 May 2014 22:18:49 +0200 Subject: [PATCH 007/458] doc: Annotation --- doc/index.ipynb | 28 +- doc/pyannote.core.annotation.ipynb | 1198 ++++++++++++++++++++++++++++ 2 files changed, 1224 insertions(+), 2 deletions(-) create mode 100644 doc/pyannote.core.annotation.ipynb diff --git a/doc/index.ipynb b/doc/index.ipynb index dc855f93..f1da9e6a 100644 --- a/doc/index.ipynb +++ b/doc/index.ipynb @@ -1,7 +1,7 @@ { "metadata": { "name": "", - "signature": "sha256:3e295104febcaf8e546ee8ee6c91f6991a7dba086959f3caef5ab40c92b01eb4" + "signature": "sha256:9358a0cd9feb4f3aeb0db4a6cdb9aac9a0f5b7009558534b31a2866ba57a2b4b" }, "nbformat": 3, "nbformat_minor": 0, @@ -60,8 +60,32 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "[Annotation](pyannote.core.annotation) (`pyannote.core.annotation`)" + "[Annotation](pyannote.core.annotation.ipynb) (`pyannote.core.annotation`)" ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Contribute" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`pyannote.core` is on [Github](https://github.com/hbredin/pyannote-core]. \n", + "Please fork and pull requests :)" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] } ], "metadata": {} diff --git a/doc/pyannote.core.annotation.ipynb b/doc/pyannote.core.annotation.ipynb new file mode 100644 index 00000000..efedf8db --- /dev/null +++ b/doc/pyannote.core.annotation.ipynb @@ -0,0 +1,1198 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:a4d5ace5db53f04fbea7d935faf9b49cbdaeb510d5a7f2cdd07cf162894ad3c4" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "%pylab inline\n", + "from pyannote.core.notebook import set_notebook_crop" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Annotation (`pyannote.core.annotation.Annotation`)" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from pyannote.core import Annotation" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**`Annotation`** instances are used to describe sets of annotated temporal fragments. \n", + "For instance, one can use an **`Annotation`** to store the result of speaker identification approach applied on an episode of *The Big Bang Theory* TV series." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "annotation = Annotation(\n", + " uri='TheBigBangTheory.Season01.Episode01', \n", + " modality='speaker'\n", + ")" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For instance, to represent a dialogue between Penny and Leonard, we could do the following:" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from pyannote.core import Segment\n", + "annotation[Segment(3, 5)] = 'Penny'\n", + "annotation[Segment(5.5, 7)] = 'Leonard'\n", + "annotation[Segment(8, 10)] = 'Penny'\n", + "annotation" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAHgGhv9P8Kv/AAAAAElFTkSuQmCC\n", + "prompt_number": 4, + "text": [ + "" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, suppose (super-annoying) Sheldon speaks over Penny's second speech turn." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "annotation[Segment(8, 10)] = 'Sheldon'\n", + "annotation" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nuTbqt2brAAAAAElFTkSuQmCC\n", + "prompt_number": 5, + "text": [ + "" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Damn, Sheldon! That's not what we wanted! We did not want to replace Penny by Sheldon. Instead, we wanted to show that both characters are speaking at the very same time. \n", + "To achieve this, we need to create a new track for the same segment." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "segment = Segment(8, 10)\n", + "annotation[segment, annotation.new_track(segment)] = 'Penny'\n", + "annotation" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "prompt_number": 6, + "text": [ + "" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's much better!\n", + "A track cannot be identified by a segment alone: it is uniquely identified by a 2-tuple (segment, track_identifier)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In fact, the **new_track** method is simply an helper function to help you generate new track identifiers for a given segment.\n", + "And the previous lines are in fact shortcuts for the following:" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "annotation = Annotation(\n", + " uri='TheBigBangTheory.Season01.Episode01', \n", + " modality='speaker'\n", + ")\n", + "annotation[Segment(3, 5), '_'] = 'Penny'\n", + "annotation[Segment(5.5, 7), '_',] = 'Leonard'\n", + "annotation[Segment(8, 10), '_'] = 'Penny'\n", + "annotation[Segment(8, 10), 'anything'] = 'Sheldon'\n", + "annotation" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "prompt_number": 7, + "text": [ + "" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`_` is the default track identifier (in case you are sure that each segment has only one associated track). Generally, you should avoid using the shortcut `annotation[segment]` and always add a track identifier of your choosing. " + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Iterating over segments, tracks and/or labels" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "for segment in annotation.itersegments():\n", + " print segment" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "[3.000 --> 5.000]\n", + "[5.500 --> 7.000]\n", + "[8.000 --> 10.000]\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "for segment, track in annotation.itertracks():\n", + " print segment, track" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "[3.000 --> 5.000] _\n", + "[5.500 --> 7.000] _\n", + "[8.000 --> 10.000] anything\n", + "[8.000 --> 10.000] _\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "for segment, track, label in annotation.itertracks(label=True):\n", + " print segment, track, label" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "[3.000 --> 5.000] _ Penny\n", + "[5.500 --> 7.000] _ Leonard\n", + "[8.000 --> 10.000] anything Sheldon\n", + "[8.000 --> 10.000] _ Penny\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Dealing with segments" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One can use the **get_timeline** method to obtain a [timeline](pyannote.core.timeline.ipynb) made of all segments (not tracks!) in the annotation" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "annotation.get_timeline()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAASUVORK5CYII=\n", + "prompt_number": 11, + "text": [ + ", , ])>" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Dealing with tracks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Get all tracks for a given segment" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "annotation.get_tracks(Segment(8, 10))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "prompt_number": 12, + "text": [ + "{'_', 'anything'}" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check whether a given track exists" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "annotation.has_track(Segment(8, 10), '---')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "prompt_number": 13, + "text": [ + "False" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One can re-initialize tracks as incrementing integer using **retrack** method. This also makes sure that no two tracks have the same identifier." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "for segment, track in annotation.retrack().itertracks():\n", + " print segment, track" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "[3.000 --> 5.000] 0\n", + "[5.500 --> 7.000] 1\n", + "[8.000 --> 10.000] 2\n", + "[8.000 --> 10.000] 3\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Dealing with labels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Get (sorted) list of unique labels" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "annotation.labels()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "prompt_number": 15, + "text": [ + "['Leonard', 'Penny', 'Sheldon']" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "List of labels for a given segment. Read the help message for more options." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "annotation.get_labels(Segment(8, 10))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "prompt_number": 16, + "text": [ + "{'Penny', 'Sheldon'}" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One may want to be more precise on the identiy of each speaker and replace character names by actor names. We can use **translate** to do just that:" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "mapping = {'Penny': 'Kaley Cuoco', 'Sheldon': 'Jim Parsons', 'Leonard': 'Johnny Galecki'}\n", + "annotation.translate(mapping)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAG6pJREFUeJzt3XtU1VX+//HnQTAqb+h4KzVQRwThcA4yOGoqGWjU2NIS\nV6Ijoow5Llv+bHSVNTPQNydrlVOkWWZGWixNrZwMdSoTNY2voSiOTtCwZNQZY7yVFyTknP37g/Eo\nivTNkA9+fD3WYgn7c3u72RxeZ3/2OTiMMQYRERERG/OzugARERGRa02BR0RERGxPgUdERERsT4FH\nREREbE+BR0RERGxPgUdERERsz7+ujXFxcWzatKmhahERERG5aoMGDSI3N7fWbXXO8GzatAljzHX5\nkZ6ebnkNjeFD/aC+UD+oH9QX6ocbpS/qmqTRLS0RERGxPQUeERERsT3bBp64uDirS2gU1A8XqC+q\nqR+qqR8uUF9UUz9cYMe+cBhjrvi3tBwOB3VsFhEREWk06sottp3hERERETlPgUdERERsT4FHRERE\nbE+BR0RERGxPgUdERERsT4FHREREbE+BR0RERGxPgUdERERsT4FHREREbE+BR0RERGxPgUdERERs\nT4FHREREbE+BR0RERGxPgUdERERsT4FHREREbE+BR0RERGxPgUdERERsT4FHREREbE+BpwE1a9bM\n9/natWsJDQ3l4MGDV9w/IyODuXPn1su1ly5dSmRkJE6nk+jo6Ho7rzSci8fPpXJzcxk2bFgDVgNl\nZWUkJyfTrVs3YmJi6NevH6tXr67zmNLSUiIjI6/qenFxcezYseOy9vvuu4+TJ09e1Tnl+tC8eXMO\nHz5MUlLSVZ8jIyODTp064Xa7iYyMZM2aNfVYoVwPFHgakMPhAGDDhg1MmzaN9evX07lz5x/c/6da\nt24dmZmZfPLJJxQWFpKXl0fLli3r5dzScOprPNQHYwzDhw8nLi6OkpIS8vPzWb58OYcOHbpm13Q4\nHLX2QU5ODi1atLhm15XGoWPHjqxcufKqj3c4HDz66KMUFBSwcuVKJkyY8H8+1uv1XvV1pfFQ4Glg\nmzdvZtKkSeTk5BASEgLAokWLiI2NxeVyMXLkSM6ePXvZcSUlJSQmJhITE8PAgQMpKiri1KlTdO3a\nlaqqKgBOnjxJ165d8Xg8NY6dM2cOc+fOpUOHDgA0bdqUtLQ0oOaz5qNHj/pqqqioIDU11TcjlJub\nC4DH42HGjBlERkYSFRXF/PnzgeoQFx0djdPpZOLEiVRWVtZzz8l5M2fO9M3WrVixwtd++vRpkpKS\nCAsLY+zYsb724OBgMjIy6N27N06nk6KiIqD6Ge+ECRO466676NatG/PmzQMgPT2dzMxM3/FPPvkk\nL7/8co0aPvvsM2666SYmTZrka+vSpQtTp04FqmdyBg4cSO/evenduzdffPHFZf8Pj8fDzJkziY2N\nJSoqitdff9237bnnnsPpdOJyuXjiiSdqHOf1ehk/fjx//OMfff+/48eP/7hOlOvOP//5TyIiIgB4\n6623GD58OEOGDCEkJIT58+fzwgsvEB0dTd++fTlx4kSt5zDGANCzZ0/8/f05cuQII0aMICYmhoiI\nCBYtWuTbt1mzZsyYMQOXy8UXX3zB448/Tq9evYiKimLmzJlA9TgfPHgwUVFRxMfH+2bsx48fz7Rp\n0+jfvz/dunXjvffeA+Dw4cMMHDjQN8v0+eefX7P+klqYOvzAZvmR/P39TevWrc2ePXtqtB87dsz3\n+e9//3szb948Y4wxGRkZZu7cucYYYwYPHmy+/vprY4wxeXl5ZvDgwcYYY1JTU83q1auNMcYsXLjQ\nzJgx47Lrtm7d2pw8ebLWmuLi4syOHTuMMcYcOXLEBAcHG2OMeeGFF8zEiRONMcZ89dVXpkuXLqai\nosIsWLDAJCUlGY/HY4wx5vjx4+bs2bOmc+fOvvrGjRtnXnrppR/bPfIDmjVrZt577z2TkJBgvF6v\nKSsrM126dDGHDx82GzduNC1btjT/+te/jNfrNX379jVbt241xhgTHBxs5s+fb4wxZsGCBSYtLc0Y\nY0x6errp37+/qaysNEePHjVt2rQxVVVVprS01ERHRxtjjPF4PKZbt27m+PHjNWrJzMw006dPv2Kt\n5eXlpqKiwhhjTHFxsYmJiTHGGLN//34TERFhjKker7NnzzbGGFNRUWFiYmLM/v37zdq1a02/fv3M\n2bNnjTHGnDhxwhhTPVbz8vLMQw89ZJ555hnftYKDg2v8DIn9NGvWzJSWlvrGTlZWlunevbs5ffq0\nOXLkiGnRooVZuHChMcaY6dOn1/r4k5GRYV544QVjTPVj6O23326MMb6xXV5ebiIiInxfOxwOs3Ll\nSmOMMUePHjWhoaG+c3333XfGGGN+9atfmaVLlxpjjHnzzTfN8OHDjTHGpKSkmFGjRhljjNm3b5/p\n3r27Mab6cfVPf/qTMcYYr9drTp06VS/9IxfUlVs0w9OAmjZtSv/+/XnjjTdqtO/Zs4cBAwbgdDrJ\nzs5m3759NbafOXOGbdu2kZSUhNvtZvLkyXzzzTcApKWlkZWVBVQ/60lNTa2XWrdu3eqbJQgNDeWO\nO+6guLiYDRs28PDDD+PnVz10goKCKCoqIiQkhO7duwOQkpLC5s2b66UOqenzzz8nOTkZh8NBu3bt\nGDRoEF9++SUOh4PY2Fhuu+02HA4HLpeL0tJS33EPPPAAANHR0b52h8PBfffdR0BAAG3atKFdu3aU\nlZVxxx130KZNG3bt2sXHH39MdHQ0QUFBNeq49NbS1KlTcblcxMbGAlBZWUlaWhpOp5NRo0ZdNqYB\nPv74Y5YuXYrb7eaXv/wlx48f5+uvv2bDhg1MmDCBwMBAAFq1agVUPzt/+OGHcTqdzJo1q176U65f\nd911F7feeis/+9nPaNWqlW8NW2RkZI2xf54xhhdffBG3283MmTN59913AcjMzMTlctG3b18OHjzI\n119/DUCTJk148MEHAWjZsiWBgYFMnDiRDz74gJtvvhmAvLw8kpOTARg7dqxvxsbhcDB8+HAAwsLC\nKCsrAyA2NpasrCyeeuopCgsL61yXJ/VPgacB+fn5sWLFCrZv386cOXN87ePHj2fBggUUFhaSnp5+\n2S0tr9dLUFAQBQUFvo+9e/cC0K9fP0pLS8nNzcXj8RAeHn7ZdXv16kV+fn6tNfn7+/vuT1dUVNTY\nZv47/XupS9sv/eV3pePkp3M4HFfs/5tuusnX1qRJE9+tzou3XdretGnTWo85H6TfeuutWtc69OrV\ni507d/q+nj9/Phs2bODIkSMAvPjii3Ts2JHCwkLy8/OveItz/vz5vjFdUlJCQkICUPsYcjgc9OvX\nj88++4zvv/++1vPJjePi8e7n5+f72s/Pr8YYP+/iNTybN2+mf//+5ObmsmHDBvLy8ti1axdut9v3\nOBgYGOj72fL392f79u2MHDmSjz76iHvuucd33is93l38s3V+nwEDBrBlyxZuv/12xo8fz9tvv/0T\ne0F+DAWeBhYYGEhOTg7Z2dm8+eabQPXaiw4dOnDu3Dneeecd3w+ZMQZjDM2bNyckJIRVq1b52nfv\n3u0757hx4xgzZswVF+HNmjWLmTNn+p5lVFZWsnjxYqB6/cP5MHT+/FD9g5mdnQ1AcXExBw4coGfP\nniQkJLBw4ULfOqETJ07Qo0cPSktLKSkpAeDtt98mLi6uXvpLarrzzjt599138Xq9HDlyhM2bNxMb\nG3tVIbOuY0aMGMH69evJz89n6NChl20fPHgwFRUVvPbaa762M2fO+MbuyZMnfWvGli5detm6MoCh\nQ4eyYMEC3y+n4uJiysvLSUhIICsryxf8L16PkZaWxr333suoUaNqPadIXeP60m0nT54kKCiIwMBA\nvvrqK/Ly8mo97syZM3z77bckJiby5z//2ff4269fP5YvXw5AdnY2AwcOrLO2AwcO0LZtW9LS0khL\nS6OgoODH/NfkJ1LgaUDnfxkEBQWxfv16Zs+ezZo1a3j66afp06cPd955J2FhYTX2P39MdnY2ixcv\nxuVyERERUeMllcnJyZw4cYLRo0fXet3ExESmTp1KfHw8ERER9O7dm1OnTgEwY8YMXn31VaKjozl2\n7JjvelOmTMHr9eJ0OnnooYdYsmQJAQEBpKWl0aVLF9+C0mXLlhEYGEhWVhZJSUk4nU78/f2ZPHny\nNenDG1VVVRU33XQTI0aMwOl0EhUVxd13383zzz9Pu3btrvgKpktdvF9dxwQEBDB48GBGjRp1xX1W\nr17Npk2b6Nq1K3369GH8+PE899xzQPX4WbJkCS6Xi6KiohpT9+fPl5aWRnh4ONHR0URGRvLb3/4W\nj8fD0KFDuf/++4mJicHtdl/2FgrTp0/H7XYzbtw4zSbeAM6PfeCKY/fSz680Zi9tv+eee6iqqiI8\nPJxZs2bRt2/fWvc9deoUw4YNIyoqigEDBvDiiy8CMG/ePLKysoiKiiI7O7vGYv/a6tu4cSMul4vo\n6GhWrFjBtGnTflxnyE9ztYt/Gr30eVZX0GBWrlxpxo0bZ3UZjV8jGBPp267uuF27dpk+ffrUbzF1\n8Hg8xuVymX/84x8Nds2GdrXfCzt6z6RbXcIVNfTYl2qNeUzUpa7cYt8ZnqcWWF1Bg3jkkUd44okn\n+MMf/mB1KY1fIxgTT/3vjz/mtddeIzk5mdmzZ9d/QbXYt28fP//5z4mPj6dbt24Nck0rXM33wq4+\n4CmrS6hVQ499uaCxjomfwvHfRFT7xloWSF43HOFgLn9liNzAGsGYcLwE5v9ZWoL8l74XF/waB29z\nnT7WyzVxvY6JunKLfWd4RERERP5LgUdERERsz9/qAq4px+XvSSNiNcdLVlcgcrlf03j+VpvItWDv\nwKM1PHKxRhKAtW6kcVDwrOl6XK8h144dA7BuaYmIiIjtKfCIiIiI7SnwiIiIiO0p8IiIiIjt2Tfw\npE+xugJpbBrBmEjvY3UFcp6+FxeMIN3qEqSRseOYsO87LYuIiMgNRe+0LCIiIjc0BR4RERGxPQUe\nERERsT0FHhEREbE9BR4RERGxPQUeERERsT0FHhEREbE9BR4RERGxPQUeERERsT0FHhEREbE9BR4R\nERGxPQUeERERsT0FHhEREbE9BR4RERGxPQUeERERsT0FHhEREbE9BR4REWl0mjVr5vt87dq1hIaG\ncvDgwSvun5GRwdy5c+vl2kuXLiUyMhKn00l0dHS9nVespcAjIiKNjsPhAGDDhg1MmzaN9evX07lz\n5x/c/6dat24dmZmZfPLJJxQWFpKXl0fLli3r5dxiLQUeERFplDZv3sykSZPIyckhJCQEgEWLFhEb\nG4vL5WLkyJGcPXv2suNKSkpITEwkJiaGgQMHUlRUxKlTp+jatStVVVUAnDx5kq5du+LxeGocO2fO\nHObOnUuHDh0AaNq0KWlpaQDExcWxY8cOAI4ePeqrqaKigtTUVN+MUG5uLgAej4cZM2YQGRlJVFQU\n8+fPB6pDXHR0NE6nk4kTJ1JZWVnPPSe1UeAREZFGp6KighEjRvCXv/yFHj16+NoffPBBtm/fzq5d\nuwgLC2Px4sW+bedneSZNmsS8efPIz8/n+eefZ8qUKTRv3py4uDhycnIAWL58OQ8++CBNmjSpcd29\ne/fSu3fvWmtyOBy1ziS98sorNGnShMLCQpYtW0ZKSgrff/89r7/+OgcOHGD37t3s3r2bMWPG+MLR\nihUrKCwspKqqildfffUn95f8MAUeERFpdJo2bUr//v154403arTv2bOHAQMG4HQ6yc7OZt++fTW2\nnzlzhm3btpGUlITb7Wby5Ml88803AKSlpZGVlQXAW2+9RWpqar3UunXrVsaOHQtAaGgod9xxB8XF\nxWzYsIGHH34YP7/qX7VBQUEUFRUREhJC9+7dAUhJSWHz5s31UofUTYFHREQaHT8/P1asWMH27duZ\nM2eOr338+PEsWLCAwsJC0tPTL7ul5fV6CQoKoqCgwPexd+9eAPr160dpaSm5ubl4PB7Cw8Mvu26v\nXr3Iz8+vtSZ/f3+8Xi9QPQN1MWNMrcdc2n7pDNGVjpP6p8AjIiKNUmBgIDk5OWRnZ/Pmm28CcPr0\naTp06MC5c+d45513fAHCGIMxhubNmxMSEsKqVat87bt37/adc9y4cYwZM4YJEybUes1Zs2Yxc+ZM\nysrKAKisrPTdNgsODvaFofPnBxgwYADZ2dkAFBcXc+DAAXr27ElCQgILFy70rRM6ceIEPXr0oLS0\nlJKSEgDefvtt4uLi6qW/pG4KPCIi0uicDzJBQUGsX7+e2bNns2bNGp5++mn69OnDnXfeSVhYWI39\nzx+TnZ3N4sWLcblcREREsGbNGt9+ycnJnDhxgtGjR9d63cTERKZOnUp8fDwRERH07t2bU6dOATBj\nxgxeffVVoqOjOXbsmO96U6ZMwev14nQ6eeihh1iyZAkBAQGkpaXRpUsXnE4nLpeLZcuWERgYSFZW\nFklJSTidTvz9/Zk8efI16UOpyWHqmE9zOByabhMRsbuM+ZAx1eoqGsSqVatYs2YNS5YssbqUxu06\nHRN15RYFHhGRG50jHMy+H97vOvfII4/w17/+lbVr1/oWDcsVXKdjQoFHRESu7Dr95SbX0HU6JurK\nLVrDIyIiIranwCMiIiK2p8AjIiIitudvdQEiItIIOC5/Ez4RO1HgERGR63KBqlxDNgzAuqUlIiIi\ntqfAIyIiIranwCMiIiK2p8AjInKjS59idQXS2NhwTOidlkVERMQW9E7LIiIickNT4BERERHbU+AR\nERER21PgEREREdtT4BERERHbU+ARERER21PgEREREdtT4BERERHbU+ARERER21PgEREREdtT4BER\nERHbU+ARERER21PgEREREdtT4BERERHbU+ARERER21PgEREREdtT4BERERHbU+ARERER21PgERER\nEdtT4BERERHbU+ARERER21PgEREREdtT4BERERHbU+ARERER21PgEREREdtT4BERERHbs23gyc3N\ntbqERkH9cIH6opr6oZr64QL1RTX1wwV27AsFHptTP1ygvqimfqimfrhAfVFN/XCBHfvCtoFHRERE\n5DwFHhEREbE9hzHGXGljXFwcmzZtash6RERERK7KoEGDrng7rs7AIyIiImIHuqUlIiIitqfAIyIi\nIrZnq8BTUVFBnz59cLlchIeHM2vWLKtLspTH48HtdjNs2DCrS7FUcHAwTqcTt9tNbGys1eVY5ttv\nv2XkyJGEhYURHh5OXl6e1SVZoqioCLfb7fto2bIlL7/8stVlWWLOnDn06tWLyMhIkpOT+f77760u\nyTKZmZlERkYSERFBZmam1eU0mAkTJtC+fXsiIyN9bcePHychIYEePXowZMgQvv32WwsrrD+2CjyB\ngYFs3LiRXbt2UVhYyMaNG/n888+tLssymZmZhIeH43A4rC7FUg6Hg9zcXAoKCti+fbvV5Vhm2rRp\n3Hvvvfz973+nsLCQsLAwq0uyRGhoKAUFBRQUFLBjxw5uueUWRowYYXVZDa60tJRFixaxc+dO9uzZ\ng8fjYfny5VaXZYm//e1vvPHGG3z55Zfs3r2bjz76iJKSEqvLahCpqamsX7++Rtuzzz5LQkICxcXF\n3H333Tz77LMWVVe/bBV4AG655RYAKisr8Xg8tG7d2uKKrHHo0CHWrl1LWloaWpfODd8H3333HVu2\nbGHChAkA+Pv707JlS4urst6nn35Kt27d6Ny5s9WlNLgWLVoQEBBAeXk5VVVVlJeXc/vtt1tdliW+\n+uor+vTpQ2BgIE2aNGHQoEG8//77VpfVIAYMGEBQUFCNtg8//JCUlBQAUlJSWL16tRWl1TvbBR6v\n14vL5aJ9+/bcddddhIeHW12SJaZPn87zzz+Pn5/tvsU/msPhID4+npiYGBYtWmR1OZbYv38/bdu2\nJTU1lejoaH7zm99QXl5udVmWW758OcnJyVaXYYnWrVvzu9/9ji5dunDbbbfRqlUr4uPjrS7LEhER\nEWzZsoXjx49TXl5OTk4Ohw4dsrosy5SVldG+fXsA2rdvT1lZmcUV1Q/b/Tb08/Nj165dHDp0iM2b\nN9vy7bF/yEcffUS7du1wu903/MwGwNatWykoKGDdunW88sorbNmyxeqSGlxVVRU7d+5kypQp7Ny5\nk1tvvdU209RXq7KykjVr1pCUlGR1KZYoKSnhpZdeorS0lH//+9+cPn2a7Oxsq8uyRM+ePXnssccY\nMmQIiYmJuN1uPVn8L4fDYZtlEbb9jrZs2ZL77ruP/Px8q0tpcNu2bePDDz8kJCSE0aNH89lnnzFu\n3Diry7JMx44dAWjbti0jRoy4IdfxdOrUiU6dOvGLX/wCgJEjR7Jz506Lq7LWunXr6N27N23btrW6\nFEvk5+fTr18/2rRpg7+/Pw888ADbtm2zuizLTJgwgfz8fDZt2kSrVq0IDQ21uiTLtG/fnm+++QaA\nw4cP065dO4srqh+2CjxHjx71rSY/e/Ysn3zyCW632+KqGt4zzzzDwYMH2b9/P8uXL2fw4MEsXbrU\n6rIsUV5ezqlTpwA4c+YMH3/8cY1XI9woOnToQOfOnSkuLgaq16706tXL4qqstWzZMkaPHm11GZbp\n2bMneXl5nD17FmMMn3766Q27BADgP//5DwAHDhzggw8+uGFvdQLcf//9LFmyBIAlS5YwfPhwiyuq\nH/5WF1CfDh8+TEpKCl6vF6/Xy69//Wvuvvtuq8uynF2mI69GWVmZ7xU4VVVVjBkzhiFDhlhclTXm\nzZvHmDFjqKyspFu3bmRlZVldkmXOnDnDp59+esOu6QKIiopi3LhxxMTE4OfnR3R0NJMmTbK6LMuM\nHDmSY8eOERAQwIIFC2jRooXVJTWI0aNHs2nTJo4ePUrnzp35n//5Hx5//HFGjRrF4sWLCQ4OZsWK\nFVaXWS/0pyVERETE9mx1S0tERESkNgo8IiIiYnsKPCIiImJ7CjwiIiJiewo8IiIiYnsKPCIiImJ7\nCjwi8pMdO3YMt9uN2+2mY8eOdOrUCbfbTfPmzZk6darV5YmI6H14RKR+PfXUUzRv3pxHH33U6lJE\nRHw0wyMi9e7886jc3FyGDRsGQEZGBikpKQwcOJDg4GDef/99ZsyYgdPpJDExkaqqKgB27NhBXFwc\nMTEx3HPPPb6/6SMi8lMo8IhIg9m/fz8bN27kww8/ZOzYsSQkJFBYWMjNN99MTk4O586d45FHHuG9\n994jPz+f1NRUnnzySavLFhEbsNXf0hKRxsvhcJCYmEiTJk2IiIjA6/UydOhQACIjIyktLaW4uJi9\ne/cSHx8PgMfj4bbbbrOybBGxCQUeEWkwTZs2BcDPz4+AgABfu5+fH1VVVRhj6NWrF9u2bbOqRBGx\nKd3SEpEG8X95fURoaChHjhwhLy8PgHPnzrFv375rXZqI3AAUeESk3jkcDt+/tX1+8T4Xfx0QEMCq\nVat47LHHcLlcuN1uvvjii4YrXERsSy9LFxEREdvTDI+IiIjYngKPiIiI2J4Cj4iIiNieAo+IiIjY\nngKPiIiI2J4Cj4iIiNieAo+IiIjYngKPiIiI2N7/B3sNfd6GMSRHAAAAAElFTkSuQmCC\n", + "prompt_number": 17, + "text": [ + "" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# this also works\n", + "annotation % mapping" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "prompt_number": 18, + "text": [ + "" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Cropping and subsetting" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The **crop** method works the same way it does for [timeline](pyannote.core.timeline.ipynb) instances." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "annotation" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "prompt_number": 19, + "text": [ + "" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "segment = Segment(6, 9)\n", + "segment" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAACa9JREFUeJzt3X9MVfUfx/HXuUIzm2I6vKngcG6h/DCOkW5uCSag1Gzq\nqA1/MVj5R6u1fmzm/MMff5hb/0St/jHndHMy56+hZisWXDFiiqBov9gcrFhKqbOp18ILtz/4CrWS\n7/drdN/4uc/Hdgecwx+vvdkZr/s559zjRaPRqAAAABwWsA4AAADwb6PwAAAA51F4AACA8yg8AADA\neRQeAADgPAoPAABwXsJgO/Pz8xUKhWKVBQAA4J7l5eWprq7ub/cNusITCoUUjUbvy9eGDRvMMwyH\nF3NgFsyBOTAL5hAvsxhskYZTWgAAwHkUHgAA4DxnC09+fr51hGGBOQxgFn2YQx/mMIBZ9GEOA1yc\nhReNRu/6LC3P8zTIbgAAgGFjsN7i7AoPAADAHRQeAADgPAoPAABwHoUHAAA4j8IDAACcR+EBAADO\no/AAAADnUXgAAIDzKDwAAMB5FB4AAOA8Cg8AAHAehQcAADiPwgMAAJxH4QEAAM6j8AAAAOdReAAA\ngPMoPAAAwHkUHgAA4DwKDwAAcB6FB4gzGzdaJwCGJ44Nt3nRaDR6152ep0F2A7gPeZ7EYQ38FcfG\n/W+w3sIKDwAAcF6CdQAAsed51gkAILYoPEAcYtke+CveCLiNU1oAAMB5FB4gzmzYYJ0AGJ44NtzG\nXVoAAMAJ3KUFAADiGoUHAAA4j8IDAACcR+EBAADOo/AAAADnUXgAAIDzKDwAAMB5FB4AAOA8Cg8A\nAHAehQcAADiPwgMAAJxH4QEAAM6j8AAAAOdReAAAgPMoPAAAwHkUHgAA4DwKDwAAcB6FBwAAOI/C\nAwAAnOds4amrq7OOMCwwhwHMog9z6MMcBjCLPsxhgIuzoPA4jjkMYBZ9mEMf5jCAWfRhDgNcnIWz\nhQcAAOAOCg8AAHCeF41Go3fbmZ+fr1AoFMs8AAAA9yQvL++up+MGLTwAAAAu4JQWAABwHoUHAAA4\nz6nC8+uvv2rOnDnKyclRRkaG1q1bZx3JVE9Pj3zf1+LFi62jmEpLS9PMmTPl+75mz55tHcfMtWvX\nVFJSohkzZigjI0ONjY3WkUx899138n2//5WUlKT33nvPOpaJt99+W5mZmcrOztby5cv122+/WUcy\nU1lZqezsbGVlZamystI6TsxUVFQoGAwqOzu7f9vVq1dVWFioRx99VEVFRbp27ZphwqHjVOEZOXKk\namtrdebMGbW2tqq2tlYnTpywjmWmsrJSGRkZ8jzPOoopz/NUV1enlpYWnTx50jqOmVdffVVPP/20\nvvnmG7W2tmrGjBnWkUykp6erpaVFLS0tOn36tEaNGqWlS5dax4q5jo4Obdu2Tc3NzTp37px6enpU\nVVVlHcvE+fPn9dFHH+nUqVM6e/asjhw5ogsXLljHiony8nJ98sknf9q2detWFRYWqq2tTQsWLNDW\nrVuN0g0tpwqPJI0aNUqS1N3drZ6eHo0bN844kY3Ozk59/PHHeuGFF8R16Yr7Gfzyyy+qr69XRUWF\nJCkhIUFJSUnGqezV1NRo2rRpSk1NtY4Sc2PGjFFiYqLC4bAikYjC4bAmT55sHcvEt99+qzlz5mjk\nyJEaMWKE8vLydODAAetYMfHkk0/q4Ycf/tO26upqlZWVSZLKysp06NAhi2hDzrnC09vbq5ycHAWD\nQc2fP18ZGRnWkUy89tpreueddxQIOPcn/r95nqeCggLl5uZq27Zt1nFMtLe3Kzk5WeXl5Zo1a5Ze\nfPFFhcNh61jmqqqqtHz5cusYJsaNG6c33nhDU6ZM0aRJkzR27FgVFBRYxzKRlZWl+vp6Xb16VeFw\nWEePHlVnZ6d1LDNdXV0KBoOSpGAwqK6uLuNEQ8O5/4aBQEBnzpxRZ2enjh8/7uTHY/83R44c0YQJ\nE+T7ftyvbEjSF198oZaWFh07dkwffPCB6uvrrSPFXCQSUXNzs1566SU1NzfroYcecmaZ+l51d3fr\n8OHDeu6556yjmLhw4YLeffdddXR06Mcff9SNGze0e/du61gmpk+frrVr16qoqEjFxcXyfZ83i//h\neZ4zl0U4+xdNSkrSM888o6amJusoMdfQ0KDq6mpNnTpVpaWl+vzzz7V69WrrWGYmTpwoSUpOTtbS\npUvj8jqelJQUpaSk6IknnpAklZSUqLm52TiVrWPHjunxxx9XcnKydRQTTU1Nmjt3rsaPH6+EhAQt\nW7ZMDQ0N1rHMVFRUqKmpSaFQSGPHjlV6erp1JDPBYFCXLl2SJF28eFETJkwwTjQ0nCo8ly9f7r+a\n/NatW/rss8/k+75xqtjbsmWLfvjhB7W3t6uqqkpPPfWUdu3aZR3LRDgc1vXr1yVJN2/e1Keffvqn\nuxHixSOPPKLU1FS1tbVJ6rt2JTMz0ziVrT179qi0tNQ6hpnp06ersbFRt27dUjQaVU1NTdxeAiBJ\nP/30kyTp+++/18GDB+P2VKckPfvss9q5c6ckaefOnVqyZIlxoqGRYB1gKF28eFFlZWXq7e1Vb2+v\nVq1apQULFljHMufKcuS96Orq6r8DJxKJaMWKFSoqKjJOZeP999/XihUr1N3drWnTpmnHjh3Wkczc\nvHlTNTU1cXtNlyQ99thjWr16tXJzcxUIBDRr1iytWbPGOpaZkpISXblyRYmJifrwww81ZswY60gx\nUVpaqlAopMuXLys1NVWbN2/WW2+9peeff17bt29XWlqa9u7dax1zSPBoCQAA4DynTmkBAAD8HQoP\nAABwHoUHAAA4j8IDAACcR+EBAADOo/AAAADnUXgA/GNXrlyR7/vyfV8TJ05USkqKfN/X6NGj9fLL\nL1vHAwA+hwfA0Nq0aZNGjx6t119/3ToKAPRjhQfAkLvzPqqurk6LFy+WJG3cuFFlZWWaN2+e0tLS\ndODAAb355puaOXOmiouLFYlEJEmnT59Wfn6+cnNztWjRov5n+gDAP0HhARAz7e3tqq2tVXV1tVau\nXKnCwkK1trbqwQcf1NGjR3X79m298sor2r9/v5qamlReXq7169dbxwbgAKeepQVg+PI8T8XFxRox\nYoSysrLU29urhQsXSpKys7PV0dGhtrY2ffXVVyooKJAk9fT0aNKkSZaxATiCwgMgZh544AFJUiAQ\nUGJiYv/2QCCgSCSiaDSqzMxMNTQ0WEUE4ChOaQGIif/l/oj09HT9/PPPamxslCTdvn1bX3/99b8d\nDUAcoPAAGHKe5/V//bvv//g7f/w5MTFR+/bt09q1a5WTkyPf9/Xll1/GLjgAZ3FbOgAAcB4rPAAA\nwHkUHgAA4DwKDwAAcB6FBwAAOI/CAwAAnEfhAQAAzqPwAAAA51F4AACA834HmeMd7uhy8BwAAAAA\nSUVORK5CYII=\n", + "prompt_number": 20, + "text": [ + "" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "annotation.crop(segment)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAEpBJREFUeJzt3XtQVOf9x/HPAfF+i61SU60YjQTYBRaNVluBKGox0VFq\nzKiJKKP5w4mT3q3TZqCXNM606XhJM52xqTGpLc0YZFBiap0AIVVMkfXS2sTUgUQbo/GSKixegOf3\nBz/XqkhTgzzy8H7NMMrZ49nPfk8mfjznWdYzxhgBAAA4LMJ2AAAAgNuNwgMAAJxH4QEAAM6j8AAA\nAOdReAAAgPMoPAAAwHldWnswPT1dZWVl7ZUFAADglqWlpam0tLTFx1q9wlNWViZjTIf8ys3NtZ7h\nTvhiDsyCOTAHZsEcOsssWrtIwy0tAADgPAoPAABwnrOFJz093XaEOwJzuIpZNGMOzZjDVcyiGXO4\nysVZeMaYm36Wlud5auVhAACAO0ZrvcXZKzwAAABXUHgAAIDzKDwAAMB5FB4AAOA8Cg8AAHAehQcA\nADiPwgMAAJxH4QEAAM6j8AAAAOdReAAAgPMoPAAAwHkUHgAA4DwKDwAAcB6FBwAAOI/CAwAAnEfh\nAQAAzqPwAAAA51F4AACA8yg8AD6V3r17245wg7y8PD377LO2Y3RqTz/9tHw+n5KSkhQIBPT2228r\nJiZGZ86c+dTHKC0t1YwZM1p87H89FnAzXWwHANAxeJ5n9fmNMTfksJ2ps9u9e7eKi4sVDAYVFRWl\nM2fO6OLFi/I8L3y+PivOMdoKV3gA3LIjR44oMzNTY8aMUWpqqt59911JUk1NjSZNmqSkpCRlZGTo\n6NGjkqRFixbpySef1Fe+8hWNGDFCr776qiSptrZWGRkZGj16tBITE1VUVBQ+TmxsrLKzs+X3+3X0\n6FE9/fTTio2N1cSJE8PPBzs++ugjff7zn1dUVJQkacCAARo8eLAkad26deHzeeU81dXVKScnR+PG\njVNKSkr4PP+n06dPa+rUqfL5fFq6dOk1xemXv/yl/H6//H6/1qxZI6n5v5G4uDg9/vjj8vl8mjZt\nmi5cuHC7Xzo6ItOK//IwgE6kd+/eN2ybNGmSee+994wxxlRUVJhJkyYZY4x56KGHzEsvvWSMMea3\nv/2tmTVrljHGmOzsbDN37lxjjDGHDh0yI0eONMYY09DQYM6dO2eMMebjjz8Ob6+urjYRERFmz549\nxhhjKisrjd/vN/X19ebcuXNm5MiR5tlnn71dLxn/RW1trUlOTjajRo0yy5YtM2VlZcYYY2JiYsxz\nzz1njDHm+eefN0uWLDHGGLNy5Urzu9/9zhhjzNmzZ82oUaNMXV2dKSkpMQ899JAxxpjly5ebn/zk\nJ8YYY4qLi43neeb06dPhcx8KhUxtba1JSEgwwWDQVFdXmy5dupj9+/cbY4yZO3du+DnQ+bTWW7il\nBeCW1NbWavfu3Xr44YfD2y5duiRJqqioUGFhoSTp0Ucf1fe+9z1JzbcnZs2aJUmKi4vTiRMnJElN\nTU1auXKlysvLFRERoQ8//FAnT56UJA0bNkxjx46VJJWXlysrK0vdu3dX9+7dNXPmzDa7dYL/Xa9e\nvbR3716Vl5erpKREjzzyiJ555hlJUlZWliQpJSVFBQUFkqQdO3Zo69at+sUvfiFJunjxYvjq3xXl\n5eXasmWLJGn69Om66667ZIzRW2+9paysLPXo0SN8/PLycs2cOVPDhw9XYmKiJGn06NGqqam57a8d\nHQ+FB8AtaWpqUv/+/RUMBlt8/GZFpGvXrjfss2nTJp06dUpVVVWKjIzU8OHDw7clevXqFd7/+rUh\nlB37IiIilJaWprS0NPn9fr344ouSpG7dukmSIiMj1dDQEN6/oKBA99577zXHOH78+DXft3ReWzr3\nV9b3XHmuK89XX1//2V4UnMQaHgC3pG/fvho+fLg2b94sqfkvoAMHDkiSJkyYoPz8fEnNZSY1NbXV\nY507d06DBg1SZGSkSkpK9P7777e4X2pqqgoLC3XhwgWdP39e27ZtY1GrRYcPH9Z7770X/j4YDCom\nJuam+0+bNk1r1669Zv/rpaam6ve//70kafv27Tp79qw8z9PEiRNVWFio+vp61dXVqbCwUBMnTqT0\n4lOj8AD4VEKhkIYOHRr+Wr16tTZt2qQXXnhBycnJ8vl84UWo69at04YNG5SUlKRNmzaFF5hKLb/L\nasGCBaqsrFRiYqJefvllxcXFtbh/IBDQI488oqSkJE2fPj18qwt21NbWatGiRUpISFBSUpLeeecd\n5eXlXbOP53nhc/jUU0/p8uXLSkxMlM/nU25u7g375Obm6s0335TP59OWLVs0bNgwSc3nftGiRRo7\ndqy+/OUva+nSpUpKSgr/+eufE7ieZ1qpx2351kIAd4i856S8J2ynsI85hOXtlvLG205hH3Po+Frr\nLRQeoLPx4iVzyHYK+5hDmLdaMt+wncI+5tDxtdZbuKUFAACcR+EBAADOo/AAAADn8XN4gM7Ii7ed\nAHcYb7XtBMDtReEBOiMW61L6rsNiXUqf67ilBQAAnEfhAQAAzqPwAAAA51F4AACA8yg8QGeTu8x2\ngjsDcwjLHWc7wZ2BObiNj5YAAABO4KMlAABAp0bhAQAAzqPwAAAA51F4AACA8yg8AADAeRQeAADg\nPAoPAABwHoUHAAA4j8IDAACcR+EBAADOo/AAAADnUXgAAIDzKDwAAMB5FB4AAOA8Cg8AAHAehQcA\nADiPwgMAaBORkZEKBALy+/2aO3eu6uvrbUcCwig8AIA20bNnTwWDQR08eFBdu3bVr3/9a9uRgDAK\nDwCgzX31q1/VP//5T4VCIeXk5GjcuHFKSUlRUVGRJOnFF19UVlaWMjMzNWrUKK1YsSL8Z3v37q0f\n/vCHSk5O1vjx43Xy5EmdP39e99xzjxoaGiRJ586d0z333KPGxkYrrw8dD4UHANCmGhoa9Prrrysx\nMVE//elPNXnyZO3Zs0dvvPGGvvvd7yoUCkmS9u/fr1deeUUHDx7UH//4R/3rX/+SJIVCIY0fP177\n9u1Tamqq1q9frz59+ig9PV3FxcWSpPz8fH39619XZGSktdeJjoXCAwBoE/X19QoEArr//vs1bNgw\n5eTkaMeOHVq1apUCgYAeeOABXbx4UR988IE8z9PkyZPVp08fdevWTfHx8Xr//fclSV27dtWDDz4o\nSRo9erRqamokSUuWLNGGDRskNV8hWrx4sZXXiY6pi+0AAAA39OjRQ8Fg8IbtBQUFuvfee6/ZtmfP\nHnXr1i38fWRkZPh2VVRUVHh7REREePuECRNUU1Oj0tJSNTY2Kj4+/na8DDiKKzwAgNtm2rRpWrt2\nbfj7K4XIGHNLx1u4cKEWLFignJycNsmHzoPCAwBoE57n3bDtqaee0uXLl5WYmCifz6fc3Nzwvi3t\nf/1xrt9v/vz5Onv2rObNm9fG6eE6z7RSsz3Pu+UWDgDoGAqUpyzl2Y7xqWzevFlbt27Vxo0b2/zY\nHWkOaFlrvYXCAwCd3GPy9LLu/P/XL1++XH/605/02muvaeTIkW1+/I4yB9xca72FRcsAgA5h3bp1\ntiOgA2MNDwAAcB6FBwAAOI/CAwAAnMcaHgCAHlPLbxEHXEHhAQDw7iRR+lzHLS0AAOA8Cg8AAHAe\nhQcAADiPwgMAndxs5dqOcEdgDm7joyUAAIATWustXOEBAADOo/AAAADnUXgAAIDzKDwAAMB5FB4A\nAOA8Cg8AAHAehQcAADiPwgMAAJxH4QEAAM6j8AAAAOdReAAAgPMoPAAAwHkUHgAA4DwKDwAAcB6F\nBwAAOI/CAwAAnEfhAQAAzqPwAAAA51F4AACA8yg8AADAeRQeAADgPAoPAABwHoUHAAA4j8IDAACc\nR+EBAADOo/AAAADnOVt4SktLbUe4IzCHq5hFM+bQjDlcxSyaMYerXJwFhcdxzOEqZtGMOTRjDlcx\ni2bM4SoXZ+Fs4QEAALiCwgMAAJznGWPMzR5MT09XWVlZe+YBAAC4JWlpaTe9Hddq4QEAAHABt7QA\nAIDzKDwAAMB5ThWeCxcuaNy4cUpOTlZ8fLxWrlxpO5JVjY2NCgQCmjFjhu0oVsXExCgxMVGBQEBj\nx461HceaTz75RHPmzFFcXJzi4+NVUVFhO5IV7777rgKBQPirX79+Wrt2re1YVjzzzDNKSEiQ3+/X\n/PnzdfHiRduRrFmzZo38fr98Pp/WrFljO067ycnJUXR0tPx+f3jbmTNnNGXKFI0aNUpTp07VJ598\nYjFh23Gq8HTv3l0lJSXat2+fDhw4oJKSEr311lu2Y1mzZs0axcfHy/M821Gs8jxPpaWlCgaDevvt\nt23HsebJJ5/U9OnT9Y9//EMHDhxQXFyc7UhWxMbGKhgMKhgMau/everZs6dmz55tO1a7q6mp0fr1\n61VVVaWDBw+qsbFR+fn5tmNZ8be//U2/+c1v9Ne//lX79+/Xtm3bdOTIEdux2sXixYv1+uuvX7Nt\n1apVmjJlig4fPqzJkydr1apVltK1LacKjyT17NlTknTp0iU1NjZqwIABlhPZcezYMb322mtasmSJ\nWJeuTj+Df//73yovL1dOTo4kqUuXLurXr5/lVPbt3LlTI0aM0NChQ21HaXd9+/ZVVFSUQqGQGhoa\nFAqF9MUvftF2LCveeecdjRs3Tt27d1dkZKTS0tJUUFBgO1a7mDhxou66665rthUVFSk7O1uSlJ2d\nrcLCQhvR2pxzhaepqUnJycmKjo7WAw88oPj4eNuRrPjmN7+pn//854qIcO4U/888z1NGRobGjBmj\n9evX245jRXV1tQYOHKjFixcrJSVFS5cuVSgUsh3Luvz8fM2fP992DCsGDBigb3/72/rSl76ku+++\nW/3791dGRobtWFb4fD6Vl5frzJkzCoVCKi4u1rFjx2zHsubEiROKjo6WJEVHR+vEiROWE7UN5/42\njIiI0L59+3Ts2DG9+eabTv547P9m27ZtGjRokAKBQKe/siFJf/nLXxQMBrV9+3b96le/Unl5ue1I\n7a6hoUFVVVVatmyZqqqq1KtXL2cuU9+qS5cuaevWrXr44YdtR7HiyJEjWr16tWpqavThhx+qtrZW\nmzZtsh3Livvuu08rVqzQ1KlTlZmZqUAgwD8W/5/nec4si3D2jPbr108PPvigKisrbUdpd7t27VJR\nUZGGDx+uefPm6Y033tDChQttx7Jm8ODBkqSBAwdq9uzZnXIdz5AhQzRkyBDdf//9kqQ5c+aoqqrK\nciq7tm/frtGjR2vgwIG2o1hRWVmpCRMm6HOf+5y6dOmirKws7dq1y3Ysa3JyclRZWamysjL1799f\nsbGxtiNZEx0drY8++kiSdPz4cQ0aNMhyorbhVOE5depUeDV5fX29/vznPysQCFhO1f5+9rOf6ejR\no6qurlZ+fr4mTZqkl156yXYsK0KhkM6fPy9Jqqur044dO655N0Jn8YUvfEFDhw7V4cOHJTWvXUlI\nSLCcyq4//OEPmjdvnu0Y1tx3332qqKhQfX29jDHauXNnp10CIEknT56UJH3wwQfasmVLp73VKUkz\nZ87Uxo0bJUkbN27UrFmzLCdqG11sB2hLx48fV3Z2tpqamtTU1KTHHntMkydPth3LOlcuR96KEydO\nhN+B09DQoAULFmjq1KmWU9mxbt06LViwQJcuXdKIESO0YcMG25Gsqaur086dOzvtmi5JSkpK0sKF\nCzVmzBhFREQoJSVFjz/+uO1Y1syZM0enT59WVFSUnn/+efXt29d2pHYxb948lZWV6dSpUxo6dKh+\n/OMf6/vf/77mzp2rF154QTExMXrllVdsx2wTfLQEAABwnlO3tAAAAFpC4QEAAM6j8AAAAOdReAAA\ngPMoPAAAwHkUHgAA4DwKD4DP7PTp0woEAgoEAho8eLCGDBmiQCCgPn366IknnrAdDwD4OTwA2taP\nfvQj9enTR9/61rdsRwGAMK7wAGhzV/4dVVpaqhkzZkiS8vLylJ2drdTUVMXExKigoEDf+c53lJiY\nqMzMTDU0NEiS9u7dq/T0dI0ZM0Zf+9rXwp/pAwCfBYUHQLuprq5WSUmJioqK9Oijj2rKlCk6cOCA\nevTooeLiYl2+fFnLly/Xq6++qsrKSi1evFg/+MEPbMcG4ACnPksLwJ3L8zxlZmYqMjJSPp9PTU1N\nmjZtmiTJ7/erpqZGhw8f1t///ndlZGRIkhobG3X33XfbjA3AERQeAO2ma9eukqSIiAhFRUWFt0dE\nRKihoUHGGCUkJGjXrl22IgJwFLe0ALSLT/P+iNjYWH388ceqqKiQJF2+fFmHDh263dEAdAIUHgBt\nzvO88K8t/f4/9/nP76OiorR582atWLFCycnJCgQC2r17d/sFB+As3pYOAACcxxUeAADgPAoPAABw\nHoUHAAA4j8IDAACcR+EBAADOo/AAAADnUXgAAIDzKDwAAMB5/wdZYx7JiauLBgAAAABJRU5ErkJg\ngg==\n", + "prompt_number": 21, + "text": [ + "" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The **subset** method allows to extract annotations based on their labels." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "male_characters = set(['Sheldon', 'Leonard'])\n", + "annotation.subset(male_characters)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\neAAAgPMIHgAA4Lz/B/ocQcOCYV/3AAAAAElFTkSuQmCC\n", + "prompt_number": 22, + "text": [ + "" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# all but male characters\n", + "annotation.subset(male_characters, invert=True)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n/wGhtarxiWmJnQAAAABJRU5ErkJggg==\n", + "prompt_number": 23, + "text": [ + "" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Analyzing annotations" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# timeline made of Penny's segments\n", + "annotation.label_timeline('Penny')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAABjCAYAAACfSNqRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAO5ReAAAgHsUHgAA4B6FBwAAuPcXee4n7MTQ45gAAAAASUVORK5CYII=\n", + "prompt_number": 24, + "text": [ + ", ])>" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# total Penny's speech duration\n", + "print 'Penny spoke during %f seconds' % annotation.label_duration('Penny')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Penny spoke during 4.000000 seconds\n" + ] + } + ], + "prompt_number": 25 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# label chart based on their duration\n", + "annotation.chart()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "prompt_number": 26, + "text": [ + "[('Penny', 4), ('Sheldon', 2), ('Leonard', 1.5)]" + ] + } + ], + "prompt_number": 26 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# who is the biggest speaker?\n", + "annotation.argmax()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "prompt_number": 27, + "text": [ + "'Penny'" + ] + } + ], + "prompt_number": 27 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Other operations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**co_iter** works the same way as for [timeline](pyannote.core.timeline.ipynb) except it iterates over overlapping (segment, track) tuples." + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Need help?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can always try the following... \n", + "Who knows? It might give you the information you are looking for!" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "help(Annotation)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Help on class Annotation in module pyannote.core.annotation:\n", + "\n", + "class Annotation(__builtin__.object)\n", + " | Annotation\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | uri : string, optional\n", + " | uniform resource identifier of annotated document\n", + " | modality : string, optional\n", + " | name of annotated modality\n", + " | \n", + " | Methods defined here:\n", + " | \n", + " | __contains__(self, included)\n", + " | Inclusion\n", + " | \n", + " | Use expression 'segment in annotation' or 'timeline in annotation'\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | included : `Segment` or `Timeline`\n", + " | \n", + " | Returns\n", + " | -------\n", + " | contains : bool\n", + " | True if every segment in `included` exists in annotation\n", + " | False otherwise\n", + " | \n", + " | __delitem__(self, key)\n", + " | \n", + " | __eq__(self, other)\n", + " | \n", + " | __getitem__(self, key)\n", + " | # label = annotation[segment, track]\n", + " | \n", + " | __init__(self, uri=None, modality=None)\n", + " | \n", + " | __len__(self)\n", + " | Number of segments\n", + " | \n", + " | __mod__(self, translation)\n", + " | \n", + " | __ne__(self, other)\n", + " | \n", + " | __nonzero__(self)\n", + " | \n", + " | __rshift__(self, timeline)\n", + " | Tag a timeline\n", + " | \n", + " | Use expression 'tagged = annotation >> timeline'\n", + " | \n", + " | Shortcut for :\n", + " | >>> tagger = DirectTagger()\n", + " | >>> tagged = tagger(annotation, timeline)\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | timeline : :class:`pyannote.base.timeline.Timeline`\n", + " | \n", + " | Returns\n", + " | -------\n", + " | tagged : :class:`pyannote.base.annotation.Annotation`\n", + " | Tagged timeline - one track per intersecting label.\n", + " | \n", + " | __setitem__(self, key, label)\n", + " | # annotation[segment, track] = label\n", + " | \n", + " | __str__(self)\n", + " | Human-friendly representation\n", + " | \n", + " | anonymize_labels(self)\n", + " | Anonmyize labels\n", + " | \n", + " | Create a new annotation where labels are anonymized, ie. each label\n", + " | is replaced by a unique `Unknown` instance.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | anonymized : :class:`Annotation`\n", + " | New annotation with anonymized labels.\n", + " | \n", + " | anonymize_tracks(self)\n", + " | Anonymize tracks\n", + " | \n", + " | Create a new annotation where each track is anonymized, i.e. the label\n", + " | of each track is set to a unique `Unknown` instance\n", + " | \n", + " | Returns\n", + " | -------\n", + " | anonymized : `Annotation`\n", + " | Anonymized annotation\n", + " | \n", + " | argmax(self, segment=None, known_first=False)\n", + " | Get most frequent label\n", + " | \n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | segment : Segment, optional\n", + " | Section of annotation where to look for the most frequent label.\n", + " | Defaults to whole annotation extent.\n", + " | known_first: bool, optional\n", + " | If True, artificially reduces the duration of intersection of\n", + " | `Unknown` labels so that 'known' labels are returned first.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | label : any existing label or None\n", + " | Label with longest intersection\n", + " | \n", + " | Examples\n", + " | --------\n", + " | \n", + " | >>> annotation = Annotation(modality='speaker')\n", + " | >>> annotation[Segment(0, 10), 'speaker1'] = 'Alice'\n", + " | >>> annotation[Segment(8, 20), 'speaker1'] = 'Bob'\n", + " | >>> print \"%s is such a talker!\" % annotation.argmax()\n", + " | Bob is such a talker!\n", + " | >>> segment = Segment(22, 23)\n", + " | >>> if not annotation.argmax(segment):\n", + " | ... print \"No label intersecting %s\" % segment\n", + " | No label intersection [22 --> 23]\n", + " | \n", + " | chart(self, percent=False)\n", + " | Label chart based on their duration\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | percent : bool, optional\n", + " | Return total duration percentage (rather than raw duration)\n", + " | \n", + " | Returns\n", + " | -------\n", + " | chart : (label, duration) iterable\n", + " | Sorted from longest to shortest.\n", + " | \n", + " | co_iter(self, other)\n", + " | Parameters\n", + " | ----------\n", + " | other : Annotation\n", + " | \n", + " | Generates\n", + " | ---------\n", + " | (segment, track), (other_segment, other_track)\n", + " | \n", + " | copy(self)\n", + " | \n", + " | crop(self, other, mode='intersection')\n", + " | Crop annotation\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | other : `Segment` or `Timeline`\n", + " | \n", + " | mode : {'strict', 'loose', 'intersection'}\n", + " | In 'strict' mode, only segments fully included in focus coverage\n", + " | are kept. In 'loose' mode, any intersecting segment is kept\n", + " | unchanged. In 'intersection' mode, only intersecting segments are\n", + " | kept and replaced by their actual intersection with the focus.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | cropped : Annotation\n", + " | \n", + " | Remarks\n", + " | -------\n", + " | In 'intersection' mode, the best is done to keep the track names\n", + " | unchanged. However, in some cases where two original segments are\n", + " | cropped into the same resulting segments, conflicting track names are\n", + " | modified to make sure no track is lost.\n", + " | \n", + " | empty(self)\n", + " | \n", + " | get_labels(self, segment, unknown=True, unique=True)\n", + " | Local set of labels\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | segment : Segment\n", + " | Segments to get label from.\n", + " | unknown : bool, optional\n", + " | When False, do not return Unknown instances\n", + " | When True, return any label (even Unknown instances)\n", + " | unique : bool, optional\n", + " | When False, return the list of (possibly repeated) labels.\n", + " | When True (default), return the set of labels\n", + " | Returns\n", + " | -------\n", + " | labels : set\n", + " | Set of labels for `segment` if it exists, empty set otherwise.\n", + " | \n", + " | Examples\n", + " | --------\n", + " | \n", + " | >>> annotation = Annotation()\n", + " | >>> segment = Segment(0, 2)\n", + " | >>> annotation[segment, 'speaker1'] = 'Bernard'\n", + " | >>> annotation[segment, 'speaker2'] = 'John'\n", + " | >>> print sorted(annotation.get_labels(segment))\n", + " | set(['Bernard', 'John'])\n", + " | >>> print annotation.get_labels(Segment(1, 2))\n", + " | set([])\n", + " | \n", + " | get_timeline(self)\n", + " | Get timeline made of annotated segments\n", + " | \n", + " | get_track_by_name(self, track)\n", + " | Get all tracks with given name\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | track : any valid track name\n", + " | Requested name track\n", + " | \n", + " | Returns\n", + " | -------\n", + " | tracks : list\n", + " | List of (segment, track) tuples\n", + " | \n", + " | get_tracks(self, segment)\n", + " | Set of tracks for query segment\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | segment : `Segment`\n", + " | Query segment\n", + " | \n", + " | Returns\n", + " | -------\n", + " | tracks : set\n", + " | Set of tracks for query segment\n", + " | \n", + " | has_track(self, segment, track)\n", + " | Check whether a given track exists\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | segment : `Segment`\n", + " | Query segment\n", + " | track :\n", + " | Query track\n", + " | \n", + " | Returns\n", + " | -------\n", + " | exists : bool\n", + " | True if track exists for segment\n", + " | \n", + " | itersegments(self)\n", + " | Segment iterator\n", + " | \n", + " | itertracks(self, label=False)\n", + " | \n", + " | label_coverage(self, label)\n", + " | Parameters\n", + " | ----------\n", + " | label :\n", + " | \n", + " | Returns\n", + " | -------\n", + " | \n", + " | label_duration(self, label)\n", + " | \n", + " | label_timeline(self, label)\n", + " | Get timeline for a given label\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | label :\n", + " | \n", + " | Returns\n", + " | -------\n", + " | timeline : :class:`Timeline`\n", + " | Timeline made of all segments annotated with `label`\n", + " | \n", + " | labels(self, unknown=True)\n", + " | List of labels\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | unknown : bool, optional\n", + " | When False, do not return Unknown instances\n", + " | When True, return any label (even Unknown instances)\n", + " | \n", + " | Returns\n", + " | -------\n", + " | labels : list\n", + " | Sorted list of labels\n", + " | \n", + " | Remarks\n", + " | -------\n", + " | Labels are sorted based on their string representation.\n", + " | \n", + " | new_track(self, segment, candidate=None, prefix=None)\n", + " | Track name generator\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | segment : Segment\n", + " | prefix : str, optional\n", + " | candidate : any valid track name\n", + " | \n", + " | Returns\n", + " | -------\n", + " | track : str\n", + " | New track name\n", + " | \n", + " | retrack(self)\n", + " | \n", + " | smooth(self)\n", + " | Smooth annotation\n", + " | \n", + " | Create new annotation where contiguous tracks with same label are\n", + " | merged into one longer track.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | annotation : Annotation\n", + " | New annotation where contiguous tracks with same label are merged\n", + " | into one long track.\n", + " | \n", + " | Remarks\n", + " | -------\n", + " | Track names are lost in the process.\n", + " | \n", + " | subset(self, labels, invert=False)\n", + " | Annotation subset\n", + " | \n", + " | Extract annotation subset based on labels\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | labels : set\n", + " | Set of labels\n", + " | invert : bool, optional\n", + " | If invert is True, extract all but requested `labels`\n", + " | \n", + " | Returns\n", + " | -------\n", + " | subset : `Annotation`\n", + " | Annotation subset.\n", + " | \n", + " | to_json(self)\n", + " | \n", + " | translate(self, translation)\n", + " | Translate labels\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | translation: dict\n", + " | Label translation.\n", + " | Labels with no associated translation are kept unchanged.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | translated : :class:`Annotation`\n", + " | New annotation with translated labels.\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Class methods defined here:\n", + " | \n", + " | from_df(cls, df, uri=None, modality=None, aggfunc=) from __builtin__.type\n", + " | Parameters\n", + " | ----------\n", + " | df : DataFrame\n", + " | Must contain the following columns: 'segment', 'track' and 'label'\n", + " | uri : str, optional\n", + " | Resource identifier\n", + " | modality : str, optional\n", + " | Modality\n", + " | aggfunc : func\n", + " | Value aggregation function in case of duplicate (segment, track,\n", + " | label) tuples\n", + " | \n", + " | Returns\n", + " | -------\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors defined here:\n", + " | \n", + " | __dict__\n", + " | dictionary for instance variables (if defined)\n", + " | \n", + " | __weakref__\n", + " | list of weak references to the object (if defined)\n", + " | \n", + " | uri\n", + " | Resource identifier\n", + "\n" + ] + } + ], + "prompt_number": 28 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file From bf6a4bbae4facd2545a4dd68b52ca34be22956c2 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Fri, 2 May 2014 22:22:43 +0200 Subject: [PATCH 008/458] doc: preparing the future --- doc/index.ipynb | 32 ++++++++++++++++++++------------ 1 file changed, 20 insertions(+), 12 deletions(-) diff --git a/doc/index.ipynb b/doc/index.ipynb index f1da9e6a..df2ab6ca 100644 --- a/doc/index.ipynb +++ b/doc/index.ipynb @@ -1,7 +1,7 @@ { "metadata": { "name": "", - "signature": "sha256:9358a0cd9feb4f3aeb0db4a6cdb9aac9a0f5b7009558534b31a2866ba57a2b4b" + "signature": "sha256:618c1abfc4fb6815952c57d406154c1d311c2997f25edbdf8ab44d8af47cb3ec" }, "nbformat": 3, "nbformat_minor": 0, @@ -28,7 +28,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "pyannote.core package can be installed the easy way:\n", + "`pyannote.core` package can be installed the easy way:\n", "```bash\n", "$ pip install pyannote.core\n", "```" @@ -63,6 +63,20 @@ "[Annotation](pyannote.core.annotation.ipynb) (`pyannote.core.annotation`)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[Feature](pyannote.core.feature.ipynb) (`pyannote.core.feature`) -- documentation coming soon" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[Scores](pyannote.core.scores.ipynb) (`pyannote.core.scores`) -- documentation coming soon" + ] + }, { "cell_type": "heading", "level": 2, @@ -75,17 +89,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "`pyannote.core` is on [Github](https://github.com/hbredin/pyannote-core]. \n", - "Please fork and pull requests :)" + "`pyannote.core` is on [Github](https://github.com/hbredin/pyannote-core). \n", + " \n", + " \n", + " Fork and pull requests are very welcome!" ] - }, - { - "cell_type": "code", - "collapsed": false, - "input": [], - "language": "python", - "metadata": {}, - "outputs": [] } ], "metadata": {} From a7d0f95e2c0bc744fac6f3bf468f0559b1e978be Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Fri, 2 May 2014 22:24:10 +0200 Subject: [PATCH 009/458] doc: preparing the future --- doc/index.ipynb | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/doc/index.ipynb b/doc/index.ipynb index df2ab6ca..c0cc5ea7 100644 --- a/doc/index.ipynb +++ b/doc/index.ipynb @@ -1,7 +1,7 @@ { "metadata": { "name": "", - "signature": "sha256:618c1abfc4fb6815952c57d406154c1d311c2997f25edbdf8ab44d8af47cb3ec" + "signature": "sha256:6e4beb6041e0424cc9556e8e9d4565350294c0d2829f1cba8152635f01966064" }, "nbformat": 3, "nbformat_minor": 0, @@ -63,6 +63,13 @@ "[Annotation](pyannote.core.annotation.ipynb) (`pyannote.core.annotation`)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[Transcription](pyannote.core.transcription) (`pyannote.core.transcription`) -- coming soon" + ] + }, { "cell_type": "markdown", "metadata": {}, From e474a76e81b8f19de828ca9f9b3e42f723559a37 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Fri, 2 May 2014 22:26:06 +0200 Subject: [PATCH 010/458] doc: CHANGELOG --- CHANGELOG.md | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 CHANGELOG.md diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 00000000..0f400e65 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,4 @@ +### Version 0.0.1 (2014-05-02) + + - first public version + From 60e63057588cf7baebb4eba889378bbae606a174 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Sun, 4 May 2014 12:11:19 +0200 Subject: [PATCH 011/458] feat: anchored and drifting time generator --- pyannote/core/time.py | 242 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 242 insertions(+) create mode 100644 pyannote/core/time.py diff --git a/pyannote/core/time.py b/pyannote/core/time.py new file mode 100644 index 00000000..b9e7ac21 --- /dev/null +++ b/pyannote/core/time.py @@ -0,0 +1,242 @@ +#!/usr/bin/env python +# encoding: utf-8 + +# The MIT License (MIT) + +# Copyright (c) 2014 CNRS (Hervé BREDIN - http://herve.niderb.fr) + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +""" +Provides three objects: T, TStart and TEnd + +TStart and TEnd are used to represent start ($) and end (^) time of a medium. + +T provides facilities to generate anchored or drifting times. +A time is `anchored` if its temporal position is known precisely (e.g. t=3s). +A time is `drifting` if its exact position is not yet known. + +To generate an `anchored` time, simply use: +>>> t = T(3.) + +To generate a `drifting` time, simply use: +>>> t = T() + +Each subsequent call to T() increments an internal string providing a unique +identifier to each new `drifting` time. +>>> print T() +A +>>> print T() +B + +One can reset the internal states if needed. +>>> T.reset() +>>> print T() +A + +Also, if you want to refer to a specific `drifting` time, simple use: +>>> t = T('B') +""" + +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +import itertools + +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +class _TAnchored(float): + + def __new__(cls, t): + return float.__new__(cls, t) + + @property + def anchored(self): + return True + + @property + def drifting(self): + return False + + def __str__(self): + + if float(self) == float('infinity'): + return '^' + + if float(self) == -float('infinity'): + return '$' + + return super(_TAnchored, self).__str__() + + def __repr__(self): + return '' % str(self) + + def for_json(self): + """ + Usage + ----- + >>> import simplejson as json + >>> t = T() + >>> json.dumps(t, for_json=True) + """ + + t = float(self) + + if t == float('infinity'): + return {'__T__': '^'} + + if t == -float('infinity'): + return {'__T__': '$'} + + return {'__T__': t} + + + +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + +def _t_iter(): + """Label generator + + Usage + ----- + t = _t_iter() + next(t) -> 'A' # start with 1-letter labels + ... # from A to Z + next(t) -> 'Z' + next(t) -> 'AA' # then 2-letters labels + next(t) -> 'AB' # from AA to ZZ + ... + next(t) -> 'ZY' + next(t) -> 'ZZ' + next(t) -> 'AAA' # then 3-letters labels + ... # (you get the idea) + """ + + # label length + r = 1 + + # infinite loop + while True: + + # generate labels with current length + for c in itertools.product(ALPHABET, repeat=r): + yield "".join(c) + + # increment label length when all possibilities are exhausted + r = r + 1 + + +class _TDrifting(str): + + __t_iter = _t_iter() + + def __new__(cls, t=None): + if t is None: + t = next(cls.__t_iter) + return str.__new__(cls, t) + + + @classmethod + def _reset(cls): + """Reset label generator""" + cls.__t_iter = _t_iter() + + @property + def anchored(self): + return False + + @property + def drifting(self): + return True + + def __repr__(self): + return '' % str(self) + + def for_json(self): + """ + Usage + ----- + >>> import simplejson as json + >>> t = T() + >>> json.dumps(t, for_json=True) + """ + return {'__T__': str(self)} + +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +class _T(object): + """ + Facility to generate `anchored` or `drifting` times. + A time is `anchored` if its temporal position is known precisely (e.g. t=3s). + A time is `drifting` if its exact position is not yet known. + + To generate an `anchored` time, simply use: + >>> t = T(3.) + + To generate a `drifting` time, simply use: + >>> t = T() + + Each subsequent call to T() increments an internal string providing a unique + identifier to each new `drifting` time. + >>> print T() + A + >>> print T() + B + + One can reset the internal states if needed. + >>> T.reset() + >>> print T() + A + + Also, if you want to refer to a specific `drifting` time, simple use: + >>> t = T('B') + """ + + def __call__(self, t=None): + if t is None or isinstance(t, str): + return _TDrifting(t) + else: + return _TAnchored(float(t)) + + def reset(self): + """Reset drifting time string generator""" + _TDrifting._reset() + + def from_json(self, data): + """Get time from JSON data""" + + t = data['__T__'] + + if t == '$': + t = -float('infinity') + + if t == '^': + t = float('infinity') + + return self.__call__(t) + +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +__all__ = ['T', 'TStart', 'TEnd'] + +T = _T() + +TStart = _TAnchored(-float('infinity')) # == T(-float('infinity')) +TEnd = _TAnchored(float('infinity')) # == T(+float('infinity')) From 50ea851a8f54beae0af979e767bb433a45c4827b Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Sun, 4 May 2014 19:50:56 +0200 Subject: [PATCH 012/458] feat: JSON input/output --- pyannote/core/annotation.py | 28 ++++++++++++-- pyannote/core/json.py | 74 +++++++++++++++++++++++++++++++++++++ pyannote/core/segment.py | 13 ++++++- pyannote/core/time.py | 13 ++++--- pyannote/core/timeline.py | 18 +++++++-- setup.py | 1 + 6 files changed, 133 insertions(+), 14 deletions(-) create mode 100644 pyannote/core/json.py diff --git a/pyannote/core/annotation.py b/pyannote/core/annotation.py index 380a493b..788554a9 100755 --- a/pyannote/core/annotation.py +++ b/pyannote/core/annotation.py @@ -23,6 +23,8 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +from __future__ import unicode_literals + import itertools import operator import warnings @@ -34,6 +36,7 @@ from banyan import SortedDict from interval_tree import TimelineUpdator from segment import Segment from timeline import Timeline +from json import PYANNOTE_JSON_ANNOTATION # ignore Banyan warning warnings.filterwarnings( @@ -850,10 +853,27 @@ class Annotation(object): for t, T in itertools.product(tracks, other_tracks): yield (s, t), (S, T) - def to_json(self): - annotation = [{PYANNOTE_SEGMENT: s.to_json(), PYANNOTE_TRACK: t, PYANNOTE_LABEL: l} - for s, t, l in self.itertracks(label=True)] - return {PYANNOTE_URI: self.uri, PYANNOTE_MODALITY: self.modality, 'tracks': annotation} + def for_json(self): + data = { + PYANNOTE_JSON_ANNOTATION: [ + [s.for_json(), t, l] for s, t, l in self.itertracks(label=True) + ], + } + if self.uri: + data[PYANNOTE_URI] = self.uri + if self.modality: + data[PYANNOTE_MODALITY] = self.modality + return data + + @classmethod + def from_json(cls, data): + uri = data.get(PYANNOTE_URI, None) + modality = data.get(PYANNOTE_MODALITY, None) + annotation = cls(uri=uri, modality=modality) + for s, track, label in data[PYANNOTE_JSON_ANNOTATION]: + segment = Segment.from_json(s) + annotation[segment, track] = label + return annotation def _repr_png_(self): from pyannote.core.notebook import repr_annotation diff --git a/pyannote/core/json.py b/pyannote/core/json.py new file mode 100644 index 00000000..01a1db01 --- /dev/null +++ b/pyannote/core/json.py @@ -0,0 +1,74 @@ +#!/usr/bin/env python +# encoding: utf-8 + +# The MIT License (MIT) + +# Copyright (c) 2014 CNRS (Hervé BREDIN - http://herve.niderb.fr) + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from __future__ import unicode_literals + +import simplejson as json + +PYANNOTE_JSON_TIME = 'T' +PYANNOTE_JSON_SEGMENT = 'S' +PYANNOTE_JSON_TIMELINE = 'L' +PYANNOTE_JSON_ANNOTATION = 'A' + + +def object_hook(d): + """ + Usage + ----- + >>> import simplejson as json + >>> with open('file.json', 'r') as f: + ... json.load(f, object_hook=object_hook) + """ + + from time import T + from segment import Segment + from timeline import Timeline + from annotation import Annotation + + if PYANNOTE_JSON_TIME in d: + return T.from_json(d) + + if PYANNOTE_JSON_SEGMENT in d: + return Segment.from_json(d) + + if PYANNOTE_JSON_TIMELINE in d: + return Timeline.from_json(d) + + if PYANNOTE_JSON_ANNOTATION in d: + return Annotation.from_json(d) + + return d + +def load(path): + with open(path, 'r') as f: + data = json.load(f, encoding='utf-8', object_hook=object_hook) + return data + +def dump(data, path): + # TODO: add pyannote.core version + with open(path, 'w') as f: + json.dump(data, f, encoding='utf-8', for_json=True) + + diff --git a/pyannote/core/segment.py b/pyannote/core/segment.py index 2ec6ac6b..f99fe9a6 100755 --- a/pyannote/core/segment.py +++ b/pyannote/core/segment.py @@ -23,10 +23,14 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +from __future__ import unicode_literals + from collections import namedtuple import numpy as np +from json import PYANNOTE_JSON_SEGMENT + SEGMENT_PRECISION = 1e-6 @@ -247,8 +251,13 @@ class Segment(namedtuple('Segment', ['start', 'end'])): def __repr__(self): return '' % (self.start, self.end) - def to_json(self): - return {'start': self.start, 'end': self.end} + def for_json(self): + return {PYANNOTE_JSON_SEGMENT: [self.start, self.end]} + + @classmethod + def from_json(cls, data): + start, end = data[PYANNOTE_JSON_SEGMENT] + return cls(start=start, end=end) def _repr_png_(self): from pyannote.core.notebook import repr_segment diff --git a/pyannote/core/time.py b/pyannote/core/time.py index b9e7ac21..b0a75bd6 100644 --- a/pyannote/core/time.py +++ b/pyannote/core/time.py @@ -56,8 +56,11 @@ Also, if you want to refer to a specific `drifting` time, simple use: # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +from __future__ import unicode_literals import itertools +from json import PYANNOTE_JSON_TIME + # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class _TAnchored(float): @@ -98,12 +101,12 @@ class _TAnchored(float): t = float(self) if t == float('infinity'): - return {'__T__': '^'} + return {PYANNOTE_JSON_TIME: '^'} if t == -float('infinity'): - return {'__T__': '$'} + return {PYANNOTE_JSON_TIME: '$'} - return {'__T__': t} + return {PYANNOTE_JSON_TIME: t} @@ -177,7 +180,7 @@ class _TDrifting(str): >>> t = T() >>> json.dumps(t, for_json=True) """ - return {'__T__': str(self)} + return {PYANNOTE_JSON_TIME: str(self)} # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -222,7 +225,7 @@ class _T(object): def from_json(self, data): """Get time from JSON data""" - t = data['__T__'] + t = data[PYANNOTE_JSON_TIME] if t == '$': t = -float('infinity') diff --git a/pyannote/core/timeline.py b/pyannote/core/timeline.py index d0c0344a..f0343b18 100755 --- a/pyannote/core/timeline.py +++ b/pyannote/core/timeline.py @@ -23,12 +23,15 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +from __future__ import unicode_literals + import warnings +from . import PYANNOTE_URI from banyan import SortedSet from interval_tree import TimelineUpdator from segment import Segment - +from json import PYANNOTE_JSON_TIMELINE # ignore Banyan warning warnings.filterwarnings( @@ -571,8 +574,17 @@ class Timeline(object): return timeline - def to_json(self): - return [s.to_json() for s in self] + def for_json(self): + data = {PYANNOTE_JSON_TIMELINE: [s.for_json() for s in self]} + if self.uri: + data[PYANNOTE_URI] = self.uri + return data + + @classmethod + def from_json(cls, data): + segments = [Segment.from_json(s) for s in data[PYANNOTE_JSON_TIMELINE]] + uri = data.get(PYANNOTE_URI, None) + return cls(segments=segments, uri=uri) def _repr_png_(self): from pyannote.core.notebook import repr_timeline diff --git a/setup.py b/setup.py index 50cce78d..6dd6433f 100755 --- a/setup.py +++ b/setup.py @@ -40,6 +40,7 @@ setup( 'banyan >=0.1.5', 'numpy >=1.7.1', 'pandas >=0.13.1', + 'simplejson >= 3.4.1', ], # versioneer From e4d1d539579c197202217ffea7de366435fdb674 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Sun, 4 May 2014 19:53:54 +0200 Subject: [PATCH 013/458] chore: import unicode_literals --- pyannote/core/__init__.py | 2 ++ pyannote/core/feature.py | 2 ++ pyannote/core/interval_tree.py | 2 ++ pyannote/core/mapping.py | 2 ++ pyannote/core/matrix.py | 2 ++ pyannote/core/notebook.py | 2 ++ pyannote/core/scores.py | 2 ++ setup.py | 9 ++++++++- 8 files changed, 22 insertions(+), 1 deletion(-) diff --git a/pyannote/core/__init__.py b/pyannote/core/__init__.py index 63b71c5a..19714007 100644 --- a/pyannote/core/__init__.py +++ b/pyannote/core/__init__.py @@ -23,6 +23,8 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +from __future__ import unicode_literals + from ._version import get_versions __version__ = get_versions()['version'] del get_versions diff --git a/pyannote/core/feature.py b/pyannote/core/feature.py index c79b16ef..139486b7 100755 --- a/pyannote/core/feature.py +++ b/pyannote/core/feature.py @@ -29,6 +29,8 @@ Features. """ +from __future__ import unicode_literals + import numpy as np from segment import Segment, SlidingWindow from timeline import Timeline diff --git a/pyannote/core/interval_tree.py b/pyannote/core/interval_tree.py index 9e1bf6c8..e725835d 100644 --- a/pyannote/core/interval_tree.py +++ b/pyannote/core/interval_tree.py @@ -23,6 +23,8 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +from __future__ import unicode_literals + # ===================================================================== # Helper functions # ===================================================================== diff --git a/pyannote/core/mapping.py b/pyannote/core/mapping.py index ada92df5..feb6df2c 100755 --- a/pyannote/core/mapping.py +++ b/pyannote/core/mapping.py @@ -23,6 +23,8 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +from __future__ import unicode_literals + class NoMatch(object): """ Parameters diff --git a/pyannote/core/matrix.py b/pyannote/core/matrix.py index 6f2a21ae..63bc3fd6 100755 --- a/pyannote/core/matrix.py +++ b/pyannote/core/matrix.py @@ -23,6 +23,8 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +from __future__ import unicode_literals + import numpy as np import pandas from segment import SEGMENT_PRECISION diff --git a/pyannote/core/notebook.py b/pyannote/core/notebook.py index a7d90145..8e7a915a 100644 --- a/pyannote/core/notebook.py +++ b/pyannote/core/notebook.py @@ -23,6 +23,8 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +from __future__ import unicode_literals + from IPython.core.pylabtools import print_figure import matplotlib.pyplot as plt from matplotlib.cm import get_cmap diff --git a/pyannote/core/scores.py b/pyannote/core/scores.py index b07291dd..e109deb6 100644 --- a/pyannote/core/scores.py +++ b/pyannote/core/scores.py @@ -23,6 +23,8 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +from __future__ import unicode_literals + import numpy as np from pandas import MultiIndex, DataFrame, pivot_table diff --git a/setup.py b/setup.py index 6dd6433f..d503c851 100755 --- a/setup.py +++ b/setup.py @@ -40,9 +40,16 @@ setup( 'banyan >=0.1.5', 'numpy >=1.7.1', 'pandas >=0.13.1', + 'networkx >= 1.8.1', 'simplejson >= 3.4.1', ], - + extras_require = { + 'notebook': [ + 'matplotlib >= 1.3.1', + 'pygraphviz >= 1.2', + 'ipython >= 2.0.0', + ], + }, # versioneer version=versioneer.get_version(), cmdclass=versioneer.get_cmdclass(), From a5615f0459d0231a481f88a25e1bfcf357e4f9bd Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Sun, 4 May 2014 20:04:09 +0200 Subject: [PATCH 014/458] chore(notebook): code cleaning --- pyannote/core/notebook.py | 269 ++++++++++++++++++++------------------ 1 file changed, 145 insertions(+), 124 deletions(-) diff --git a/pyannote/core/notebook.py b/pyannote/core/notebook.py index 8e7a915a..c41441dc 100644 --- a/pyannote/core/notebook.py +++ b/pyannote/core/notebook.py @@ -38,7 +38,7 @@ from segment import Segment # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class Notebook: - pass + pass _notebook = Notebook() _notebook.extent = None @@ -47,184 +47,205 @@ _notebook.width = _DEFAULT_NOTEBOOK_WIDTH def set_notebook_crop(segment=None, margin=0.1): - if segment is None: - _notebook.extent = None - else: - assert isinstance(segment, Segment) - assert segment - duration = segment.duration - _notebook.extent = Segment( - segment.start-margin*duration, - segment.end+margin*duration - ) + if segment is None: + _notebook.extent = None + else: + assert isinstance(segment, Segment) + assert segment + duration = segment.duration + _notebook.extent = Segment( + segment.start-margin*duration, + segment.end+margin*duration + ) def set_notebook_width(inches=None): - if inches is None: - _notebook.width = _DEFAULT_NOTEBOOK_WIDTH - else: - _notebook.width = inches + if inches is None: + _notebook.width = _DEFAULT_NOTEBOOK_WIDTH + else: + _notebook.width = inches # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def _setup(): - fig, ax = plt.subplots() - ax.set_xlim(_notebook.extent) - ax.set_xlabel('Time') - ax.set_ylim((0, 1)) - ax.axes.get_yaxis().set_visible(False) - return fig, ax + """Prepare figure""" + fig, ax = plt.subplots() + ax.set_xlim(_notebook.extent) + ax.set_xlabel('Time') + ax.set_ylim((0, 1)) + ax.axes.get_yaxis().set_visible(False) + return fig, ax def _render(fig): - data = print_figure(fig, 'png') - plt.close(fig) - return data + """Render figure as png and return raw image data""" + # render figure as png + data = print_figure(fig, 'png') + # prevent IPython notebook from displaying the figure + plt.close(fig) + # return raw image data + return data def _draw_segment(ax, segment, y, color, label=None): - if segment: - ax.hlines(y, segment.start, segment.end, color, lw=1) - ax.vlines(segment.start, y+0.05, y-0.05, color, lw=1) - ax.vlines(segment.end, y+0.05, y-0.05, color, lw=1) - if label: - text = ax.text(segment.middle, y+0.05, codecs.encode(unicode(label), 'ascii', 'replace'), - horizontalalignment='center', fontsize=10) - # text.draw() - # [[x0, y0], [x1, y1]] = text.get_window_extent().get_points() + + # do nothing if segment is empty + if not segment: + return + + # draw segment + ax.hlines(y, segment.start, segment.end, color, lw=1) + ax.vlines(segment.start, y+0.05, y-0.05, color, lw=1) + ax.vlines(segment.end, y+0.05, y-0.05, color, lw=1) + + if label is None: + return + + # draw label + text = ax.text( + segment.middle, + y+0.05, + codecs.encode(unicode(label), 'ascii', 'replace'), + horizontalalignment='center', + fontsize=10 + ) # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def repr_segment(segment): - - # remember current figure size - figsize = plt.rcParams['figure.figsize'] - # and update it for segment display - plt.rcParams['figure.figsize'] = (_notebook.width, 1) + """Get `png` data for `segment`""" + + # remember current figure size + figsize = plt.rcParams['figure.figsize'] + # and update it for segment display + plt.rcParams['figure.figsize'] = (_notebook.width, 1) - if not _notebook.extent: - set_notebook_crop(segment=segment) + if not _notebook.extent: + set_notebook_crop(segment=segment) - fig, ax = _setup() - - y = 0.5 - color = 'b' - _draw_segment(ax, segment, y, color) + fig, ax = _setup() + + # segments are vertically centered and blue + y = 0.5 + color = 'b' + _draw_segment(ax, segment, y, color) - data = _render(fig) + data = _render(fig) - # go back to previous figure size - plt.rcParams['figure.figsize'] = figsize + # go back to previous figure size + plt.rcParams['figure.figsize'] = figsize - return data + return data # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def _y(segments): - """ + """ - Parameters - ---------- - segments : iterator - `Segment` iterator (sorted) + Parameters + ---------- + segments : iterator + `Segment` iterator (sorted) - Returns - ------- - y : np.array - y coordinates of each segment + Returns + ------- + y : np.array + y coordinates of each segment - """ + """ - # up_to stores the largest end time - # displayed in each line (at the current iteration) - # (at the beginning, there is only one empty line) - up_to = [-np.inf] + # up_to stores the largest end time + # displayed in each line (at the current iteration) + # (at the beginning, there is only one empty line) + up_to = [-np.inf] - # y[k] indicates on which line to display kth segment - y = [] + # y[k] indicates on which line to display kth segment + y = [] - for segment in segments: - # so far, we do not know which line to use - found = False - # try each line until we find one that is ok - for i, u in enumerate(up_to): - # if segment starts after the previous one - # on the same line, then we add it to the line - if segment.start >= u: - found = True - y.append(i) - up_to[i] = segment.end - break - # in case we went out of lines, create a new one - if not found: - y.append(len(up_to)) - up_to.append(segment.end) + for segment in segments: + # so far, we do not know which line to use + found = False + # try each line until we find one that is ok + for i, u in enumerate(up_to): + # if segment starts after the previous one + # on the same line, then we add it to the line + if segment.start >= u: + found = True + y.append(i) + up_to[i] = segment.end + break + # in case we went out of lines, create a new one + if not found: + y.append(len(up_to)) + up_to.append(segment.end) - # from line numbers to actual y coordinates - y = 1. - 1./(len(up_to)+1) * (1+np.array(y)) + # from line numbers to actual y coordinates + y = 1. - 1./(len(up_to)+1) * (1+np.array(y)) - return y + return y # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def repr_timeline(timeline): + """Get `png` data for `timeline`""" - # remember current figure size - figsize = plt.rcParams['figure.figsize'] - # and update it for segment display - plt.rcParams['figure.figsize'] = (_notebook.width, 1) + # remember current figure size + figsize = plt.rcParams['figure.figsize'] + # and update it for segment display + plt.rcParams['figure.figsize'] = (_notebook.width, 1) - if not _notebook.extent and timeline: - set_notebook_crop(segment=timeline.extent()) + if not _notebook.extent and timeline: + set_notebook_crop(segment=timeline.extent()) - cropped = timeline.crop(_notebook.extent, mode='loose') + cropped = timeline.crop(_notebook.extent, mode='loose') - fig, ax = _setup() - - color = 'b' - for segment, y in itertools.izip(cropped, _y(cropped)): - _draw_segment(ax, segment, y, color) + fig, ax = _setup() + + color = 'b' + for segment, y in itertools.izip(cropped, _y(cropped)): + _draw_segment(ax, segment, y, color) - data = _render(fig) + data = _render(fig) - # go back to previous figure size - plt.rcParams['figure.figsize'] = figsize + # go back to previous figure size + plt.rcParams['figure.figsize'] = figsize - return data + return data # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def repr_annotation(annotation): + """Get `png` data for `annotation`""" - # remember current figure size - figsize = plt.rcParams['figure.figsize'] - # and update it for segment display - plt.rcParams['figure.figsize'] = (_notebook.width, 2) + # remember current figure size + figsize = plt.rcParams['figure.figsize'] + # and update it for segment display + plt.rcParams['figure.figsize'] = (_notebook.width, 2) - if not _notebook.extent: - set_notebook_crop(segment=annotation.get_timeline().extent()) + if not _notebook.extent: + set_notebook_crop(segment=annotation.get_timeline().extent()) - cropped = annotation.crop(_notebook.extent, mode='loose') - segments = [s for s, _ in cropped.itertracks()] + cropped = annotation.crop(_notebook.extent, mode='loose') + segments = [s for s, _ in cropped.itertracks()] - # one color per label - chart = cropped.chart() - cm = get_cmap('gist_rainbow') - colors = { - label: cm(1.*i/len(chart)) - for i, (label, _) in enumerate(chart) - } + # one color per label + chart = cropped.chart() + cm = get_cmap('gist_rainbow') + colors = { + label: cm(1.*i/len(chart)) + for i, (label, _) in enumerate(chart) + } - fig, ax = _setup() + fig, ax = _setup() - for (segment, track, label), y in itertools.izip( - cropped.itertracks(label=True), _y(segments)): - color = colors[label] # color = f(label) - _draw_segment(ax, segment, y, color, label=label) + for (segment, track, label), y in itertools.izip( + cropped.itertracks(label=True), _y(segments)): + color = colors[label] # color = f(label) + _draw_segment(ax, segment, y, color, label=label) - data = _render(fig) + data = _render(fig) - # go back to previous figure size - plt.rcParams['figure.figsize'] = figsize + # go back to previous figure size + plt.rcParams['figure.figsize'] = figsize - return data + return data # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ From 87d5f55dddc349fc9370aa72ed8b39ac82c65a57 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Sun, 4 May 2014 20:06:20 +0200 Subject: [PATCH 015/458] fix: do not import notebook (extra) --- pyannote/core/__init__.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/pyannote/core/__init__.py b/pyannote/core/__init__.py index 19714007..7f1c757f 100644 --- a/pyannote/core/__init__.py +++ b/pyannote/core/__init__.py @@ -41,5 +41,3 @@ from segment import Segment from timeline import Timeline from annotation import Annotation from scores import Scores - -from notebook import set_notebook_crop \ No newline at end of file From 7c322348318c74b8bc6639278fd9285aab45336b Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Sun, 4 May 2014 20:09:28 +0200 Subject: [PATCH 016/458] feat: Transcription (as annotation graph) --- pyannote/core/__init__.py | 2 + pyannote/core/json.py | 6 + pyannote/core/notebook.py | 97 ++++++- pyannote/core/transcription.py | 478 +++++++++++++++++++++++++++++++++ 4 files changed, 582 insertions(+), 1 deletion(-) create mode 100644 pyannote/core/transcription.py diff --git a/pyannote/core/__init__.py b/pyannote/core/__init__.py index 7f1c757f..54b71a7d 100644 --- a/pyannote/core/__init__.py +++ b/pyannote/core/__init__.py @@ -37,7 +37,9 @@ PYANNOTE_LABEL = 'label' PYANNOTE_SCORE = 'score' PYANNOTE_IDENTITY = 'identity' +from time import T, TStart, TEnd from segment import Segment from timeline import Timeline from annotation import Annotation +from transcription import Transcription from scores import Scores diff --git a/pyannote/core/json.py b/pyannote/core/json.py index 01a1db01..a92f7c41 100644 --- a/pyannote/core/json.py +++ b/pyannote/core/json.py @@ -31,6 +31,8 @@ PYANNOTE_JSON_TIME = 'T' PYANNOTE_JSON_SEGMENT = 'S' PYANNOTE_JSON_TIMELINE = 'L' PYANNOTE_JSON_ANNOTATION = 'A' +PYANNOTE_JSON_TRANSCRIPTION = 'G' + def object_hook(d): @@ -46,6 +48,7 @@ def object_hook(d): from segment import Segment from timeline import Timeline from annotation import Annotation + from transcription import Transcription if PYANNOTE_JSON_TIME in d: return T.from_json(d) @@ -59,6 +62,9 @@ def object_hook(d): if PYANNOTE_JSON_ANNOTATION in d: return Annotation.from_json(d) + if PYANNOTE_JSON_TRANSCRIPTION in d: + return Transcription.from_json(d) + return d def load(path): diff --git a/pyannote/core/notebook.py b/pyannote/core/notebook.py index c41441dc..2e77ce7a 100644 --- a/pyannote/core/notebook.py +++ b/pyannote/core/notebook.py @@ -30,8 +30,10 @@ import matplotlib.pyplot as plt from matplotlib.cm import get_cmap import itertools import codecs +import tempfile +import networkx as nx import numpy as np - +import subprocess from segment import Segment @@ -249,3 +251,96 @@ def repr_annotation(annotation): # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +def _shorten_long_text(text, max_length=30): + suffix = "..." + if len(text) > max_length: + return text[:max_length-len(suffix)] + suffix + else: + return text + +def _remove_non_ascii(text): + # list of characters to remove + # those characters make resulting SVG invalid + remove = [u"&", ] + remove = {ord(r): u"" for r in remove} + ascii = unicode(codecs.encode(text, 'ascii', 'replace')) + return ascii.translate(remove) + +def _dottable(transcription): + # create new graph with graphviz/dot layout instructions + # (e.g. graph orientation, node and edge labels, etc.) + + + # create a dumb networkx copy to avoid messing with input transcription + dottable = transcription.copy() + + # graphviz/dot will display graph from left to right + dottable.graph['graph'] = {'rankdir': 'LR'} + + # set shape, label and tooltip of each node + for n in transcription.nodes_iter(): + + + dottable.node[n] = { + 'label': str(n), 'tooltip': str(n), + 'shape': 'circle' if n.drifting else 'box' + } + # 'URL': 'javascript:console.log("{t}")'.format(t=n.T), + + # set edge label + + label_header = ( + "<" + ) + label_pattern = ( + "" + "" + "" + "" + ) + label_footer = "
{name}{value}
>" + tooltip_pattern = "[{name}] {value}" + + for source, target, key, data in transcription.edges_iter(keys=True, data=True): + tooltip = "" + label = "" + if data: + + # initialize label table + label = label_header + + for name, value in data.iteritems(): + # remove non-ascii characters + name = _remove_non_ascii(name) + value = _remove_non_ascii(value) + # shorten long value + value = _shorten_long_text(value) + # update label and tooltip + label += label_pattern.format(name=name, value=value) + tooltip += tooltip_pattern.format(name=name, value=value) + + # close label table + label += label_footer + + dottable[source][target][key] = { + 'label': label, + 'labeltooltip': tooltip, + 'edgetooltip': tooltip, + 'headtooltip': tooltip, + 'tailtooltip': tooltip, + } + + return dottable + +def _write_temporary_dot_file(transcription): + _, path = tempfile.mkstemp('.dot') + nx.write_dot(_dottable(transcription), path) + return path + +def repr_transcription(transcription): + """Get `svg` data for `transcription`""" + path = _write_temporary_dot_file(transcription) + data = subprocess.check_output(["dot", "-T", "svg", path]) + return data[data.find(">> G = Transcription() + >>> t1 = T(1.000) + >>> t2 = T() + >>> data = {'speaker': 'John', 'speech': 'Hello world!'} + >>> G.add_annotation(t1, t2, data=data) + """ + + t1 = T(t1) + t2 = T(t2) + + # make sure Ts are connected in correct chronological order + if t1.anchored and t2.anchored: + assert t1 <= t2 + + self.add_edge(t1, t2, attr_dict=data) + + def relabel_drifting_nodes(self, mapping=None): + """Relabel drifting nodes + + Parameters + ---------- + mapping : dict, optional + A dictionary with the old labels as keys and new labels as values. + + + Returns + ------- + g : Transcription + New annotation graph + mapping : dict + A dictionary with the new labels as keys and old labels as values. + Can be used to get back to the version before relabelling. + """ + + if mapping is None: + old2new = {n: T() for n in self.drifting()} + else: + old2new = dict(mapping) + + new2old = {new: old for old, new in old2new.iteritems()} + return nx.relabel_nodes(self, old2new, copy=True), new2old + + def crop(self, source, target=None): + """Get subgraph between source and target + + Parameters + ---------- + source : Segment, + target : float or str, optional + + Returns + ------- + g : Transcription + Sub-graph between source and target + """ + + if isinstance(source, Segment): + source, target = source.start, source.end + + source = T(source) + target = T(target) + + if source.anchored: + before = [n for n in self.anchored() if n <= source] + if before: + source = sorted(before)[-1] + + if target.anchored: + after = [n for n in self.anchored() if n >= target] + if after: + target = sorted(after)[0] + + from_source = nx.algorithms.descendants(self, source) + to_target = nx.algorithms.ancestors(self, target) + nbunch = {source, target} | (from_source & to_target) + return self.subgraph(nbunch) + + # ========================================================================= + + def _merge(self, drifting_t, another_t): + """Helper function to merge `drifting_t` with `another_t` + + Assumes that both `drifting_t` and `another_t` exists. + Also assumes that `drifting_t` is an instance of `TFloating` + (otherwise, this might lead to weird graph configuration) + + Parameters + ---------- + drifting_t : + Existing drifting time in graph + another_t : + Existing time in graph + """ + # drifting_t and another_t must exist in graph + + # add a (t --> another_t) edge for each (t --> drifting_t) edge + for t, _, key, data in self.in_edges_iter( + nbunch=[drifting_t], data=True, keys=True + ): + self.add_edge(t, another_t, key=key, attr_dict=data) + + # add a (another_t --> t) edge for each (drifting_t --> t) edge + for _, t, key, data in self.edges_iter( + nbunch=[drifting_t], data=True, keys=True + ): + self.add_edge(another_t, t, key=key, attr_dict=data) + + # remove drifting_t node (as it was replaced by another_t) + self.remove_node(drifting_t) + + def anchor(self, drifting_t, anchored_t): + """ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + o -- [ D ] -- o ==> o -- [ A ] -- o + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + Anchor `drifting_t` at `anchored_t` + + Parameters + ---------- + drifting_t : + Drifting time to anchor + anchored_t : + When to anchor `drifting_t` + + """ + + drifting_t = T(drifting_t) + anchored_t = T(anchored_t) + + assert (drifting_t in self) and (drifting_t.drifting) + assert anchored_t.anchored + + if anchored_t not in self: + self.add_node(anchored_t) + + self._merge(drifting_t, anchored_t) + + def align(self, one_t, another_t): + """ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + o -- [ F ] -- o o o + ⟍ ⟋ + ==> [ F ] + ⟋ ⟍ + o -- [ f ] -- o o o + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + Align two (potentially drifting) times + + `one_t` and `another_t` cannot both be anchored at the same time + In case `another_t` is anchored, this is similar to `anchor` method + + Parameters + ---------- + one_t, another_t + Two times to be aligned. + """ + + one_t = T(one_t) + another_t = T(another_t) + + assert one_t in self + assert another_t in self + + # first time is drifting + if one_t.drifting: + self._merge(one_t, another_t) + + # second time is drifting + elif another_t.drifting: + self._merge(another_t, one_t) + + # both times are anchored --> FAIL + else: + raise ValueError( + 'Cannot align two anchored times') + + # ========================================================================= + + def pre_align(self, t1, t2, t): + """ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + p -- [ t1 ] p [ t1 ] + ⟍ ⟋ + ==> [ t ] + ⟋ ⟍ + p' -- [ t2 ] p' [ t2 ] + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + """ + + t1 = T(t1) + t2 = T(t2) + t = T(t) + + # make sure --[t1] incoming edges are empty + # because they're going to be removed afterwards, + # and we don't want to loose data + pred1 = self.predecessors(t1) + for p in pred1: + for key, data in self[p][t1].iteritems(): + assert not data + + # make sure --[t2] incoming edges are empty + # (for the same reason...) + pred2 = self.predecessors(t2) + for p in pred2: + for key, data in self[p][t2].iteritems(): + assert not data + + # let's get started (remove all incoming edges) + for p in pred1: + for key in list(self[p][t1]): + self.remove_edge(p, t1, key=key) + for p in pred2: + for key in list(self[p][t2]): + self.remove_edge(p, t2, key=key) + + for p in set(pred1) | set(pred2): + self.add_annotation(p, t, data=None) + + self.add_annotation(t, t1, data=None) + self.add_annotation(t, t2, data=None) + + def post_align(self, t1, t2, t): + """ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + [ t1 ] -- s [ t1 ] s + ⟍ ⟋ + ==> [ t ] + ⟋ ⟍ + [ t2 ] -- s' [ t2 ] s' + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + """ + + t1 = T(t1) + t2 = T(t2) + t = T(t) + + # make sure [t1]-- outgoing edges are empty + # because they're going to be removed afterwards, + # and we don't want to loose data + succ1 = self.successors(t1) + for s in succ1: + for key, data in self[t1][s].iteritems(): + assert not data + + # make sure --[t2] outgoing edges are empty + # (for the same reason...) + succ2 = self.successors(t2) + for s in succ2: + for key, data in self[t2][s].iteritems(): + assert not data + + # let's get started (remove all outgoing edges) + for s in succ1: + for key in list(self[t1][s]): + self.remove_edge(t1, s, key=key) + for s in succ2: + for key in list(self[t2][s]): + self.remove_edge(t2, s, key=key) + + for s in set(succ1) | set(succ2): + self.add_annotation(t, s, data=None) + + self.add_annotation(t1, t, data=None) + self.add_annotation(t2, t, data=None) + + # ========================================================================= + + def ordering_graph(self): + """Ordering graph + + t1 --> t2 in the ordering graph indicates that t1 happens before t2. + A missing edge simply means that it is not clear yet. + + """ + + g = nx.DiGraph() + + # add times + for t in self.nodes_iter(): + g.add_node(t) + + # add existing edges + for t1, t2 in self.edges_iter(): + g.add_edge(t1, t2) + + # connect every pair of anchored times + anchored = sorted(self.anchored()) + for t1, t2 in itertools.combinations(anchored, 2): + g.add_edge(t1, t2) + + # connect every time with its sucessors + _g = g.copy() + for t1 in _g: + for t2 in set([target for (_, target) in nx.bfs_edges(_g, t1)]): + g.add_edge(t1, t2) + + return g + + def ordered_edges_iter(self, data=False, keys=False): + """Return an iterator over the edges in temporal/topological order. + + Ordered edges are returned as tuples with optional data and keys + in the order (t1, t2, key, data). + + Parameters + ---------- + data : bool, optional (default=False) + If True, return edge attribute dict with each edge. + keys : bool, optional (default=False) + If True, return edge keys with each edge. + + Returns + ------- + edge_iter : iterator + An iterator of (u,v), (u,v,d) or (u,v,key,d) tuples of edges. + """ + + # start by sorting nodes in temporal+topological order + o = self.ordering_graph() + nodes = nx.topological_sort(o) + + # iterate over edges using this very order + for _ in self.edges_iter(nbunch=nodes, data=data, keys=keys): + yield _ + + # ========================================================================= + + def _anchored_successors(self, n): + """Get all first anchored successors""" + + # loop on all outgoing edges + for t in self.successors(n): + + # if neighbor is anchored + # stop looking for (necessarily later) successors + if t.anchored: + yield t + continue + + # if neighbor is not anchored + # look one level deeper + for tt in self._anchored_successors(t): + yield tt + + def _anchored_predecessors(self, n): + """Get all first anchored predecessors""" + + # loop on all incoming edges + for t in self.predecessors(n): + + # if predecessor is anchored + # stop looking for (necessarily earlier) predecessors + if t.anchored: + yield t + continue + + # if neighbor is not anchored + # look one level deeper + for tt in self._anchored_predecessors(t): + yield tt + + def timerange(self, t): + """Infer smallest possible timerange from graph structure + + Returns + ------- + (left, right) tuple + left == None or right == None indicates that the current state of + the annotation graph does not allow to decide the boundary. + + """ + + t = T(t) + + if t.anchored: + return (t.T, t.T) + successors = [n for n in self._anchored_successors(t)] + predecessors = [n for n in self._anchored_predecessors(t)] + + earlier_successor = None + if successors: + earlier_successor = min(successors) + + later_predecessor = None + if predecessors: + later_predecessor = max(predecessors) + + return (later_predecessor.T, earlier_successor.T) + + # ========================================================================= + + def for_json(self): + return {PYANNOTE_JSON_TRANSCRIPTION: node_link_data(self)} + + @classmethod + def from_json(cls, data): + graph = node_link_graph(data[PYANNOTE_JSON_TRANSCRIPTION]) + return cls(graph=graph, **graph.graph) + + # === IPython Notebook displays =========================================== + + def _repr_svg_(self): + from notebook import repr_transcription + return repr_transcription(self) From 38d4e196423b8f6a8826dcf15ea67b12041c825c Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Sun, 4 May 2014 20:19:02 +0200 Subject: [PATCH 017/458] git: ignore MANIFEST and notebook checkpoints --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index 51cbe852..b8a81055 100644 --- a/.gitignore +++ b/.gitignore @@ -6,6 +6,7 @@ __pycache__/ *.so # Distribution / packaging +MANIFEST .Python env/ bin/ @@ -52,3 +53,4 @@ coverage.xml # Sphinx documentation docs/_build/ +doc/.ipynb_checkpoints From a27f9e6192522fc0bc80d607de42a3e71b872544 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Mon, 5 May 2014 22:18:00 +0200 Subject: [PATCH 018/458] doc: visual index --- doc/index.ipynb | 155 +++++++++++++++++++++++++---- doc/pyannote.core.annotation.ipynb | 30 +++--- doc/pyannote.core.segment.ipynb | 9 +- doc/pyannote.core.timeline.ipynb | 13 ++- 4 files changed, 167 insertions(+), 40 deletions(-) diff --git a/doc/index.ipynb b/doc/index.ipynb index c0cc5ea7..ca07d1a5 100644 --- a/doc/index.ipynb +++ b/doc/index.ipynb @@ -1,7 +1,7 @@ { "metadata": { "name": "", - "signature": "sha256:6e4beb6041e0424cc9556e8e9d4565350294c0d2829f1cba8152635f01966064" + "signature": "sha256:829046194119708434df414492879e4699dd54685b3be0e1afcb80fe243d8b68" }, "nbformat": 3, "nbformat_minor": 0, @@ -34,6 +34,13 @@ "```" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**OS X Mavericks users**: if `pip` has trouble installing `banyan`, try installing it from (bug-fixed) [source](https://github.com/hbredin/banyan). " + ] + }, { "cell_type": "heading", "level": 2, @@ -43,45 +50,153 @@ ] }, { - "cell_type": "markdown", + "cell_type": "code", + "collapsed": false, + "input": [ + "from pyannote.core import *" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 3, "metadata": {}, "source": [ - "[Segment](pyannote.core.segment.ipynb) (`pyannote.core.segment`)" + "Segment ([pyannote.core.segment](pyannote.core.segment.ipynb))" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "segment = Segment(start=0, end=20)\n", + "segment" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAxsAAACUCAYAAAD70DRZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAABJRU5ErkJggg==\n", + "prompt_number": 2, + "text": [ + "" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Timeline ([pyannote.core.timeline](pyannote.core.timeline.ipynb))" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "timeline = Timeline([Segment(1, 5), Segment(6, 8), Segment(12, 18), Segment(7, 20)])\n", + "timeline" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAxsAAACUCAYAAAD70DRZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nyY1TqwAAAABJRU5ErkJggg==\n", + "prompt_number": 3, + "text": [ + ", , , ])>" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Annotation ([pyannote.core.annotation](pyannote.core.annotation.ipynb))" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "annotation = Annotation()\n", + "annotation[Segment(1, 5)] = 'John'\n", + "annotation[Segment(6, 8)] = 'Jack'\n", + "annotation[Segment(12, 18)] = 'John'\n", + "annotation[Segment(7, 20)] = 'Alice'\n", + "annotation" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "png": "iVBORw0KGgoAAAANSUhEUgAAAxsAAADkCAYAAADw8jmYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "prompt_number": 4, + "text": [ + "" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Transcription ([pyannote.core.transcription](pyannote.core.transcription.ipynb))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "[Timeline](pyannote.core.timeline.ipynb) (`pyannote.core.timeline`)" + "Not yet available - coming" + ] + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Feature ([pyannote.core.feature](pyannote.core.feature.ipynb))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "[Annotation](pyannote.core.annotation.ipynb) (`pyannote.core.annotation`)" + "Already available - documentation in preparation" + ] + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Scores ([pyannote.core.scores](pyannote.core.scores.ipynb))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "[Transcription](pyannote.core.transcription) (`pyannote.core.transcription`) -- coming soon" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "[Feature](pyannote.core.feature.ipynb) (`pyannote.core.feature`) -- documentation coming soon" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "[Scores](pyannote.core.scores.ipynb) (`pyannote.core.scores`) -- documentation coming soon" + "Already available - documentation in preparation" ] }, { diff --git a/doc/pyannote.core.annotation.ipynb b/doc/pyannote.core.annotation.ipynb index efedf8db..293f4a4e 100644 --- a/doc/pyannote.core.annotation.ipynb +++ b/doc/pyannote.core.annotation.ipynb @@ -1,7 +1,7 @@ { "metadata": { "name": "", - "signature": "sha256:a4d5ace5db53f04fbea7d935faf9b49cbdaeb510d5a7f2cdd07cf162894ad3c4" + "signature": "sha256:1bd4e074d3fea54e1ebd157ff53cefe9f101c2334c0f838eeb6d430270f404f3" }, "nbformat": 3, "nbformat_minor": 0, @@ -96,7 +96,7 @@ "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAHgGhv9P8Kv/AAAAAElFTkSuQmCC\n", "prompt_number": 4, "text": [ - "" + "" ] } ], @@ -125,7 +125,7 @@ "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nuTbqt2brAAAAAElFTkSuQmCC\n", "prompt_number": 5, "text": [ - "" + "" ] } ], @@ -156,7 +156,7 @@ "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", "prompt_number": 6, "text": [ - "" + "" ] } ], @@ -201,7 +201,7 @@ "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", "prompt_number": 7, "text": [ - "" + "" ] } ], @@ -503,7 +503,7 @@ "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", "prompt_number": 17, "text": [ - "" + "" ] } ], @@ -525,7 +525,7 @@ "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", "prompt_number": 18, "text": [ - "" + "" ] } ], @@ -561,7 +561,7 @@ "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", "prompt_number": 19, "text": [ - "" + "" ] } ], @@ -604,7 +604,7 @@ "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngg==\n", "prompt_number": 21, "text": [ - "" + "" ] } ], @@ -633,7 +633,7 @@ "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\neAAAgPMIHgAA4Lz/B/ocQcOCYV/3AAAAAElFTkSuQmCC\n", "prompt_number": 22, "text": [ - "" + "" ] } ], @@ -655,7 +655,7 @@ "png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACbCAYAAABmiUHlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAADU1JREFUeJzt3X1MlfX/x/HXdRBvKNRsSJoWaXlzuIkLMaYrwfAmcrY0\nckNLBrP+aLnW3axV01ort/4J+9barBltLXJmDUXNnECWaSEHsVuWk8wyTc0yD6kHzu8PfmL1Rb9l\nyAfePB8bUy6O7H0+nHP55DrXOceLRqNRAQAAGBZwPQAAAMCFRvAAAADzCB4AAGAewQMAAMwjeAAA\ngHkEDwAAMK/Xub6Yk5Oj6urqzpoFAADgvGVnZ6uqqqrdr53zCE91dbWi0Wi3/Fi8eLHzGbrCB+vA\nWrAOrANrwTr0lLU410EaHtICAADmETwAAMA8s8GTk5PjeoQugXU4g7VoxTq0Yh3OYC1asQ5nWFwL\nLxqNnvW9tDzP0zm+DAAA0GWcq1vMHuEBAAA4jeABAADmETwAAMA8ggcAAJhH8AAAAPMIHgAAYB7B\nAwAAzCN4AACAeQQPAAAwj+ABAADmETwAAMA8ggcAAJhH8AAAAPMIHgAAYB7BAwAAzCN4AACAeQQP\nAAAwj+ABAADmETwAAMA8ggcAAJhH8AAAAPMIHgAAYB7BAwAAzCN4AACAeQQPAAAwj+ABAADmETwA\nAMA8ggcAAJhH8AAAAPMIHgAAYB7BAwAAzCN4AACAeQQPAAAwj+ABAADmETwAAMA8ggcAAJhH8HQT\nMTEx8n1fqampmjNnjpqamlyPBABdEvtLtIfg6Sbi4uIUCoW0a9cu9e7dWy+//LLrkQCgS2J/ifYQ\nPN3Q9ddfr2+++UbhcFjFxcXKyspSRkaGysvLJUmvvfaaZs+erby8PI0aNUqLFi1q+7cXX3yxHn/8\ncaWnp2vChAk6ePCgjh07phEjRigSiUiSfv31V40YMULNzc1Orh8AdBT2lziN4OlmIpGINmzYoLS0\nND399NPKzc3V9u3btXnzZj388MMKh8OSpJ07d2rlypXatWuX3nrrLX3//feSpHA4rAkTJqiurk6T\nJk3S8uXLFR8fr5ycHFVUVEiSysrKdNtttykmJsbZ9QSAf4v9Jf6I4Okmmpqa5Pu+xo8fryuvvFLF\nxcXauHGjli5dKt/3NXnyZJ04cUJ79+6V53nKzc1VfHy8+vTpo2AwqG+//VaS1Lt3b82YMUOSNG7c\nODU2NkqSFixYoBUrVkhq/Y2nqKjIyfUEgH+L/SXa08v1APh7+vXrp1Ao9F/bV69erWuuueZP27Zv\n364+ffq0fR4TE9N2+DU2NrZteyAQaNs+ceJENTY2qqqqSs3NzQoGgxfiagDABcf+Eu3hCE83Nn36\ndC1btqzt89N38Gg0el7fb/78+Zo3b56Ki4s7ZD4A6CrYX4Lg6SY8z/uvbU888YROnTqltLQ0paSk\naPHixW2Xbe/yf/0+f73c3Llz9fPPP6ugoKCDpweAzsP+Eu3xoufIW8/zzrt+nVvyH2nJva6n6FZW\nrVqlNWvWqLS01PUoFwa3CaB93Df+MfaXXdO5usVu8HhBKfqF6ym6jYULF+q9997TunXrdPXVV7se\n58LgNgG0j/vGP8L+susieACJ2wRwNtw38Ffd9DZxrm7hHB4AAGAewQMAAMwjeAAAgHm2X3jQ48Wg\nAOBvYX8J42wHTzc84QoXEDt04OzYX+KPDO4veUgLAACYR/AAAADzCB4AAGAewQMAAMyzGzyL73E9\nAboabhNA+7hv4K8M3ibsvrUEAADoUXhrCQAA0KMRPAAAwDyCBwAAmEfwAAAA8wgeAABgHsEDAADM\nI3gAAIB5BA8AADCP4AEAAOYRPAAAwDyCBwAAmEfwAAAA8wgeAABgHsEDAADMI3gAAIB5BA8AADCP\n4AEAAOYRPAAAwDyCBwAAmEfwAAAA8wgeAABgHsEDAADMI3gAAIB5BA8AADCP4AEAAOYRPAAAwDyC\nBwAAmEfwAAAA8wgeAABgHsEDAADMI3gAAIB5BA8AADCP4AEAAOYRPAAAwDyCBwAAmEfwAAAA8wge\nAABgHsEDAADMI3gAAIB5BA8AADCP4AEAAOYRPAAAwDyCBwAAmEfwAAAA88wGT1VVlesRugTW4QzW\nohXr0Ip1OIO1aMU6nGFxLQge41iHM1iLVqxDK9bhDNaiFetwhsW1MBs8AAAApxE8AADAPC8ajUbP\n9sWcnBxVV1d35jwAAADnJTs7+6wPx50zeAAAACzgIS0AAGAewQMAAMwzFTy///67srKylJ6ermAw\nqEcffdT1SE41NzfL933NnDnT9ShOJSUlKS0tTb7v67rrrnM9jjNHjx5Vfn6+xo4dq2AwqG3btrke\nyYmvv/5avu+3fQwYMEDLli1zPZYTzz77rJKTk5Wamqq5c+fqxIkTrkdypqSkRKmpqUpJSVFJSYnr\ncTpNcXGxEhMTlZqa2rbtyJEjmjp1qkaNGqVp06bp6NGjDifsOKaCp2/fvqqsrFRdXZ3q6+tVWVmp\nDz/80PVYzpSUlCgYDMrzPNejOOV5nqqqqhQKhfTJJ5+4HseZ++67TzfffLO+/PJL1dfXa+zYsa5H\ncmL06NEKhUIKhULasWOH4uLiNGvWLNdjdbrGxkYtX75ctbW12rVrl5qbm1VWVuZ6LCc+++wzvfLK\nK/r000+1c+dOrV27Vrt373Y9VqcoKirShg0b/rRt6dKlmjp1qhoaGpSbm6ulS5c6mq5jmQoeSYqL\ni5MknTx5Us3NzRo0aJDjidzYt2+f1q1bpwULFojz0tXj1+CXX37Rli1bVFxcLEnq1auXBgwY4Hgq\n9zZt2qSRI0dq+PDhrkfpdP3791dsbKzC4bAikYjC4bAuv/xy12M58dVXXykrK0t9+/ZVTEyMsrOz\ntXr1atdjdYobbrhBl1xyyZ+2lZeXq7CwUJJUWFiod99918VoHc5c8LS0tCg9PV2JiYmaPHmygsGg\n65GcuP/++/Xcc88pEDD3I/7HPM/TlClTlJmZqeXLl7sex4k9e/YoISFBRUVFysjI0F133aVwOOx6\nLOfKyso0d+5c12M4MWjQID344IO64oorNHToUA0cOFBTpkxxPZYTKSkp2rJli44cOaJwOKyKigrt\n27fP9VjOHDhwQImJiZKkxMREHThwwPFEHcPc/4aBQEB1dXXat2+fPvjgA5Mvj/2/rF27VoMHD5bv\n+z3+yIYkffTRRwqFQlq/fr1efPFFbdmyxfVInS4Siai2tlb33HOPamtrddFFF5k5TH2+Tp48qTVr\n1uj22293PYoTu3fv1vPPP6/Gxkb98MMP+u233/TGG2+4HsuJMWPGaNGiRZo2bZry8vLk+z6/LP4/\nz/PMnBZh9ic6YMAAzZgxQzU1Na5H6XRbt25VeXm5rrrqKhUUFGjz5s2aP3++67GcGTJkiCQpISFB\ns2bN6pHn8QwbNkzDhg3T+PHjJUn5+fmqra11PJVb69ev17hx45SQkOB6FCdqamo0ceJEXXrpperV\nq5dmz56trVu3uh7LmeLiYtXU1Ki6uloDBw7U6NGjXY/kTGJion788UdJ0v79+zV48GDHE3UMU8Fz\n6NChtrPJm5qa9P7778v3fcdTdb5nnnlG3333nfbs2aOysjLdeOONev31112P5UQ4HNaxY8ckSceP\nH9fGjRv/9GyEnuKyyy7T8OHD1dDQIKn13JXk5GTHU7n15ptvqqCgwPUYzowZM0bbtm1TU1OTotGo\nNm3a1GNPAZCkgwcPSpL27t2rd955p8c+1ClJt9xyi0pLSyVJpaWluvXWWx1P1DF6uR6gI+3fv1+F\nhYVqaWlRS0uL7rzzTuXm5roeyzkrhyPPx4EDB9qegROJRDRv3jxNmzbN8VRuvPDCC5o3b55Onjyp\nkSNHasWKFa5Hcub48ePatGlTjz2nS5KuvfZazZ8/X5mZmQoEAsrIyNDdd9/teixn8vPzdfjwYcXG\nxuqll15S//79XY/UKQoKClRdXa1Dhw5p+PDheuqpp/TII49ozpw5evXVV5WUlKSVK1e6HrND8NYS\nAADAPFMPaQEAALSH4AEAAOYRPAAAwDyCBwAAmEfwAAAA8wgeAABgHsED4F87fPiwfN+X7/saMmSI\nhg0bJt/3FR8fr3vvvdf1eADA6/AA6FhPPvmk4uPj9cADD7geBQDacIQHQIc7/XtUVVWVZs6cKUla\nsmSJCgsLNWnSJCUlJWn16tV66KGHlJaWpry8PEUiEUnSjh07lJOTo8zMTN10001t7+kDAP8GwQOg\n0+zZs0eVlZUqLy/XHXfcoalTp6q+vl79+vVTRUWFTp06pYULF+rtt99WTU2NioqK9Nhjj7keG4AB\npt5LC0DX5Xme8vLyFBMTo5SUFLW0tGj69OmSpNTUVDU2NqqhoUGff/65pkyZIklqbm7W0KFDXY4N\nwAiCB0Cn6d27tyQpEAgoNja2bXsgEFAkElE0GlVycrK2bt3qakQARvGQFoBO8XeeHzF69Gj99NNP\n2rZtmyTp1KlT+uKLLy70aAB6AIIHQIfzPK/tz/b+/sfL/PHz2NhYrVq1SosWLVJ6erp839fHH3/c\neYMDMIunpQMAAPM4wgMAAMwjeAAAgHkEDwAAMI/gAQAA5hE8AADAPIIHAACYR/AAAADzCB4AAGDe\n/wGhtarxiWmJnQAAAABJRU5ErkJggg==\n", "prompt_number": 23, "text": [ - "" + "" ] } ], @@ -945,7 +945,7 @@ " | \n", " | copy(self)\n", " | \n", - " | crop(self, other, mode='intersection')\n", + " | crop(self, other, mode=u'intersection')\n", " | Crop annotation\n", " | \n", " | Parameters\n", @@ -971,6 +971,8 @@ " | \n", " | empty(self)\n", " | \n", + " | for_json(self)\n", + " | \n", " | get_labels(self, segment, unknown=True, unique=True)\n", " | Local set of labels\n", " | \n", @@ -1139,8 +1141,6 @@ " | subset : `Annotation`\n", " | Annotation subset.\n", " | \n", - " | to_json(self)\n", - " | \n", " | translate(self, translation)\n", " | Translate labels\n", " | \n", @@ -1174,6 +1174,8 @@ " | Returns\n", " | -------\n", " | \n", + " | from_json(cls, data) from __builtin__.type\n", + " | \n", " | ----------------------------------------------------------------------\n", " | Data descriptors defined here:\n", " | \n", diff --git a/doc/pyannote.core.segment.ipynb b/doc/pyannote.core.segment.ipynb index 950087e0..8dc2f2f2 100644 --- a/doc/pyannote.core.segment.ipynb +++ b/doc/pyannote.core.segment.ipynb @@ -1,7 +1,7 @@ { "metadata": { "name": "", - "signature": "sha256:4b89a8137927ed8e28131e6997066577a66c6d70295168c40ee78ed5be351488" + "signature": "sha256:19c03eb505c101730448f707d6e72024ce48e66e4beb9d0610da34b7cf435e75" }, "nbformat": 3, "nbformat_minor": 0, @@ -549,6 +549,8 @@ " | copy(self)\n", " | Duplicate segment.\n", " | \n", + " | for_json(self)\n", + " | \n", " | intersects(self, other)\n", " | Check whether two segments intersect each other\n", " | \n", @@ -567,7 +569,10 @@ " | pretty(self)\n", " | Human-readable representation of segments\n", " | \n", - " | to_json(self)\n", + " | ----------------------------------------------------------------------\n", + " | Class methods defined here:\n", + " | \n", + " | from_json(cls, data) from __builtin__.type\n", " | \n", " | ----------------------------------------------------------------------\n", " | Static methods defined here:\n", diff --git a/doc/pyannote.core.timeline.ipynb b/doc/pyannote.core.timeline.ipynb index 0299f7b9..778b3a74 100644 --- a/doc/pyannote.core.timeline.ipynb +++ b/doc/pyannote.core.timeline.ipynb @@ -1,7 +1,7 @@ { "metadata": { "name": "", - "signature": "sha256:fcfc25daecf48fefb64137a273ce8cffa7ee7f2e7702fbcb7ea7b2288c284058" + "signature": "sha256:9495420d2916dbde9f85831e4de260d1f3157975316149bf17ba9d4a8f3a8ad6" }, "nbformat": 3, "nbformat_minor": 0, @@ -774,7 +774,7 @@ " | coverage : Timeline\n", " | Timeline coverage\n", " | \n", - " | crop(self, other, mode='intersection', mapping=False)\n", + " | crop(self, other, mode=u'intersection', mapping=False)\n", " | \n", " | duration(self)\n", " | Timeline duration\n", @@ -819,6 +819,8 @@ " | >>> print timeline.extent()\n", " | [0 --> 10]\n", " | \n", + " | for_json(self)\n", + " | \n", " | gaps(self, focus=None)\n", " | Timeline gaps\n", " | \n", @@ -887,8 +889,6 @@ " | [6 --> 7]\n", " | ]\n", " | \n", - " | to_json(self)\n", - " | \n", " | union(self, other)\n", " | Create new timeline made of union of segments\n", " | \n", @@ -896,6 +896,11 @@ " | Add `timeline` segments\n", " | \n", " | ----------------------------------------------------------------------\n", + " | Class methods defined here:\n", + " | \n", + " | from_json(cls, data) from __builtin__.type\n", + " | \n", + " | ----------------------------------------------------------------------\n", " | Data descriptors defined here:\n", " | \n", " | __dict__\n", From 5e20fcabc6823fe4819b3652beebef2973cf8c76 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Mon, 5 May 2014 22:24:49 +0200 Subject: [PATCH 019/458] fix: Transcription JSON support --- pyannote/core/json.py | 5 ----- pyannote/core/time.py | 38 ---------------------------------- pyannote/core/transcription.py | 5 ++++- 3 files changed, 4 insertions(+), 44 deletions(-) diff --git a/pyannote/core/json.py b/pyannote/core/json.py index a92f7c41..8f458f4d 100644 --- a/pyannote/core/json.py +++ b/pyannote/core/json.py @@ -27,7 +27,6 @@ from __future__ import unicode_literals import simplejson as json -PYANNOTE_JSON_TIME = 'T' PYANNOTE_JSON_SEGMENT = 'S' PYANNOTE_JSON_TIMELINE = 'L' PYANNOTE_JSON_ANNOTATION = 'A' @@ -44,15 +43,11 @@ def object_hook(d): ... json.load(f, object_hook=object_hook) """ - from time import T from segment import Segment from timeline import Timeline from annotation import Annotation from transcription import Transcription - if PYANNOTE_JSON_TIME in d: - return T.from_json(d) - if PYANNOTE_JSON_SEGMENT in d: return Segment.from_json(d) diff --git a/pyannote/core/time.py b/pyannote/core/time.py index b0a75bd6..75120a10 100644 --- a/pyannote/core/time.py +++ b/pyannote/core/time.py @@ -86,30 +86,6 @@ class _TAnchored(float): return super(_TAnchored, self).__str__() - def __repr__(self): - return '' % str(self) - - def for_json(self): - """ - Usage - ----- - >>> import simplejson as json - >>> t = T() - >>> json.dumps(t, for_json=True) - """ - - t = float(self) - - if t == float('infinity'): - return {PYANNOTE_JSON_TIME: '^'} - - if t == -float('infinity'): - return {PYANNOTE_JSON_TIME: '$'} - - return {PYANNOTE_JSON_TIME: t} - - - # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' @@ -155,7 +131,6 @@ class _TDrifting(str): t = next(cls.__t_iter) return str.__new__(cls, t) - @classmethod def _reset(cls): """Reset label generator""" @@ -169,19 +144,6 @@ class _TDrifting(str): def drifting(self): return True - def __repr__(self): - return '' % str(self) - - def for_json(self): - """ - Usage - ----- - >>> import simplejson as json - >>> t = T() - >>> json.dumps(t, for_json=True) - """ - return {PYANNOTE_JSON_TIME: str(self)} - # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class _T(object): diff --git a/pyannote/core/transcription.py b/pyannote/core/transcription.py index c0de4297..3f15fb78 100644 --- a/pyannote/core/transcription.py +++ b/pyannote/core/transcription.py @@ -38,8 +38,9 @@ import itertools class Transcription(nx.MultiDiGraph): """Transcription stored as annotation graph""" - def __init__(self, graph=None, uri=None): + def __init__(self, graph=None, **attrs): super(Transcription, self).__init__(data=graph) + self.graph.update(attrs) def drifting(self): """Get list of drifting times""" @@ -469,6 +470,8 @@ class Transcription(nx.MultiDiGraph): @classmethod def from_json(cls, data): graph = node_link_graph(data[PYANNOTE_JSON_TRANSCRIPTION]) + mapping = {node: T(node) for node in graph} + graph = nx.relabel_nodes(graph, mapping) return cls(graph=graph, **graph.graph) # === IPython Notebook displays =========================================== From b016e1151045893327cbb66890ae64c7de77c236 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Mon, 5 May 2014 22:26:29 +0200 Subject: [PATCH 020/458] chore(Transciption): add_{annotation ==> edge} --- pyannote/core/transcription.py | 22 +++++++++------------- 1 file changed, 9 insertions(+), 13 deletions(-) diff --git a/pyannote/core/transcription.py b/pyannote/core/transcription.py index 3f15fb78..32aebcac 100644 --- a/pyannote/core/transcription.py +++ b/pyannote/core/transcription.py @@ -50,7 +50,7 @@ class Transcription(nx.MultiDiGraph): """Get list of anchored times""" return [n for n in self if n.anchored] - def add_annotation(self, t1, t2, data=None): + def add_edge(self, t1, t2, key=None, attr_dict=None, **attrs): """Add annotation to the graph between times t1 and t2 Parameters @@ -62,12 +62,8 @@ class Transcription(nx.MultiDiGraph): Example ------- >>> G = Transcription() - >>> t1 = T(1.000) - >>> t2 = T() - >>> data = {'speaker': 'John', 'speech': 'Hello world!'} - >>> G.add_annotation(t1, t2, data=data) + >>> G.add_edge(T(1.), T(), speaker='John', 'speech'='Hello world!') """ - t1 = T(t1) t2 = T(t2) @@ -75,7 +71,7 @@ class Transcription(nx.MultiDiGraph): if t1.anchored and t2.anchored: assert t1 <= t2 - self.add_edge(t1, t2, attr_dict=data) + super(Transcription, self).add_edge(t1, t2, key=key, attr_dict=attr_dict, **attrs) def relabel_drifting_nodes(self, mapping=None): """Relabel drifting nodes @@ -287,10 +283,10 @@ class Transcription(nx.MultiDiGraph): self.remove_edge(p, t2, key=key) for p in set(pred1) | set(pred2): - self.add_annotation(p, t, data=None) + self.add_edge(p, t) - self.add_annotation(t, t1, data=None) - self.add_annotation(t, t2, data=None) + self.add_edge(t, t1) + self.add_edge(t, t2) def post_align(self, t1, t2, t): """ @@ -333,10 +329,10 @@ class Transcription(nx.MultiDiGraph): self.remove_edge(t2, s, key=key) for s in set(succ1) | set(succ2): - self.add_annotation(t, s, data=None) + self.add_edge(t, s) - self.add_annotation(t1, t, data=None) - self.add_annotation(t2, t, data=None) + self.add_edge(t1, t) + self.add_edge(t2, t) # ========================================================================= From 9afde8f5df51c21ab88d68d6cb3c3a0981b6fa26 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Tue, 6 May 2014 10:59:56 +0200 Subject: [PATCH 021/458] chore(time): remove _TAnchored.from_json --- pyannote/core/time.py | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/pyannote/core/time.py b/pyannote/core/time.py index 75120a10..00f775a5 100644 --- a/pyannote/core/time.py +++ b/pyannote/core/time.py @@ -59,8 +59,6 @@ Also, if you want to refer to a specific `drifting` time, simple use: from __future__ import unicode_literals import itertools -from json import PYANNOTE_JSON_TIME - # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class _TAnchored(float): @@ -184,19 +182,6 @@ class _T(object): """Reset drifting time string generator""" _TDrifting._reset() - def from_json(self, data): - """Get time from JSON data""" - - t = data[PYANNOTE_JSON_TIME] - - if t == '$': - t = -float('infinity') - - if t == '^': - t = float('infinity') - - return self.__call__(t) - # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ __all__ = ['T', 'TStart', 'TEnd'] From 7b7e5ae08ce902d98a86996c668dc58a191d82da Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Tue, 6 May 2014 11:04:26 +0200 Subject: [PATCH 022/458] doc: CHANGELOG --- CHANGELOG.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0f400e65..73183a01 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,7 @@ +### Version 0.0.2 (2014-05-06) + + - feat: Transcription data structure (annotation graph) + ### Version 0.0.1 (2014-05-02) - first public version From e8daaf1bbc4bdbb5f56bc78c6ad7062a9893329b Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Wed, 7 May 2014 15:59:51 +0200 Subject: [PATCH 023/458] fix(notebook): do not shorten tooltip text --- pyannote/core/notebook.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pyannote/core/notebook.py b/pyannote/core/notebook.py index 2e77ce7a..6df4f3f3 100644 --- a/pyannote/core/notebook.py +++ b/pyannote/core/notebook.py @@ -224,7 +224,7 @@ def repr_annotation(annotation): if not _notebook.extent: set_notebook_crop(segment=annotation.get_timeline().extent()) - cropped = annotation.crop(_notebook.extent, mode='loose') + cropped = annotation.crop(_notebook.extent, mode='intersection') segments = [s for s, _ in cropped.itertracks()] # one color per label @@ -314,9 +314,9 @@ def _dottable(transcription): name = _remove_non_ascii(name) value = _remove_non_ascii(value) # shorten long value - value = _shorten_long_text(value) + short_value = _shorten_long_text(value) # update label and tooltip - label += label_pattern.format(name=name, value=value) + label += label_pattern.format(name=name, value=short_value) tooltip += tooltip_pattern.format(name=name, value=value) # close label table From ef845f3fd4b5d2ca9214550288510cd3b0692e04 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Wed, 7 May 2014 16:13:29 +0200 Subject: [PATCH 024/458] feat(Transcription): get edge time range --- pyannote/core/transcription.py | 64 ++++++++++++++++++++++++---------- 1 file changed, 46 insertions(+), 18 deletions(-) diff --git a/pyannote/core/transcription.py b/pyannote/core/transcription.py index 32aebcac..dc5b698e 100644 --- a/pyannote/core/transcription.py +++ b/pyannote/core/transcription.py @@ -395,7 +395,14 @@ class Transcription(nx.MultiDiGraph): yield _ # ========================================================================= - + # _anchored_{predecessors|successors} are far from optimal + # in this kind of situations + # _______ + # / \ + # --- n -- a -- f' -- + # + # TODO: we should make sure not to look after f' for another anchored node + # def _anchored_successors(self, n): """Get all first anchored successors""" @@ -430,33 +437,54 @@ class Transcription(nx.MultiDiGraph): for tt in self._anchored_predecessors(t): yield tt - def timerange(self, t): - """Infer smallest possible timerange from graph structure + def timerange(self, t1, t2, inside=False): + """Infer edge timerange from graph structure + + a -- ... -- [ t1 ] -- A -- ... -- B -- [ t2 ] -- ... -- b + + ==> [a, b] (inside=False) or [A, B] (inside=True) + + Parameters + ---------- + t1, t2 : anchored or drifting times + inside : boolean, optional Returns ------- - (left, right) tuple - left == None or right == None indicates that the current state of - the annotation graph does not allow to decide the boundary. + segment : Segment """ - t = T(t) + start = None + end = None - if t.anchored: - return (t.T, t.T) - successors = [n for n in self._anchored_successors(t)] - predecessors = [n for n in self._anchored_predecessors(t)] + if t1.anchored: + start = t1 - earlier_successor = None - if successors: - earlier_successor = min(successors) + if t2.anchored: + end = t2 - later_predecessor = None - if predecessors: - later_predecessor = max(predecessors) + if inside: - return (later_predecessor.T, earlier_successor.T) + if start is None: + s1 = [n for n in self._anchored_successors(t1)] + start = min(s1) if s1 else TStart + + if end is None: + p2 = [n for n in self._anchored_predecessors(t2)] + end = max(p2) if p2 else TEnd + + else: + + if start is None: + p1 = [n for n in self._anchored_predecessors(t1)] + start = max(p1) if p1 else TStart + + if end is None: + s2 = [n for n in self._anchored_successors(t2)] + end = max(s2) if s2 else TEnd + + return Segment(start=start, end=end) # ========================================================================= From c13fb4cc95aef0b71a5ad8d1e427ca3c3e750c79 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Wed, 7 May 2014 16:13:56 +0200 Subject: [PATCH 025/458] fix(setup): package prefix is pyannote-core --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index d503c851..57ad391c 100755 --- a/setup.py +++ b/setup.py @@ -27,7 +27,7 @@ import versioneer versioneer.versionfile_source = 'pyannote/core/_version.py' versioneer.versionfile_build = versioneer.versionfile_source versioneer.tag_prefix = '' -versioneer.parentdir_prefix = 'pyannote.core-' +versioneer.parentdir_prefix = 'pyannote-core-' from setuptools import setup, find_packages From c6f9fc8c6aee7456544e17e78c6e8a0b54ff6b09 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Wed, 7 May 2014 17:25:06 +0200 Subject: [PATCH 026/458] fix: end of outside timerange --- pyannote/core/transcription.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/pyannote/core/transcription.py b/pyannote/core/transcription.py index dc5b698e..aa12fbf4 100644 --- a/pyannote/core/transcription.py +++ b/pyannote/core/transcription.py @@ -455,6 +455,9 @@ class Transcription(nx.MultiDiGraph): """ + t1 = T(t1) + t2 = T(t2) + start = None end = None @@ -482,7 +485,7 @@ class Transcription(nx.MultiDiGraph): if end is None: s2 = [n for n in self._anchored_successors(t2)] - end = max(s2) if s2 else TEnd + end = min(s2) if s2 else TEnd return Segment(start=start, end=end) From 0e387a8fa589b38a7dd26f882f95136a9743a634 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Wed, 7 May 2014 17:25:17 +0200 Subject: [PATCH 027/458] chore: defaults to inside timerange --- pyannote/core/transcription.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyannote/core/transcription.py b/pyannote/core/transcription.py index aa12fbf4..d0f539c9 100644 --- a/pyannote/core/transcription.py +++ b/pyannote/core/transcription.py @@ -437,7 +437,7 @@ class Transcription(nx.MultiDiGraph): for tt in self._anchored_predecessors(t): yield tt - def timerange(self, t1, t2, inside=False): + def timerange(self, t1, t2, inside=True): """Infer edge timerange from graph structure a -- ... -- [ t1 ] -- A -- ... -- B -- [ t2 ] -- ... -- b From f15c5111e94b9c8340a0bbf639fe7e1b7fdb6752 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Wed, 7 May 2014 17:27:18 +0200 Subject: [PATCH 028/458] chore: PYANNOTE_JSON_TRANSCRIPTION is 'T' --- pyannote/core/json.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/pyannote/core/json.py b/pyannote/core/json.py index 8f458f4d..81de57dd 100644 --- a/pyannote/core/json.py +++ b/pyannote/core/json.py @@ -30,9 +30,7 @@ import simplejson as json PYANNOTE_JSON_SEGMENT = 'S' PYANNOTE_JSON_TIMELINE = 'L' PYANNOTE_JSON_ANNOTATION = 'A' -PYANNOTE_JSON_TRANSCRIPTION = 'G' - - +PYANNOTE_JSON_TRANSCRIPTION = 'T' def object_hook(d): """ From 34177a0acb1bcc8089a3ff3e93833fe01d57b8f9 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Tue, 13 May 2014 13:36:55 +0200 Subject: [PATCH 029/458] feat(LabelMatrix): IPython HTML display --- pyannote/core/matrix.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pyannote/core/matrix.py b/pyannote/core/matrix.py index 63bc3fd6..f6d14cea 100755 --- a/pyannote/core/matrix.py +++ b/pyannote/core/matrix.py @@ -65,6 +65,7 @@ class LabelMatrix(object): val = self.df.at[row, col] if not np.isnan(val): yield row, col, val + def iter_values(self): for row in self.get_rows(): for col in self.get_columns(): @@ -181,6 +182,10 @@ class LabelMatrix(object): def __str__(self): return str(self.df) + def _repr_html_(self): + return self.df._repr_html_() + + def get_cooccurrence_matrix(R, C): rows = R.labels() From 4cab92fe3fe04449c212a9b21fdcc41a74d6dea6 Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Tue, 13 May 2014 13:38:24 +0200 Subject: [PATCH 030/458] improve: 10x faster "get_cooccurrence_matrix" --- pyannote/core/matrix.py | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/pyannote/core/matrix.py b/pyannote/core/matrix.py index f6d14cea..acac177b 100755 --- a/pyannote/core/matrix.py +++ b/pyannote/core/matrix.py @@ -188,20 +188,22 @@ class LabelMatrix(object): def get_cooccurrence_matrix(R, C): + # initialize label matrix with zeros rows = R.labels() cols = C.labels() - nRows = len(rows) - nCols = len(cols) + K = np.zeros((len(rows), len(cols)), dtype=np.float) + M = LabelMatrix(data=K, rows=rows, columns=cols) + + # loop on intersecting tracks + for (r_segment, r_track), (c_segment, c_track) in R.co_iter(C): + # increment + r_label = R[r_segment, r_track] + c_label = C[c_segment, c_track] + duration = (r_segment & c_segment).duration + M[r_label, c_label] += duration - K = np.zeros((nRows, nCols), dtype=np.float) - for r, row in enumerate(rows): - row_coverage = R.label_coverage(row) - for c, col in enumerate(cols): - col_coverage = C.label_coverage(col) - coverage = row_coverage.crop(col_coverage, mode='intersection') - K[r, c] = coverage.duration() + return M - return LabelMatrix(data=K, rows=rows, columns=cols) def get_tfidf_matrix(words, documents, idf=True, log=False): From 70bd7bfc17ae0567141167cc757644f7b4032c1c Mon Sep 17 00:00:00 2001 From: Herve Bredin Date: Tue, 13 May 2014 13:49:31 +0200 Subject: [PATCH 031/458] docs: add convention for commit messages --- COMMIT_MESSAGES.md | 120 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 120 insertions(+) create mode 100644 COMMIT_MESSAGES.md diff --git a/COMMIT_MESSAGES.md b/COMMIT_MESSAGES.md new file mode 100644 index 00000000..da38b524 --- /dev/null +++ b/COMMIT_MESSAGES.md @@ -0,0 +1,120 @@ +# Commit Message Conventions + +> This page defines a convention for commit messages for [pyannote](http://github.com/pyannote) related projects. +> +> All commits pushed to the [pyannote](https://github.com/pyannote) repositories must conform to that convention. + +The contens of this page are partly based on the [angular commit messages document](https://docs.google.com/document/d/1QrDFcIiPjSLDn3EL15IJygNPiHORgU1_OOAqWjiDU5Y/edit?pli=1). + + +## Purpose + +The commit message is what is what describes your contribution. +Its purpose must therefore be to document what a commit contributes to a project. + +Its head line __should__ be as meaningful as possible because it is always +seen along with other commit messages. + +Its body __should__ provide information to comprehend the commit for people +who care. + +Its footer __may__ contain references to external artifacts +(issues it solves, related commits) as well as breaking change notes. + +This applies to __all kind of projects__. + + +## Format + +#### Short form (only subject line) + + (): + +#### Long form (with body) + + (): + + + + + + + +