Docstoc

CreAtIvE

Document Sample
CreAtIvE Powered By Docstoc
					THE BIOCREATIVE METASERVER
        PLATFORM
                   BIO
                  CreAtIvE

              Meta                   Server

           SMBM ’08, Turku, Finland
 Florian Leitner, Martin Krallinger, and Alfonso Valencia
           Structural Biology and Biocomputing Programme
            National Cancer Research Centre, CNIO, Spain
2
                                                          INTRODUCTION
Overview
    Background                                  Analysis
     BioCreative                                  Statistics
     Distributed services                         Advantages
    Introduction                                Future Development
     BCMS Overview                                BCMS 1.0
     Usage Example                                Structured Digital
                                                  Abstracts (SDAs)
    Implementation
     Architecture
     Specifications
    The BCMS Platform       http://bcms.bioinfo.cnio.es    Florian Leitner, CNIO
                                                                  BACKGROUND
The BioCreative community effort
Critical Assessment
of Information
Extraction Systems in
Biology
BioCreative I
 
          2003-2004           BioCreative II
 
              2006-2007
   27 teams, Granada, Spain                        44 teams, Madrid, Spain
Hirschman et al., Overview of                 Krallinger M et al., Evalutation of
BioCreAtIvE: critical assessment of           text-mining systems in Biology: overview
information extraction for biology, BMC       of the Second BioCreative community
Bioinformatics (2005) Vol. 6 Suppl. 1         challenge, Genome Biology (2008) 9:S1
     The BCMS Platform         http://bcms.bioinfo.cnio.es         Florian Leitner, CNIO
                                                       BACKGROUND
Gene mention & normalization tasks
GM tagging gene         Ontologies, Lists             GN identification
mentions in 5,000           NLP
                                                      of 785 human
[MEDLINE]                                             EntrezGene IDs in
sentences                                             262 MEDLINE
(ubiquituous)                                 data    abstracts
                                mentions      coll.
  highest F-score:                                    (ubiquituous)
  0.872                            &                     highest F-score:
  combined F-                   mappings                 0.81
                       Abstracts,
  score: 0.907         Fulltext
                                                         combined F-
  main methods:                                          score: 0.92
  CRF and SVM            "BioRepositories"               method:
                                                         dictionary lookup
   The BCMS Platform    http://bcms.bioinfo.cnio.es     Florian Leitner, CNIO
                                                    BACKGROUND
Protein-protein interaction (PPI) task
                                                    677 abstracts for
                                                    PPI classification
                                                    (IAS, 0.780 F),
                                                    358 full-texts for
           IPS                               IMS     pair extraction
 IAS                                                 (IPS, 0.289 F),
                                              ISS
                                                     interact. method
                                                     extraction
                                                     (IMS, 0.652 F),
                                                     passage retrieval
                                                     (ISS, 0.191
                                                     precision)
  The BCMS Platform   http://bcms.bioinfo.cnio.es   Florian Leitner, CNIO
6
                                                       BACKGROUND
What is a meta-server?
    “A central broker providing a collated view for
    dispersed web resources.”

     unified view on multiple resources

     easy data comparison

     standardized access to different repositories/systems

     generation of a consensus

    The BCMS Platform    http://bcms.bioinfo.cnio.es   Florian Leitner, CNIO
7
                                                         BACKGROUND
Distributed services in biology




Structure Prediction    Function Prediction            Sequence Annotat.
   3D-Jury                JAFA                           BioDAS
   PCons                  BioBank
                                                       Stein, L, Creating a
   GeneSilico                                          bioinformatics nation,
   Folding@home                                        Nature (2002) vol. 417
                                                       (6885) pp. 119-20
    The BCMS Platform    http://bcms.bioinfo.cnio.es      Florian Leitner, CNIO
8
                                                                                           INTRODUCTION
The MetaServer at a glance
    Meta Server                                           Annotation Servers
                                                                                            Prototype
                                                                                            with the BC II
                                                 XML-     Annotations
                                 Annotation      RPC
                                  Request

                                                                                            collection of
                                                                                            approx. 22,800
        Text &
      Annotations
                                                                                   Text
                                                                                 Request    MEDLINE
                                                                                            abstracts
                                                FTP                              (SOAP)
            HTTP/XML or
                                              (weekly)
             XML-RPC                                                       SOAP or
                                                                            FTP
               Text Annotation                            Text
                  Request

            Web Browser
                                  Users
                                                                          Text
                                                                                            12 participants
      Tab     Tab       Tab


                    X                                                     PubMed
                                         Text Annotation Types
                                         ! Gene Mentions
                                                                            DB              4 annotation
                                         ! Gene Normalization
                                         ! Taxa
                                                                         MEDLINE            types
                                         ! Protein-Protein Interaction   PubMed
      The BCMS Platform                             http://bcms.bioinfo.cnio.es             Florian Leitner, CNIO
9
                                                      INTRODUCTION
Query example
    Query:

     brca2 AND rad51 OR
     dmc1 OR brca1 OR rad23a

     All known interaction
     partners of brca2

     Using a “Gene/Protein
     Mentions” query.
    The BCMS Platform   http://bcms.bioinfo.cnio.es    Florian Leitner, CNIO
10
                                                       INTRODUCTION
Result view




     The BCMS Platform   http://bcms.bioinfo.cnio.es    Florian Leitner, CNIO
11
                                                       INTRODUCTION
Annotation view




     The BCMS Platform   http://bcms.bioinfo.cnio.es    Florian Leitner, CNIO
12
                                                       IMPLEMENTATION
GM result display




     The BCMS Platform   http://bcms.bioinfo.cnio.es     Florian Leitner, CNIO
13
                                                       IMPLEMENTATION
GN result display




     The BCMS Platform   http://bcms.bioinfo.cnio.es     Florian Leitner, CNIO
14
                                                       IMPLEMENTATION
Taxa and PPI result display




     The BCMS Platform   http://bcms.bioinfo.cnio.es     Florian Leitner, CNIO
15
                                                       IMPLEMENTATION
Mention to normalization mapping




     The BCMS Platform   http://bcms.bioinfo.cnio.es     Florian Leitner, CNIO
16
                                                       IMPLEMENTATION
Comparison to “traditional” views




      PubMed                    BCMS                         HubMed
     The BCMS Platform   http://bcms.bioinfo.cnio.es     Florian Leitner, CNIO
17
                                                                                IMPLEMENTATION
The MetaServer architecture
     User Query                                   User Query                                                 MetaServer
                                                                                                     Annotation Pipeline
      Homepage                              MEDLINE        MetaServer       Gene/Protein      Gene/Protein          NCBI Taxa
                              Text
                                             (local)          DB              Names               IDs                 IDs

     Query Results
                                                                                                             Annotation Servers

      Result view
                                                 Query Results




      XML-RPC
                                                                                 XML-RPC
                                                             Request
                                                            Annotations
                                                             Validate


     Annotation
                                                            Annotations
                            MEDLINE                                                var. Web
                                               AJAX
                                                            Names and              Services
                            Abstract                         Mappings


     Results
                                               Annotation Result
                                                                                                             Public Databases

      Annotation          Gene/Protein    Gene/Protein       Taxa          Interaction


      view
                          Normalization    Mentions      Classification    Classification




      The BCMS Platform       http://bcms.bioinfo.cnio.es                                  Florian Leitner, CNIO
18
                                                        IMPLEMENTATION
The MetaServer user interfaces
     Web interface: DB queries using a web browser
      abstract text contents (all), mentions, gene/protein mappings,
      taxonomic IDs (for existing annotations)
     XML-RPC interface: PMID-centric queries
     Annotations.getAnnotations
      all results for one PMID
     Annotations.getAnnotation
      results from one AnnotationServer for one PMID
     Various meta-data (servers, teams, etc.)
     The BCMS Platform    http://bcms.bioinfo.cnio.es     Florian Leitner, CNIO
19
                                                        IMPLEMENTATION
Using the XML-RPC interface
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import sys
import xmlrpclib

url = "http://bcms.bioinfo.cnio.es/xmlrpc/"
method = sys.argv[1]
arguments = sys.argv[2:]
server = xmlrpclib.Server(url, encoding="UTF-8",
                          verbose=True)
cmd = "server." + method + "(" + ", ".join(arguments) + ")"

print >> sys.stderr, "command:", cmd

result = eval(cmd) # server.Annotations.getAnnotations(1234567)

print result

     The BCMS Platform    http://bcms.bioinfo.cnio.es     Florian Leitner, CNIO
20
                                                        IMPLEMENTATION
Implementing Annotation Servers
     Only one method needs to be implemented
     mapping the XML-RPC service to the IE/NLP
     system, also available as a Java example.
     Main caveats:
      difference between encoding/unicode/UTF-8
      using the correct encoding to report the offsets for GMs
      using the correct identifiers to report GNs
      normalization of confidence values to the ]0..1] range
     The BCMS Platform    http://bcms.bioinfo.cnio.es     Florian Leitner, CNIO
21
                                                         IMPLEMENTATION
Internal communications: XML-RPC
     Requests: XML-RPC call using the PMID as
     parameter
      Annotator.getAnnotation(int pmid)
      Why not REST? Extension in work: full-text!
     Response data format:
      struct{
      
   “annotation_type”: array[
      
   
 struct{
      
   
 
 “field_name”: <value - int,str,bool,double>, …
      
   
 }, …
      
   ], …
      }

     The BCMS Platform     http://bcms.bioinfo.cnio.es     Florian Leitner, CNIO
22
                                                        IMPLEMENTATION
Internal communications: XML-RPC
     Error communication
     Low level errors (protocols) handled by server and
     client libraries internally (no specification needed)
     XML-RPC fault communications:
      1 Service Not Available – the annotation system is offline
      2 Service Exception – the annotation system failed
      3 Type Exception – a parameter is of the wrong type
      4 Value Exception – a parameter is in the wrong value range
      5 XML Syntax Exception – invalid XML
      6 XML Parser Exception – the XML parser failed
     The BCMS Platform    http://bcms.bioinfo.cnio.es     Florian Leitner, CNIO
23
                                                        IMPLEMENTATION
BCMS specifications




WDF                      Database                       MetaServer
Django SVN +             Postgres 8.2                   Python 2.5
jQuery latest            (indexing)                     (threading,
                                                        xmlrpclib)
     The BCMS Platform    http://bcms.bioinfo.cnio.es     Florian Leitner, CNIO
24
                                                                             ANALYSIS
GM inter-server agreement
                      1 13 2            5       6
                                                             100 %
                 1
               13
                 2
                 5
                 6                                           20 %
                     based on character overlap

     The BCMS Platform         http://bcms.bioinfo.cnio.es          Florian Leitner, CNIO
25
                                                                                                    ANALYSIS
Gene Normalization comparison



                                                           Agreement
                                                  1              2               3


     UniProt           10523       10523       10523                   EntrezGene    21885       21885       21885

     Agreement                 1           2           3               Agreement             1           2           3
     Documents          22647         414             32               Documents      18393         307         174
     Overlap            10494         226             13               Overlap        17903         291         167
     TP                  9768         208             13               TP             31778         466         221
     FP                 68910         262             11               FP             39084         318          84
     FN                 16334         292             19               FN            423041        7543        6079



          The BCMS Platform                    http://bcms.bioinfo.cnio.es             Florian Leitner, CNIO
26
                                                                 ANALYSIS
Advantages through the platform
     One interface for retrieval, annotation,
     visualization, and direct comparison of
     text and annotations/classifications
     Unified access to several text mining tools
     Unified result structure (for developers and
     text-miners)
     Scalable ("unlimited" participants) and
     extensible (annotation types)
      The BCMS Platform   http://bcms.bioinfo.cnio.es   Florian Leitner, CNIO
27
                                              FUTURE DEVELOPMENT
Annotation data expansion
     New annotation types
      chemical compounds, functional annotations, …

     Extending annotation to free/full text
      full MEDLINE including meta-data (MeSH, etc.)

     New XML-RPC method: Retrieval of specific
     annotation types
      The BCMS Platform   http://bcms.bioinfo.cnio.es   Florian Leitner, CNIO
28
                                                                                                                                                                                                                                                                              FUTURE DEVELOPMENT
Interface updates
                                 URLs {urls.py}                                    Views {views.py}/Templates                                                                                                                          Models {models.py}


                                               Page Not Found                404.html                                   Server Error                   500.html
                                                                                                                                                                                                                                                                      Name




User help                                                                                                                                                                                                                                                                                                                        Personalization
                                                Display 404 erros.                                                        Display 500 erors.                                                                                                            staticMethod
                                                Main                                                                      Main
                                                                                                                                                                                                                                                        inheritedMethod
                                                                                                                                                                                                                                                        method
                                                                                                                                                                                                                                                        field_name             Relational
                                                                        Base                                   base.html                                                                                                                                unique_filed           data_type

                                                                                                                                                               ServerConf
                                                                            LinkBar:
                                                                            Query, Submit Text, Webservices, Server Stats,
                                                                            Login/Register OR Configuration, Help
                                                                            defblock Main
                                                                            defblock SideBarLeft
                                                                            defblock SideBarRight
                                                                            defblock Footer
                                                                                                                                                  user                  ForeignKey                                                                                                                           User
                                                                                                                                                  server                ForeignKey
                                                                                                                                                                                                                                                                                               get_absolute_url
                                                                                                                                                  show                  Boolean
                                        /                                                   views.main()                                          min_confidence         Float
                                                                        Query                                  search.html
                                                                                                                                                                                                                                                                                               name                 String
                                                                                     Base             autocompleter
                                                                                                                                                                                                                                                                                               email                EmailField
                                                                            "Homepage", query interface.




                                                                                                                                                                                                                                                                                                                                 with collective
                                                                            Main: QueryForm {forms.py}                help                                                                                                                                                                     password             String
                                                                            SideBarRight: bookmarks
                                                                                                                                                                                                                                                                                               min_confidence        Float
                                                                                                                                                                                                                                                                        Server
                                                                                                                                                                                                                                                                                               activated            Boolean
                                                                                                                                                                                                                                                           sendMail
                                                                                                        UserBookmarks                                          Bookmarks                                                                                   is<STATE>
                                                                                                                                                                                                                                                           set<STATE>
                                                                                                                                                                                                                                                           getWebserviceUrl
                               /result/<cache_id>/                               views.query(cache_id)
                                                                        Results                                result.html                                                                                                                                 team                   ForeignKey                 Team
                                                                                    Query                         PubMed                                                                                                                                   url                    String
                                                                                                                                                                                                                                                                                               sendMail
                                                                            Query result view.                                                    user                  ForeignKey                                                                         timeout                Integer      get_absolute_url
                                                                            Main: Query, Results               help                               content_type          ForeignKey     GenericForeignRelation                                              status                 String
                                                                            SideBarLeft: ResultNavigator/Paginator
                                                                            SidebarRight: Sorting options                                         object_id             Integer                                                                            admin_mail             String       name                 Text
                                                                                                                                                                                          Fulltext
                                                                                                                                                  content_object        GenericFK                                                                          mentions               Boolean      description          Text




Full MEDLINE
                                                                                                                                                                                       Medline
                                                                                                                                                                                                                                                           normalizations         Boolean      contact_name         String
                                                                                                    Medline          Fulltext
                                                                                                                                                                                                                                                           taxons                 Boolean      contact_mail         EmailField

                              /result/medline/<id>/                                     views.medline(id)                                                        Synonym                                                                                   interactions           Boolean      homepage             URLField
                              /result/fulltext/<id>/                                     views.fulltext(id)                                                                                                                                                fulltext               Boolean
                                                                                                           annotation.html                        save
                                                                        Annotations




                                                                                                                                                                                                                                                                                                                                 intelligence
                                                                                   Results              Sequence DB
                                                                            Text annotation view.
                                                                                                                                                  identifier             ForeignKey                                   Identifier
                                                                            Main: title, abstract [, body]       sidebar
                                                                            SideBarLeft: Annotation Results                                       name                  String
                                                                            SideBarRight:                                                                                                                save
                                                                              Server Controls, Gene/Protein
                                                                              Links, [MEDLINE annotations,            help                                                                               get_absolute_url
                                                                              bookmarks]
                                                                            Footer: Servers

                                                                                        User        Medline           Fulltext                                                                           database               ForeignKey                                                                 Database
                                                                                                                                                                                                         accession              String
                                    /servers/                                            views.servers()                                                                                                                                                                                       get_absoulte_url
                                                                                                                                                                                                         name                   String
                                                                        Server Stats                           server.html
                                                                                                                                                                                                         confirmed               Timestamp
                                                                                     Base                             help
                                                                            Overview of annotation servers; statistics.
                                                                                                                                                                                                                                                                                               name                 String
                                                                            Main: Annotation statistics {statistics.py}




including meta-
                                                                            SideBarLeft/SideBarRight: ServerTable
                                                                            - Server ID (left/right)                                                                                                                                                                                           is_sequence_db       Boolean
                                                                            - Team Name (left)
                                                                            - Status (right)                                                                                                                                                                                                   homepage             URLField
                                                                            - Annotation Types (right)
                                                                                                                                                                                                                                                                                               link_url             URLField
                                                                                            Server        Team           Result
                                                                                                                                                             Normalization
                              /servers/<team_id>/                           generic.list_detail.object_detail()
                                                                        <Team>                                 team.html

                                                                               Server Stats
                                                                                                                                                                                                                                                                      HelpMinor
                                                                                                                   E-mail
                                                                            Detail view of a team.
                                                                            Main:                                                                 result                ForeignKey




                                                                                                                                                                                                                                                                                                                                   bookmarking
                                                                            - Name                         Homepage
                                                                            - Contact                                                             taxon [identifier]     ForeignKey
                                                                            - Servers
                                                                            - Description                                                         identifier             ForeignKey                                                                         major                 ForeignKey               HelpMajor
                                                                                                                                                  confidence             Float                                                                              title                 String
                                                                                                        Server            Team
                                                                                                                                                                                                                                                           descripton            String
                                                                                                                                                                                                                                                           image                 ImageField
                                     /help/                                                 views.help()
                                                                        Help                                    help.html                                                                                                                                                                      title                String

                                                                                     Base             autocompleter                                               Taxon                                                                                                                        description          String




data
                                                                            Help base view.                                                                                                                                                                                                    image                ImageField
                                                                            Main: TOC




                                                                                                                                                  result                ForeignKey                                    Result
                                                                                                                   HelpMajor                      identifier             ForeignKey
                                                                                                                                                  confidence             Float
                               /help/<major_id>/                                  views.help(major_id)
                                                                        <Topic>                                 topic.html
                                                                                                                                                                                                         server                 ForeignKey
                                                                                        Help
                                                                                                                                                                                                         content_type           ForeignKey   GenericForeignRelation
                                                                            Help topic view.
                                                                            Main: title, content                                                               Interaction                               object_id              Integer
                                                                            SideBarLeft: TOC
                                                                            SideBarRight: related topics                                                                                                 content_object         GenericFK                                                                  Fulltext
                                                                                                                                                                                               Medline                                       Fulltext
                                                                                                                                                                                                         received_at            Timestamp

                                                                                                                                                                                                                                                                          join                 save




                                                                                                                                                                                                                                                                                                                                   filtering
                                                                                                                    HelpMajor                                                                                                                                                                  hasInteraction
                                                                                                                                                  result                1to1Field                                                                          fulltext              ForeignKey    resultServerSet
                                                                                                                                                                                                                   SectionType                             section_type          ForeignKey
                                                                                                                                                                                                                                                                                               missingServerSet
                                                                                                                                                  has_interaction       Boolean
                               /help/webservices/                                  views.webservices()                                                                                                                                                                                         get_absolute_url
                                                                        Webservices                       webservice.html                         confidence             Float                                                                              section               ForeignKey
                                                                                                                                                                                                                                                                                               date_created         Timestamp
                                                                                     Base
                                                                                                                                                                                                                                                                                               user                 ForeignKey
                                                                            Web services help.
                                                                                                                                                                                                                                                                                               bookmarks            GenericRel
                                                                            Main:                                                                                                                        section                String
                                                                            - URLs                                                                                                                                                                                                             results              GenericRel
                                                                            - API
                                                                                                                                                                                                         order                  Integer
                                                                            -Description
                                                                            SideBarLeft: page quicklinks
                                                                                                                                                                  Mention


                                                                                                                                                                                                                     Section
                                     /users/                                                views.login()                                         result                ForeignKey
                                                                        Login/Register                         login.html                                                                                save
                                                                                                                                                  offset                Integer
                                                                                     Base                                                                                                                hasInteraction
                                                                                                                     help                                                                                resultServerSet
                                                                                                                                                  section               String
                                                                            User login or registration form.                                                                                             missingServerSet
                                                                                                                                                  mention               Text




Free/full text
                                                                            Main: LoginForm & RegistrationForm {forms.py}                                                                                get_absolute_url
                                                                            - Username
                                                                                                                                                  confidence             Float
                                                                                                                                                                                                                                                                          join
                                                                            - E-Mail                                                                                                                     md5sum                 String
                                                                            - Password                                                                                                                                                                     article               ForeignKey
                                                                                                                                                  document_rank         Float
                                                                                                                                                                                                         content                Text
                                                                                                                                                                                                                                                           author                ForeignKey                 Author
                                                                                                                            User


                               /users/<user_id>/                                         views.user(id)




                                                                                                                                                                                                                                                                                                                                   weighting
                                                                        Configuration                           user.html
                                                                                                                                                                                                                                                                                               initials             String
                                                                               Login/Register                        help                                                                                                join
                                                                                                                                                                                                                                                                                               fore_name            String
                                                                                     Base                                                                                                                article                ForeignKey
                                                                                                                                                                                                                                                                                               last_name            String
                                                                            User configuration.
                                                                                                                                                                                                         identifier              ForeignKey
                                                                            Main: PersonalizationForm {forms.py}                                                                                                                                                          join                 suffix                String
                                                                            - Min. global conf.
                                                                            - Server selection & min conf.
                                                                            - Manage bookmarks                                                                                                                                                             article                ForeignKey
                                                                            - Change password, email
                                                                                                                                                                                                                                                           collective             ForeignKey              Collective
                                                                                                                            User
                                                                                                                                                                  Journal
                                    /submit/                                             views.submit()
                                                                        Submit Text                            fulltext.html

                                                                                     Base                            help                                                                                                                                                                      name                 String
                                                                            Request annotation of text.
                                                                                                                                                                                                                                                                          join
                                                                            Main: RequestForm {forms.py}                                          article               1to1Field                                     Article                              article                ForeignKey
                                                                            - Title
                                                                            - Abstract                                                            title                 Text                                                                               publication_type       ForeignKey       PublicationType
                                                                            - Body [optional]
                                                                                                                                                  issn                  String
                                                                                                                                                  issn_type             String

                                                                                                                                                  volume                String                           medline                1to1Field
                              /rest/medline/<id>/                             model_resource.Collection()                                         issue                 String                           title                  String                                                         qualifier             String
                                                                                                                                                  pub_date              Timestamp                        abstract               String
                         /rest/medline/<id>/<server_id>/                     restapi.medline(id, server_id)
                                                                                                                                                                                                         copyright              String

                               /rest/fulltext/<id>/                           model_resource.Collection()                                                                                                author_complete        Boolean




                                                                                                                                                                                                                                                                                                                                 “personalized
                                                                                                                                                                                                         has_identifier          Boolean
                         /rest/fulltext/<id>/<server_id>/                      restapi.fulltext(id, server_id)                                                                                           has_author             Boolean
                                                                                                                                                                                                                                                                          join




XML-result
                                                                                                                                                                                                         has_collective         Boolean
                                                                                                                                                                                                                                                           medline               ForeignKey
                           /rest/medline/<id>/GM_set/                         model_resource.Collection()                                                                                                has_pub*_type          Boolean
                                                                                                                                                                                                                                                           chemical              ForeignKey                Chemical
                                                                                                                                                                                                         article_date           Timestamp
                           /rest/medline/<id>/GN_set/                         model_resource.Collection()

                           /rest/medline/<id>/TX_set/                         model_resource.Collection()                                                        Comment

                                                                                                                                                                                                                                                                                               substance            Text
                           /rest/medline/<id>/PPI_set/                        model_resource.Collection()
                                                                                                                                                                                                                                                                                               registry_number      String
                                                                                                                                                                                                                                                                          join
                           /rest/fulltext/<id>/GM_set/                        model_resource.Collection()                                             medline             ForeignKey                                 Medline                               medline                ForeignKey
                                                                                                                                                      qualifier            String                                                                           gene_symbol            ForeignKey              GeneSymbol
                           /rest/fulltext/<id>/GN_set/                        model_resource.Collection()                                                                                                hasInteraction
                                                                                                                                                      source              String
                                                                                                                                                                                                         resultServerSet
                           /rest/fulltext/<id>/TX_set/                        model_resource.Collection()                                             pmid [medline]      ForeignKey                     missingServerSet
                                                                                                                                                                                                         get_absolute_url
                                                                                                                                                      note                Text

                           /rest/fulltext/<id>/PPI_set/                       model_resource.Collection()                                                                                                date_created           Timestamp                                                      symbol               Text
                                                                                                                                                                                                                                                                          join
                                                                                                                                                                                                         date_revised           Timestamp




                                                                                                                                                                                                                                                                                                                                 text-mining”
                                                                                                                                                                                                                                                           medline               ForeignKey
                                    /xmlrpc/                                                xmlrpc.handle()                                                                                              num_references         Integer
                                                                                                                                                                                                                                                           mesh_descriptor       ForeignKey        MeshDescriptor




download
                                                                                                                                                                                                         journal_title          Text
                                                                            Database           Medline          Fulltext           Result
                                                                                                                                                                                                         has_chemical           Boolean
                                                                                                                                                                                                         has_gene_symb*         Boolean
                                                                                                                                                                                                         has_mesh_desc*         Boolean
                         /help/<major_id>/<minor_id>/                         views.help(major_id, minor_id)                                                                                                                                                                                   name                 Text
                                                                                                                                                                                                         bookmarks              GenericRel                                join
                                                                                                                                                                                                                                                                                               major                Boolean
                                                                                                     HelpMajor           HelpMinor                                                                       results                GenericRel                 medline                ForeignKey
                                                                                                                                                                                                                                                           mesh_descriptor        ForeignKey

                                                                                                                                                                                                                                                           mesh_qualifier          ForeignKey           MeshQualifier
                            /autocompleter/<model>/                            views.autocomplete(model)

                                                                            HelpMajor          Medline          Fulltext           Result

                                                                                                                                                                                                                                                                                               name                 Text

                             /sidebar/<model>/<id>                               views.sidebar(model, id)                                                                                                                                                                                      major                Boolean


                                                                            Database           Medline          Fulltext           Result

                                                                Exception                                                                 Exception




     The BCMS Platform   http://bcms.bioinfo.cnio.es                                                                                                                                                                                                                                                                              Florian Leitner, CNIO
29
                                                                            FUTURE DEVELOPMENT
Architecture remodeling
                                  Full
                                  text Med
                                                                           scalable
     MEDLINE                           line



      NLM / NCBI                 Users

                 4                       1

                                              LAN
                                                    WWW                    extensible
 MEDLINE




                                                                           dedicated servers
                                                           TAR XML-RPC/
     Fulltext                                                REST API
                                                    1
 Annotations                                              External
 Data Repository             2   Webserver                  Services




                                                                MEDLINE

                                                                 MS XML-
                                                                           load balancing
                                                    3            RPC API

                Indexing                                  Annotation
                    Engine       Metaserver                  Servers

                                                                           powerful indexing
            The BCMS Platform                           http://bcms.bioinfo.cnio.es   Florian Leitner, CNIO
30
                                              FUTURE DEVELOPMENT
The FEBS Letter experiment: SDAs
Linking entries in protein
interaction database to structured
text:The FEBS Letters experiment,
Ceol, A. et al., FEBS Lett.
(2008) vol. 582


A text-mining perspective on the
requirements for electronically
annotated abstracts, Leitner, F.
and Valencia, A., FEBS
Letters (2008) vol. 582
     The BCMS Platform    http://bcms.bioinfo.cnio.es   Florian Leitner, CNIO
30
                                                FUTURE DEVELOPMENT
The FEBS Letter experiment: SDAs
Linking entries in protein                                                    Authors

interaction database to structured                                            created by

text:The FEBS Letters experiment,
Ceol, A. et al., FEBS Lett.




                                             h




                                                                                                                 Jou
                                           earc
(2008) vol. 582




                                                                                                                     rn
                                                  contributing                                     accessible




                                          Res




                                                                                                                    als
                                                       to                                           through
                                                                             Structured
                                                                              Digital
                                                                             Abstracts

A text-mining perspective on the
requirements for electronically                               facilitating                 enriching
annotated abstracts, Leitner, F.                     Te
                                                        xtM                                              as
                                                                                                            es
                                                                                                       ab
and Valencia, A., FEBS
                                                            in                                      t
                                                                 in                              Da
                                                                   g

Letters (2008) vol. 582
     The BCMS Platform    http://bcms.bioinfo.cnio.es                         Florian Leitner, CNIO
                                                                 NOTE
BioCreative II.5
 Comparing human (author) annotations to fully
 automated results: the FEBS Letters
 experiment - using the BioCreative MetaServer
 Call for participation in the MetaServer
  “free” interface
  “free” evaluation
  “free” infrastructure
  straightforward, direct tool comparison
  high visibility through BioCreative
  The BCMS Platform   http://bcms.bioinfo.cnio.es   Florian Leitner, CNIO
32
                                                                                      FUTURE DEVELOPMENT
SDAs and the BCMS
                                                   Text Annotation
                                                                                                                raw
                                                     XML-RPC                                                  manuscript

     Fulltext
                                                  Journal                                                                                   SDA complete?
                                           1

 Annotations
                       2                          Webserver                                                   edit text and
                                                                                                                  SDA
                                                                                                                                            NO

                                        LAN WWW                                                                                             YES
                                                                                                    Author
                                                          MEDLINE                                                                   submit to                 submit to
                                           3
 Data Repository           Metaserver                     MS XML-
                                                                                                                                     Editor                    BCMS

                                                          RPC API

                                                  Annotation                                                  manuscript
                                                                                                              [with SDA]
                                                                                                                                                             manuscript
                                                                                                                                                               [raw]




                                                                                    agreement on
                                                                                     publication
                                                     Servers
                                                                                                                                                             generate




                                                                     agreement on
                                                                      annotations
                                                                                                                                                            annotations

                                                                                                    BCMS
                                                                                                   Platform                        manuscript




       assisting author-based
                                                                                                                                   [with SDA]



                                                                                                                                    reviewing
                                                                                                                                     process




       curation
                                                                                                                                                        manuscript with
                                                                                                                                  NO        YES             SDA
                                                                                                    Editor

                                                                                                                              text && SDA
                                                                                                                              accepted?                     hyperlinked




       integration natural to                                                                      Database
                                                                                                                                                        annotation data
                                                                                                                                                          from SDA




       the BCMS design
                                                                                                    Curator




            The BCMS Platform                  http://bcms.bioinfo.cnio.es                                             Florian Leitner, CNIO
33
                                                        ACKNOWLEDGEMENTS
Participants - Annotation Servers
                    Group                                GM       GN   PPI Taxa conf. state
           Baumgartner WA, Hunter L                       ✓       ✓    ✓                  online
         Haddow B, Matthews M, Wang X                     ✓            ✓             ✓    offline
              Hakenberg J, Plake C                                ✓    ✓      ✓      ✓    online
         Hoffmann R,Valencia A, Sander C                          ✓    ✓      ✓      ✓    online
            Kim S, Shin SY, Zhang BT                                   ✓             ✓    online
                Kuo CJ, Hsu CN                            ✓                               online
              Lau WW, Johnson CA                                  ✓                  ✓    online
            Luong TB, Krauthammer M                               ✓                  ✓    online
           Özgür A, Erkan G, Radev DR                                  ✓             ✓    offline
                 Ruch P, Ehrler F                         ✓       ✓    ✓      ✓      ✓    online
           Sætre R,Yoshida K, Chen YH                     ✓       ✓    ✓             ✓    offline
               Tsai RTH, Hung HC                          ✓                          ✓    online

     The BCMS Platform              http://bcms.bioinfo.cnio.es        Florian Leitner, CNIO
34
                                             ACKNOWLEDGEMENTS
Thank you!
Alfonso Valencia
Martin Krallinger
José-Manuel Rodríguez Carrasco

Jörg Hakenberg
Bob Carpenter
All participants providing Annotation Servers!
Introducing Meta-Services for Biomedical Information
Extraction, Leitner, F et al., Genome Biology (2008) 9:S1
     fleitner@cnio.es     http://bcms.bioinfo.cnio.es   Florian Leitner, CNIO

				
DOCUMENT INFO
Shared By:
Categories:
Stats:
views:22
posted:5/18/2011
language:Icelandic
pages:35