シンギュラリティ実験ノート

購入した1000ドルPCで何がどこまでできるのか実験した記録です。

AIの賢さを試すユニークな方法

AIの賢さを測るベンチマークとしてカブトムシのAAをLLMに書かせるというユニークな手法を見かけた。

今井翔太氏考案の定性評価法KABUTOMUSHI-benchである。面白そうなのでローカルAIで試してみた。

gemma-4-26B-A4B

まずgemma-4-26B-A4Bで試してみた。

USER: AA(Ascii Art)でカブトムシを描いて

ASSISTANT: AA(アスキーアート)でカブトムシを描きました。

              ____
           /`    ` \
          /  / \  \ \
         |  | @ |  | |
          \  \ /  / /
           \ `---' /
      ______|     |______
     /      \_____/      \
    /   /|           |\   \
   |   | |           | |   |
    \   \|           |/   /
     \___|           |___/
         |   _____   |
         |  /     \  |
         | |       | |
         |  \_____/  |
         |           |
         \___________/
            |     |
            |     |
            |     |
            |     |
            |_____|

もう少しシンプルで、横から見たような形のものも作成しました。

          _  _
        /` \/ `\
       |  (oo)  |
        \  __  /
      __/      \__
     /            \
    |              |
     \____________/
        |      |
        |      |
        |______|

もし「もっとリアルな感じがいい」や「もっと小さくて可愛い感じがいい」などのご要望があれば、調整しますので教えてくださいね!


どこから見ればカブトムシに見えるのだろう。さっぱりわからない🤷‍♂️ gemma-4-26B-A4Bは諦めてgemma-4-31Bで試してみた。

gemma-4-31B

USER: AA(Ascii Art)でカブトムシを描いて

ASSISTANT: いいですね!カブトムシのAA(アスキーアート)を作ってみました。

【正面から見たカブトムシ】

            /\
           /  \
     _    /    \    _
    (o)\_/      \_/o)
       |          |
       |   __     |
   ___/   /  \    \___
  /   \  /    \  /   \
 |     \/      \/     |
  \____/   ____\____/
         /      \
        /        \

【横顔のカブトムシ(角が特徴的)】

               ___
              /   \
             /  _  \
       ______|  O  |______
      /      |    _|      \
     /    /\_|   / \      \
    |    /  \   /   \     |
    |   |    | |     |    |
     \  |    | |     |   /
      \_|    |_|     |_/
         |________|

【シンプルで可愛いカブトムシ】

       /\
      /  \
     |oo ||
     |__||_
     [____]
     |    |
     |____|

いかがでしたでしょうか? もっとリアルなカブトムシや、別のデザインのものがよければお声がけください!🪲

USER: もっとリアルなカブトムシを描いて

ASSISTANT: リアルなカブトムシを描きました。角(角質)の形状や、甲羅(前胸背板・鞘翅)の曲線、脚の関節などを意識して描いています。

                       _
                     .-'.
                   .'    '.
                  /   /\   \
                 |   |  |   |
                 |   |  |   |
                  \   \/   /
                   '.____.'
                    (    )
          ___________`--'___________
         /                           \
        |   .-------------------.     |
        |   |  .-------------.  |     |
        |   |  |  .-------.  |  |     |
        |   |  |  | o     o |  |     |
        |   |  |  '-------'  |  |     |
        |   |  '-------------'  |     |
        |   '-------------------'     |
         \___________________________/
          /      |           |       \
         /    _  |  _    _  |  _    \
        /    / \ | / \  / \ | / \    \
       |    |   |||   ||   |||   |    |
       |    |   |||   ||   |||   |    |
        \    \ / | \ /  \ / | \ /    /
         \______|___\____/___|___\__/
                |   |   |   |
                |   |   |   |
                |___|___|___|

ポイント:

  • 頭部: 前端の突起(頭角)を尖らせています

  • 前胸背板: 頭部の後ろにある、左右に張り出した部分を表現

  • 鞘翅(さうちょう): 甲虫の硬い羽で、中央の線を入れて立体感を

  • 脚: 各関節を意識して描き、先には爪がついているようにしています

さらにリアルさを追求したバージョンや、別のアングルなどもご希望でしたらお申し付けください!🪲


ツッコミどころ満載というか、突っ込む気にもならないレベルである😵

念の為Qwen3.6-27Bでも試してみた。

Qwen3.6-27B

USER: AA(Ascii Art)でカブトムシを描いて

ASSISTANT: カブトムシのAA(アスキーアート)をいくつか作成しました。 お使いの環境(フォントや等幅か否か)によって崩れる場合がありますが、メモ帳などの等幅フォントでご覧ください。

1. シンプルなカブトムシ(横向き)

一番スタンダードな形状です。

            \   /
             \ /
          ___(X)___
      ___/         \___
     /                 \
    |    ( )     ( )    |
     \___           ___/
         \  \___/  /
          \_______/
             / \
            /   \

2. ちょっとリアルなカブトムシ(上から見た図)

角を強調したデザインです。

          ___
         /   \
        |     |
        |     |
        |  ^  |  <-- 角
       /  / \  \
      /  /   \  \
  ___/  /_____\  \___
 /                   \
|   (O)         (O)   |
 \___________________/
    /     /   \     \
   /     /     \     \
  /     /       \     \

3. ミニサイズ(一行・簡略版)

チャットなどで使いやすい小さなサイズです。

  ( \ / )
  ( ' ' )  <-- 擬人化したカブトムシ風
  (  ^  )
   ^^ ^^

ヒント: もしもっと「巨大な角」や「特定の角度」などの要望があれば、調整しますので教えてくださいね!


Qwen3.6も似たようなレベルだった。まあ私もうまく描けるかというと自信はないのだが。。 ちなみにASCII Art Archiveというサイトを見つけたのでこの中にあったカブトムシを引用しておく。有能な人が描くとこんな感じになるというサンプルである。

       ,_    /) (\    _,
        >>  <<,_,>>  <<
       //   _0.-.0_   \\
       \'._/       \_.'/
        '-.\.--.--./.-'
        __/ : :Y: : \ _
';,  .-(_| : : | : : |_)-.  ,:'
  \\/.'  |: : :|: : :|  `.\//
   (/    |: : :|: : :|    \)
         |: : :|: : :;
        /\ : : | : : /\
       (_/'.: :.: :.'\_)
        \\  `""`""`  //
    jgs  \\         //
          ':.     .:'     By Joan G. Stark (Spunk)

余談

ASCII Art ArchiveにはASCII Gamesというページもありその中に1980年代にはやったPac-Manを模したASCII Dot-Eaterというゲームがあった。ASCII文字だけで作られているがよくできている。おそらくJavaScriptで書かれていると思う。これと同じゲームをローカルAIに作らせるのもベンチマークテストとしておもしろそうである。

Pi-Coding-Agent拡張機能(pi-reddit-research編)

Redditの記事をPi-Coding-Agentから検索できるようにするパッケージがpi-reddit-researchである。 今回はpi-reddit-researchの導入方法と使用例を紹介したい。

pi-reddit-researchの導入

ドキュメントはこちらにある。ドキュメントの通り以下のコマンドを実行してインストールする。

pi install npm:pi-reddit-research

ドキュメントには更に~/.pi/agent/reddit-research.jsonにJSONの定義をしろと書かれている。

{
  "cookie": "reddit_session=abc123; token_v2=def456"
}

ただしrecommendedとなっていたのと意味がよくわからないのでとりあえず実行してみた。

Piを立ち上げてpi-reddit-researchを試す

USER: hello!

ASSISTANT: こんにちは!何かお手伝いできることはありますか?

USER: 今月のRedditのr/LocalLLaMaで話題になったテーマを調べて

ASSISTANT: 申し訳ありません。RedditのAPI制限(認証なしの.jsonアクセス禁止)により、直接トレンドを取得することができませんでした。

現在の状況で調査を進めるために、以下の2つの方法を提案します。どちらの方法で進めるのがよろしいでしょうか?

  1. 検索キーワードを指定して調査する

    あなたが気になっている特定のキーワード(例:「Llama 3」「Quantization」「Mistral」「Groq」など)があれば、それを使ってReddit内を検索し、関連する話題を抽出します。

  2. 一般的な「今月の注目トピック」を推測して深掘りする

    現在のAI業界のトレンド(新しいモデルのリリース、推論速度の向上、量子化技術の進化など)に基づき、それらが r/LocalLLaMA でどのように議論されているかを、検索機能を用いて段階的に調査します。

どちらの方法が良いか、あるいは他に調べたい特定のテーマがあれば教えてください。

USER: pi-reddit-researchが使えるようにする方法を教えて

ASSISTANT: エラーメッセージに基づくと、Redditの仕様変更により、認証情報(Cookie)をツールに提供する必要があります。pi-reddit-research を使えるようにするための手順は以下の通りです。

手順:RedditのCookieを設定する

この作業には、ブラウザからRedditのCookieを取得し、指定された場所に保存する作業が必要です。

1. Redditにログインした状態でCookieを取得する

  1. お使いのブラウザ(Chrome, Firefox, Edgeなど)で Reddit にアクセスし、ログインした状態にします。
  2. デベロッパーツールを開きます(Windows/Linuxは F12 または Ctrl+Shift+I、Macは Cmd+Option+I)。
  3. 「Application」タブ(Firefoxの場合は「ストレージ」)を選択します。
  4. 左側のメニューから 「Cookies」 を展開し、https://www.reddit.com を選択します。
  5. リストの中から session という名前のCookieを探します。
  6. その session「Value(値)」 をすべてコピーします。

2. 設定ファイルに保存する

エラーメッセージに記載されているパス ~/.pi/agent/reddit-research.json に、取得したCookieを書き込む必要があります。

以下の内容でファイルを作成(または上書き)してください。

ファイルパス: ~/.pi/agent/reddit-research.json

ファイルの内容:

{
  "reddit_cookie": "ここにコピーしたsessionの値を貼り付けてください"
}

JSONファイルを定義しないと使えないようだった。gemma-4に聞いたら設定方法を教えてくれたのでその通りに設定したところpi-reddit-researchが使えるようになった。 今どきのローカルAIはこのレベルの質問にも答えれるくらい賢くなった。 ただしJSONのファイル形式はgemma-4が教えてくれたフォーマットではなくドキュメントにあるようにreddit_sessiontoken_v2を設定する必要があった。 ドキュメントのサンプルでは短いテキストであるが実際のテキストはもっと長い。

使用例

gemma-4-26B-A4Bに直近の1週間でr/LocalLLaMAでのホットな話題を10件リストアップしてもらった。

USER: 直近の1週間でr/LocalLLaMAでのホットな話題を10件リストアップして

ASSISTANT: 直近1週間(および現在進行中のホットなトピック)における r/LocalLLaMA の主要な話題10件をまとめました。

今週は特に DeepSeek V4 Flash のリリースとその驚異的なパフォーマンス、そして中国発のLLMの勢いがコミュニティの大部分を占めています。

r/LocalLLaMA ホットトピック・リスト

  1. DeepSeek V4 Flash の衝撃的な性能
    • DeepSeek V4 Flash 0731 が、数ヶ月前の最先端モデル(Frontier Models)に匹敵する知能スコアを叩き出していることが大きな話題です。「ローカルで動かせるモデルが、かつての最強モデルに並んだ」という点が熱狂的に議論されています。
  2. DeepSeek V4 Flash vs ChatGPT Luna の比較
    • 新しく登場した DeepSeek V4 Flash と ChatGPT Luna の比較検証が行われており、その実力差について議論が交わされています。
  3. DeepSeek V4 Flash のコストパフォーマンスと立ち位置
    • Kimi K3 に次ぐオープンウェイトモデル第2位に位置し、かつコストが50倍以上安い(極めて安価なAPI価格)という点が注目されています。
  4. DeepSeek V4 Flash の推論速度に関する議論
    • ユーザーが自身のハードウェア環境(例:4x RTX 5060 Tiなど)で、どの程度のトークン生成速度(TPS)が出ているかについての情報交換が活発です。
  5. DeepSeek V4 Flash 用の GGUF モデルと専用エンジン(DS4)
    • Unslothによる高速な量子化版(GGUF)の登場や、特定の推論エンジン(DwarfStar)での動作についての技術的なスレッドが立っています。
  6. 中国系LLMのリリースラッシュ(Carousel)
    • 次々と新しい中国製LLMが登場し続けている現状に対する、驚きと「次はどのモデルが来るのか」という予測(MiniMaxなど)が議論されています。
  7. 新モデルの大量リリースによる「疲労感」と「興奮」
    • あまりに多くの素晴らしいモデルが短期間にリリースされるため、「テストしきれないが、この勢いはすごい」という、ユーザーの嬉しい悲鳴を反映した投稿が人気を集めています。
  8. Kimi K3 を低メモリで動かす技術(Weight-Aware Streaming)
    • 29GBのRAMを使用して、非常に低速ながらも Kimi K3 を動かすための新しいテンソルエンジンに関するガイドが共有されています。
  9. リリースされた新モデルの総括
    • DeepSeek, Thinking Machines Inkling, Poolside Laguna, Upstage Solar など、ここ数日で登場した注目モデルをまとめた投稿が話題になっています。
  10. ベンチマークデータの検証
    • DeepSeekが主張するベンチマーク(DeepSWEなど)が、実際の性能を正しく反映しているか、あるいは検証が必要かといった議論が行われています。

傾向のまとめ: 今週のコミュニティは、「DeepSeek V4 Flash」という圧倒的な新星を中心に、「ローカルLLMの知能が急速にトップクラスへ追いついていること」への驚きと、「中国発モデルの爆発的なリリーススピード」に対する反応で溢れています。

USER: DeepSeek V4 Flash の衝撃的な性能に関するスレッドのURLと具体的にどのような議論が行われているかを教えて

ASSISTANT: 「DeepSeek V4 Flash の衝撃的な性能」に関連する議論は、単一のスレッドではなく、「性能(ベンチマーク)」「コスト」「ローカルでの実行可能性」という3つの観点から複数のスレッドに分かれて非常に熱狂的に行われています。

主要なスレッドのURLと、それぞれの具体的な議論内容は以下の通りです。

1. 性能(知能スコア)に関する議論

URL: https://www.reddit.com/r/LocalLLaMA/comments/1vchoua/deepseekv4flash0731_models_you_can_run_locally/

  • 議論の内容:
    • 「ローカルの勝利」: 2026年3月時点での最高峰のフロンティアモデル(知能指数51)に対し、DeepSeek V4 Flashは50というスコアを記録しており、「数千ドルのハードウェアで動かせるモデルが、わずか数ヶ月前まで最高峰だったモデルに肉薄している」という事実が議論の核となっています。
    • ベンチマークの信憑性: この高いスコアが、実際の推論能力を正しく反映しているのか、それともベンチマーク対策(Data Contamination)ではないかという慎重な見方も見られます。

2. コストパフォーマンスと立ち位置に関する議論

URL: https://www.reddit.com/r/LocalLLaMA/comments/1vc4041/deepseek_v4_flash_is_now_2_open_weight_model_to/

  • 議論の内容:
    • 「知能が安すぎる」: DeepSeekのAPI価格が極めて安価(1Mトークンあたり$0.09〜$0.18程度)であることに驚きが集まっています。投稿者はこれを「Intelligence too cheap to meter(計量不能なほど知能が安い)」と表現しています。
    • 比較: Kimi K3に次ぐオープンウェイトモデルの第2位であること、およびコスト面で競合を圧倒している点が強調されています。コーディングや論理的推論のタスクにおける実用性についても言及されています。

3. 推論速度(実用性)に関する議論

URL: https://www.reddit.com/r/LocalLLaMA/comments/1vcaztx/what_speeds_are_everyone_getting_with_deepseek_v4/

  • 議論の内容:
    • 「ハードウェアごとの実測値」: 性能が高いことは分かったが、「実際に自分の環境(GPU/RAM)でどの程度の速度(Tokens Per Second)が出るのか」という、より実践的な議論が行われています。
    • 具体的な数値: 例えば「4枚のRTX 5060 Ti環境で、プロンプト処理は200tps、生成は11tps程度」といった、具体的な構成と速度の報告がユーザー間で交換されています。

まとめると: コミュニティでは、「これほど高性能なモデルが、これほど安価に、かつローカル(あるいは安価なAPI)で利用できるようになった」というパラダイムシフトに対して、非常に高い関心が寄せられています。単なる「新しいモデルが出た」というニュースを超えて、「AIの民主化が一段階進んだ」というニュアンスで捉えられているのが特徴です。


pi-reddit-researchがあればRedditでどんな議論が行われているのかを最小限の労力で把握できるようになる。関連するスレッドのURLも正確に教えてくれる。 もちろん英語のページであるが恐れることはない。今のChromeならページごと日本語に翻訳してくれる。ブラウザでページを表示した後、右クリックして「日本語に翻訳」を選ぶだけである。

私はこの機能を知らずに数行ずつ選択してはGoogle翻訳で翻訳させていたのだが、最近になってgemma-4からこの方法を教えてもらった😅

Googleさん、こんな便利な機能あるなら早く言ってよ〜😤

Redditのページを日本語に翻訳した結果

Pi-Coding-Agent拡張機能(Wikipedia MCP編)

Wikipedia MCPとはAIがWikipediaの公開データにアクセスし検索や記事取得を行えるようにするためのMCPサーバである。Pi-Coding-Agentに本機能を導入する手順をメモしておく。

1.pi-mcp-adapterの導入

pi-mcp-adapterPi-Coding-Agentのパッケージである。Wikipedia MCPは本機能から子プロセスとして起動され、その標準入出力で情報をやり取りする。MCPサーバーの起動コマンドはmcp.jsonで定義する。 llama-sererからMCPを利用した時には別プロセスとしてmcp-proxyを立ち上げておきHTTPで通信していたのだが、Pi-Coding-Agentではそのような手間は不要になる。

インストールコマンド

pi install npm:pi-mcp-adapter

pi-mcp-adapteのドキュメントはこちらにある。

2.Wikipedia MCPの導入

Wikipedia MCPには2種類ある。wikipedia-mcp-serverwikipedia-mcpである。自分の好みでどちらかを導入すればいい。私は両方導入したのだがwikipedia-mcpの方で運用している。

2.1 wikipedia-mcp-server

wikipedia-mcp-serverのドキュメントはこちら。ツール機能としては以下の2つのみでシンプルである。

  • search : Search keyword on Wikipedia.
  • fetch : Fetch Wikipedia page content.

wikipedia-mcp-serverの導入

・インストールコマンド

pip install wikipedia-mcp-server

・起動コマンド

python -m wikipedia_mcp

・mcp.jsonの定義

 JSONの定義により内部的に自動で起動される。

{
  "mcpServers": {
    "wikipedia-mcp": {
      "command": "python",
      "args": ["-m", "wikipedia_mcp"]
    }
  }
}

2.2 wikipedia-mcp

wikipedia-mcpのドキュメントはこちら。ツール機能は豊富である。

  • search_wikipedia : Search Wikipedia for articles matching a query.
  • get_article : Get the full content of a Wikipedia article.
  • get_summary : Get a concise summary of a Wikipedia article.
  • get_sections : Get the sections of a Wikipedia article.
  • get_links : Get the links contained within a Wikipedia article.
  • get_coordinates : Get the coordinates of a Wikipedia article.

(以下省略)

wikipedia-mcpの導入

・起動コマンド

uvx wikipedia-mcp

・mcp.jsonの定義

 JSONの定義により内部的に自動で起動される。

{
  "mcpServers": {
    "wikipedia-mcp": {
      "command": "uvx",
      "args": [
        "wikipedia-mcp"
      ],
      "directTools": true
    }
  }
}

3.serper-searchの導入

serper-searchも設定するとgoogle-search機能なども使用できる。serper-searchwikipedia-mcpを併用する場合のmcp.jsonの設定は以下のようになる。--with mcp<2の記述は私のUbuntu環境ではmcpパッケージのv1系(低レベルSDK)でしか動かないためv1系固定とするため。

{
  "mcpServers": {
    "serper-search": {
      "command": "uvx",
      "args": [
        "--with",
        "mcp<2",
        "serper-mcp-server"
      ],
      "env": {
        "SERPER_API_KEY": "Your-API-KEY"
      }
    },
    "wikipedia-mcp": {
      "command": "uvx",
      "args": [
        "wikipedia-mcp"
      ],
      "directTools": true
    }
  }
}

4.その他

4.1 uvの導入

uvxコマンドを使うためにはuvの導入が必要

インストール

Python環境で以下のコマンドを実行

pip install uv

4.2 MCP接続確認

piを起動した後にMCPとの接続を確認するには/mcpコマンドを使う。 mcp.jsonで設定したMCPサーバーが表示される。 カーソルを合わせてCtrl-rで接続できているか確認できる。

mcp.json"debug": trueを設定しておくとコマンド起動ログが標準出力に出力されるのでエラー原因をつかみやすくなる。エラー原因がわからないときはClaudeなどのAIに聞くと教えてくれる。

{
  "mcpServers": {
    "wikipedia-mcp": {
      "command": "uvx",
      "args": [
        "wikipedia-mcp"
      ],
      "debug": true
    }
  }
}

4.3 その他の便利なパッケージ

Redditの投稿内容を調べてくれるpi-reddit-researchが便利である。これはMCPの設定不要でmcp.jsonへの追記は不要だがアクセス認証のcookieFileの設定が必要だった。導入方法はgemma-4に聞いたら教えてくれたのでその内容は別の記事で紹介したい。

gemma-4に昔の映画のあらすじを聞いてみた

NHK-BSプレミアムシネマの8月の放送予定がこちらでチェックできる。

8月4日放送予定の「刑事ジョン・ブック 目撃者」は若い頃に観た映画だ。1985年公開なのでもう40年前ということになる。

NHKのHPには以下のように内容が紹介されている。

父親を亡くしたアーミッシュの少年サミュエルは、母親レイチェルとともに伯母の住むボルティモアへと向かう途中、フィラデルフィア駅で殺人事件を目撃する。担当刑事ジョン・ブックは、サミュエルの証言から、警察組織の不正を直感する。犯人たちに命を狙われ傷ついたブックは、母子が住むアーミッシュの村に身を隠すが…。ハリソン・フォード主演、名匠ピーター・ウィアー監督の傑作サスペンス。アカデミー脚本、編集賞受賞。

これを映画館で観たのかレンタルビデオで観たのかも記憶が定かでない。アーミッシュの生活というのをこの映画で初めて知ったことは確かだと思うが映画のストーリはほぼ忘れている。

映画の内容を確認したいと思いWikipediaを探した。Wikipediaでの説明はこちら。これはこれで今でも便利だ。しかしふと「AIに聞いたら教えてくれるのかな」と思った。

gemma-4-26B-A4B(400億パラメタ)

最近お気に入りのローカルAIgemma-4-26B-A4Bを立ち上げ、Pi-Coding-Agentから質問してみた。

1回目

USER: 映画「刑事ジョンブック」のあらすじを400字程度でまとめて

ASSISTANT: 映画『刑事ジョン・ブック』(原題: John Wick)のあらすじを約400字でまとめます。

かつて伝説的な殺し屋として恐れられたジョン・ウィックは、愛する妻を亡くした後、静かな隠遁生活を送っていた。そんな彼のもとに、ある日、元同僚の息子が強奪した愛車と共に、亡き妻が遺した最後の手がかりである子犬が現れる。

しかし、その強盗の一団がジョンに踏み込み、愛犬を殺害するという取り返しのつかない事件を引き起こしてしまう。妻との唯一の絆であった愛犬を失ったジョンは、怒りに突き動かされ、再び復讐の道へと身を投じる。

かつての仲間や、裏社会のルールに縛られた冷酷な殺し屋たちを次々と葬っていくジョン。圧倒的な戦闘技術と、執念とも言える凄まじい執着心で、彼は仇敵を追い詰めていく。愛する者を奪われた男の、容赦のない報復劇が幕を開ける。


全然別の映画を紹介してきた。確かに「ジョン・ウイック」(原題: John Wick)という映画はあるようだけど。 私が映画のタイトルを正確に伝えていなかったからかな〜と思ってもう一度聞いてみた。

2回目

USER: 映画「刑事ジョン・ブック 目撃者」のあらすじを400字程度でまとめて

ASSISTANT: 大変失礼いたしました。先ほどは『ジョン・ウィック』と混同してしまいました。 映画『刑事ジョン・ブック 目撃者』(原題: Witness for the Prosecution)のあらすじを、改めて約400字でまとめます。

物語の舞台は第二次世界大戦直後のイギリス。敏腕弁護士サー・ウィリアム・アーロンソンは、有力者の妻を殺害した罪に問われた、一見誠実そうな男レナード・ヴォールを弁護することになる。

レナードは無実を主張し、有力な証言者として、彼に恋心を抱く女性ミラを立てる。彼女の証言により、レナードは無罪を勝ち取るかと思われたが、事件は思わぬ方向へと転がり始める。実は、ミラには彼を陥れるための巧妙な計画があり、裁判の裏には誰もが予想しなかった衝撃的な真実が隠されていたのだ。

アガサ・クリスティの傑作を映画化した本作は、法廷劇としての緊張感と、人間の狡猾さ、そして人間の心理の深淵を描き出している。観客は、緻密に張り巡らされた罠と、最後に明かされる鮮やかな大どんでん返しに、息を呑むことになる。


また別の映画を紹介してきた。邦題「情婦」で原題 Witness for the Prosecutionという映画)も確かにあるようだが😞。。

邦題と原題を正確に与えてもう一度試してみた。

3回目

USER: 1985年公開のアメリカ映画「刑事ジョン・ブック 目撃者」原題:Witnessのあらすじを400字程度でまとめて

ASSISTANT: 大変失礼いたしました。度重なる間違い、深くお詫び申し上げます。 1985年公開、クリントン・グリーン監督、ジェーン・フォンダ主演の映画『刑事ジョン・ブック 目撃者』(原題: Witness)のあらすじを、改めて約400字でまとめます。

舞台は1960年代のニューヨーク。刑事が犯罪組織の巨大な利権を暴こうとした際、その捜査の過程で、目撃者となった一人の少年が組織の暗殺者に命を狙われる。

凄惨な事件の目撃者となった少年を保護するため、刑事が選んだ方法は、彼を日常から切り離し、ある牧師の家庭へと預けることだった。牧師とその家族は、規律と信仰を重んじる穏やかな生活を送っていたが、少年の存在は、静かなコミュニティに予期せぬ緊張と変化をもたらしていく。

少年は、家族の温かさや信仰の在り方に触れる中で、次第に心を閉ざした状態から変化していく。一方、組織の追跡は着実に彼らに迫り、平穏な生活は崩壊の危機に直面する。

犯罪の闇と、牧師一家が守り続ける純粋な信念。対照的な二つの世界が交錯する中、少年を守り抜くための緊迫した戦いと、人間としての成長を描いたドラマチックな物語である。


ストーリーはほぼ正しいのだが監督名と主演俳優をしっかり間違えている。ハルシネーションというやつか。

gemma-4-26B-A4Bは軽量で応答が早く私のお気に入りであるのだがこの種のタスクには向いていないことが分かった。

これで終わろうかと思ったが試しにgemma-4-31Bにも聞いてみた。

gemma-4-31B(3100億パラメタ)

あらすじ

USER: 1985年公開のアメリカ映画「刑事ジョン・ブック 目撃者」原題:Witnessのあらすじを400字程度でまとめて

ASSISTANT: 1985年公開の映画『刑事ジョン・ブック 目撃者』は、都会的な刑事と伝統を重んじるアーミッシュのコミュニティとの交流を描いた人間ドラマであり、サスペンスです。

フィラデルフィアで起きた殺害事件の唯一の目撃者は、アーミッシュの少年でした。警官のジョン・ブックは少年を保護するため、彼が住むペンシルベニア州の静かな集落へと向かいます。近代文明を拒絶し、信仰と伝統を守り抜くアーミッシュの世界に戸惑いながらも、ブックは少年の親族である女性レイチェルに惹かれていきます。

しかし、事件の真相は警察内部の腐敗に繋がっており、口封じを狙う追っ手が集落を襲います。異なる価値観を持つ者たちが、少年の命を守るために共闘し、正義を貫こうとする姿が描かれます。静寂の中にある精神的な豊かさと、激しいアクションが対比的に表現された名作です。


まともなあらすじが返ってきた。しかしgemma-4-31Bは応答が遅い。プロンプトの評価とThinking中の時間が約3分、回答出力速度が2.9トークン/秒であった。

俳優と監督

このレベルの回答をもう少し早く出力してくれればWikipedia代わりに使ってもよさそうな気がするのだがどうだろう。あらすじ以外の情報も聞いてみた。

USER: 映画の主演俳優と監督を教えて

ASSISTANT: 映画『刑事ジョン・ブック 目撃者』の主演俳優と監督は以下の通りです。

  • 主演俳優:ハリソン・フォード(ジョン・ブック役)
  • 監督:ピーター・ウィアー

USER: その他の主な出演者は誰?

ASSISTANT: 主な出演者は以下の通りです。

  • ケリー・マクギリス(レイチェル・センダック役):少年の親族であり、ジョン・ブックと心を通わせていく女性。
  • エドワード・ファーロング(サミュエル・センダック役):事件の唯一の目撃者となった少年。
  • ダニー・グローヴァー(マクフィー刑事役):ジョン・ブックと共に捜査にあたる同僚の刑事。

特に、ヒロインのケリー・マクギリスと、当時子役だったエドワード・ファーロングの存在感が物語に重要な彩りを添えています。


監督と主演俳優までは正しいのだがその他の情報については間違いが含まれている。3100億パラメタクラスでも記憶の正確性は保証できないようだ。

gemma-4-31B(3100億パラメタ)+ wikipedia-mcp

記憶が曖昧な場合にはWikipediaを検索して確認してくれればなんとかなるのではないかと思った。AIエージェントにもこの作業を行わせるためにwikipedia-mcpを導入した。 wikipedia-mcp-serverwikipedia-mcpの2種類がある。とりあえず両方インストールしてgemma-4-31Bwikipedia-mcpの組み合わせで実行した結果が以下である。


USER: 1985年公開のアメリカ映画「刑事ジョン・ブック目撃者」原題:Witnessのあらすじ、監督と主な登場人物・キャスト、各賞の受賞歴をを500字程度でまとめて。なお記憶が曖昧な場合はWikipediaなどで内容に間違いがないか確認して。

wikipedia_mcp_search_wikipediaの内容を開く

 wikipedia_mcp_search_wikipedia 
 { 
 "query": "Witness (film)" 
 } 
 {"query":"Witness (film)","results":[{"title":"Witness (1985 film)","snippet":"<span class=\"searchmatch\">Witness</span> is 
 a 1985 American neo-noir crime thriller <span class=\"searchmatch\">film</span> directed by Peter Weir. Starring Harrison 
 Ford, its plot focuses on a police detective 
 protecting","pageid":84931,"wordcount":3964,"timestamp":"2026-07-08T19:34:27Z"},{"title":"Witness (1988 
 film)","snippet":"<span class=\"searchmatch\">Witness</span> is a 1988 Indian Malayalam language crime thriller <span 
 class=\"searchmatch\">film</span>, directed by Viji Thampi and co-written by Jagathy Sreekumar, starring Jayaram, 
 Jagathy","pageid":26015247,"wordcount":671,"timestamp":"2026-06-11T11:08:31Z"},{"title":"The Witness (2018 
 film)","snippet":"The <span class=\"searchmatch\">Witness</span> (Korean: 목격자; RR: Mokgyeokja) is a 2018 South Korean 
 crime thriller <span class=\"searchmatch\">film</span> directed by Jo Kyu-jang. It stars Lee Sung-min, Kim Sang-ho, Jin 
 Kyung","pageid":58198725,"wordcount":985,"timestamp":"2025-12-29T06:59:12Z"},{"title":"Witness (2022 film)","snippet":"<span 
 class=\"searchmatch\">Witness</span> is a 2022 Indian Tamil-language drama <span class=\"searchmatch\">film</span> directed 
 by Deepak. The <span class=\"searchmatch\">film</span> stars Shraddha Srinath and Rohini in leading roles. It was released 
 on","pageid":72479568,"wordcount":350,"timestamp":"2026-06-27T23:32:50Z"},{"title":"Witness Protection 
 (film)","snippet":"<span class=\"searchmatch\">Witness</span> Protection is a 1999 American crime drama television <span 
 class=\"searchmatch\">film</span> directed by Richard Pearce and starring Tom Sizemore, Mary Elizabeth Mastrantonio, 
 Forest","pageid":15310965,"wordcount":586,"timestamp":"2026-02-22T17:19:56Z"},{"title":"Your Witness (film)","snippet":"Your 
 <span class=\"searchmatch\">Witness</span> (U.S title Eye <span class=\"searchmatch\">Witness</span>) is a 1950 British 
 drama <span class=\"searchmatch\">film</span> directed by and starring Robert Montgomery, Leslie Banks, Felix Aylmer and 
 Andrew Cruickshank","pageid":24210362,"wordcount":603,"timestamp":"2026-07-17T06:11:48Z"},{"title":"Witness for the 
 Prosecution (1957 film)","snippet":"<span class=\"searchmatch\">Witness</span> for the Prosecution is a 1957 American legal 
 mystery melodrama <span class=\"searchmatch\">film</span> directed by Billy Wilder and starring Tyrone Power, Marlene 
 Dietrich, and","pageid":92608,"wordcount":2119,"timestamp":"2026-07-26T10:37:53Z"},{"title":"Witness Insecurity 
 (film)","snippet":"Absolute Killers, also known as <span class=\"searchmatch\">Witness</span> Insecurity and Snitch, is a 
 2011 American thriller <span class=\"searchmatch\">film</span> directed, produced and co-written by Heather Hale. 
 The","pageid":30673459,"wordcount":771,"timestamp":"2026-02-26T02:50:07Z"},{"title":"The Witness (2024 film)","snippet":"The 
 <span class=\"searchmatch\">Witness</span> (originally titled Shahed) is a 2024 Austrian-German crime-drama <span 
 class=\"searchmatch\">film</span> co-written and directed by Nader Saeivar. It is the first <span 
 class=\"searchmatch\">film</span> 
 project","pageid":77943247,"wordcount":289,"timestamp":"2026-01-11T05:23:09Z"},{"title":"Silent Witness (2013 
 film)","snippet":"Silent <span class=\"searchmatch\">Witness</span> is a 2013 Chinese crime thriller <span 
 class=\"searchmatch\">film</span> written and directed by Fei Xing and starring Sun Honglei, Aaron Kwok and Yu Nan. Tycoon 
 Lin 
 Tai&#039;s","pageid":40367765,"wordcount":1131,"timestamp":"2026-06-10T03:46:07Z"}],"status":"success","count":10,"language" 
 :"en"} 

wikipedia_mcp_get_articleの内容を開く

 wikipedia_mcp_get_article 
 { 
 "title": "Witness (1985 film)" 
 } 
 {"title":"Witness (1985 film)","pageid":84931,"summary":"Witness is a 1985 American neo-noir crime thriller film directed by 
 Peter Weir. Starring Harrison Ford, its plot focuses on a police detective protecting an Amish woman and her son, who 
 becomes a target after he witnesses a brutal murder in a Philadelphia railroad station.\nFilmed in 1984, Witness was 
 released theatrically by Paramount Pictures on February 8, 1985. The film received positive reviews upon release and became 
 a sleeper hit, grossing over $117.1 million worldwide. At the 58th Academy Awards, it earned eight nominations, including 
 Best Picture and Best Actor for Ford, winning Best Original Screenplay and Best Film Editing. It was also nominated for 
 seven BAFTA Awards, winning one for Maurice Jarre's score, and six Golden Globe Awards. William Kelley and Earl W. Wallace 
 won the Writers Guild of America Award for Best Original Screenplay and the 1986 Edgar Award for Best Motion Picture 
 Screenplay presented by the Mystery Writers of America.","text":"Witness is a 1985 American neo-noir crime thriller film 
 directed by Peter Weir. Starring Harrison Ford, its plot focuses on a police detective protecting an Amish woman and her 
 son, who becomes a target after he witnesses a brutal murder in a Philadelphia railroad station.\nFilmed in 1984, Witness 
 was released theatrically by Paramount Pictures on February 8, 1985. The film received positive reviews upon release and 
 became a sleeper hit, grossing over $117.1 million worldwide. At the 58th Academy Awards, it earned eight nominations, 
 including Best Picture and Best Actor for Ford, winning Best Original Screenplay and Best Film Editing. It was also 
 nominated for seven BAFTA Awards, winning one for Maurice Jarre's score, and six Golden Globe Awards. William Kelley and 
 Earl W. Wallace won the Writers Guild of America Award for Best Original Screenplay and the 1986 Edgar Award for Best Motion 
 Picture Screenplay presented by the Mystery Writers of America.\n\nPlot\nIn a quiet Amish community outside Lancaster, 
 Pennsylvania, friends and family attend the funeral of Jacob Lapp, leaving behind his wife, Rachel, and eight-year-old son, 
 Samuel. Rachel and Samuel travel by train to visit Rachel's sister, which takes them into Philadelphia. While at the 30th 
 Street Station waiting for a connecting train, Samuel goes into the men's room and witnesses the murder of undercover police 
 officer Detective Ian Zenovich.\nDetective Captain John Book and his partner, Sergeant Elton Carter, are assigned to the 
 case. They question Samuel, who is unable to identify the perpetrator from mugshots or a lineup. Samuel then sees a 
 newspaper clipping in a trophy case of narcotics officer Lieutenant James McFee and points him out to Book as the 
 murderer.\nBook investigates McFee and discovers that he was previously responsible for a seizure of expensive chemicals 
 used to make black-market amphetamine, after which the chemicals disappeared. Book surmises that McFee sold the chemicals 
 back to drug dealers, and Zenovich was investigating. Book expresses his suspicions to Chief of Police Paul Schaeffer, who 
 advises Book to keep the case secret so that they can determine how to proceed. Book is later ambushed in his apartment 
 parking garage by McFee, who shoots and wounds him before fleeing. Since only Schaeffer knew of Book's suspicions, Book 
 realizes that Schaeffer is corrupt and tipped off McFee.\nKnowing that Samuel and Rachel are now in danger, Book orders 
 Carter to hide their police files. He then drives them back to their farm. While beginning his drive back to Philadelphia, 
 he passes out from his wounds and crashes into their birdhouse. Rachel insists that he be taken to a hospital, but Book 
 refuses and states that going there would allow him and, by extension, them to be found. Rachel's father-in-law, Eli, 
 reluctantly agrees to shelter Book.\nBook slowly recovers in their care and begins to blend into the Amish community and 
 lifestyle. He and Rachel develop feelings for each other, which becomes a source of friction for Daniel Hochleitner (a 
 neighbor who had hoped to court Rachel after her husband's death). Book's relationship with the Amish community deepens as 
 they learn that he is skilled at carpentry and seems like a decent, hard-working man. He is invited to participate in a barn 
 raising for a newly-married couple, gaining Hochleitner's respect. However, the attraction between Book and Rachel is 
 evident and causes gossip in the tight-knit community.\nMeanwhile, Schaeffer searches for Book by contacting authorities in 
 the Amish area. However, since Amish communities have no modern means of communication and little contact with the outside 
 world, he hits repeated dead ends.\nWhen Book goes into town with Eli to use a payphone to call his precinct, he learns that 
 Carter was killed in the line of duty. Realizing that Schaeffer was behind it, Book calls him at his home (where the call 
 cannot be traced), chastises him for being corrupt and threatens to kill him. As they leave town, a group of locals harass 
 the Amish. Book retaliates, breaking with the Amish tradition of non-violence. The assault is reported to the local police, 
 and word eventually gets back to Schaeffer.\nUpset with Book over the assault, Eli orders him to leave. Rachel approaches 
 Book in a field, where they passionately embrace, finally acting on their feelings. Soon after this, Schaeffer, McFee and 
 another corrupt cop, Sergeant Leon \"Fergie\" Ferguson, arrive at the Lapp farm and take Rachel and Eli hostage. Eli manages 
 to alert Book, and Book tells Samuel to hide at Hochleitner's farm. Book tricks Fergie into the corn silo and suffocates him 
 under tons of corn, then uses Fergie's shotgun to kill McFee. Schaeffer holds Rachel and Eli at gunpoint, but Samuel 
 secretly comes back to ring the Lapp farm's bell. Book confronts Schaeffer, who threatens to kill Rachel, but the bell has 
 alerted and summoned all of the neighbors. With so many witnesses present, Schaeffer surrenders and is later arrested.\nWith 
 Rachel and Samuel no longer in danger, Book departs for Philadelphia, bidding farewell. Before he drives off, Eli wishes 
 Book well by saying, \"You be careful out there among them English.”\n\nCast\nPer the film's end credits:\n\nThemes\nIn his 
 book The Amish in the American Imagination (2001), scholar David Weaver-Zercher notes that Witness is primarily concerned 
 with the intersection of contrasting cultures, a recurring theme in several of Weir's films, including The Last Wave (1977) 
 and The Year of Living Dangerously (1982). Weaver-Zercher notes that the conflict between Amish and non-Amish as depicted in 
 Witness \"reflect[s] well on the Amish ways\" and also serves as a redemption story for Captain Book, who regains a new 
 sense of humanity during his displacement in the Amish community.\n\nProduction\nDevelopment\nProducer Edward S. Feldman, 
 who was in a \"first-look\" development deal with 20th Century Fox at the time, first received the screenplay for Witness in 
 1983. Originally titled Called Home, which is the Amish term for death, it ran for 182 pages, the equivalent of three hours 
 of screen time. The script, which had been circulating in Hollywood for several years, began with an idea by novelist Pamela 
 Wallace for a novel about an Amish woman who witnesses a murder in Los Angeles. Earl W. Wallace, who wrote for the 
 television Western How the West Was Won recalled an episode with a similar plot and contacted its writer, William Kelley. 
 Kelley had reworked the plot for the show from a script he had written for a 1972 episode of Gunsmoke. Earl Wallace and 
 Kelley wrote the original screenplay together.\nFeldman liked the concept, but felt too much of the script was devoted to 
 Amish traditions, diluting the thriller aspects of the story. He offered Kelley and Wallace $25,000 for a one-year option 
 and one rewrite, and an additional $225,000 if the film actually were made. They submitted the revised screenplay in less 
 than six weeks, and Feldman delivered it to Fox. Joe Wizan, the studio's head of production, rejected it with the statement 
 that Fox did not make \"rural movies\".\nFeldman sent the screenplay to Harrison Ford's agent Phil Gersh, who contacted the 
 producer four days later and advised him his client was willing to commit to the film. Certain the attachment of a major 
 star would change Wizan's mind, Feldman approached him once again, but Wizan insisted that as much as the studio liked Ford, 
 they still were not interested in making a \"rural movie\".\nFeldman sent the screenplay to numerous studios, and was 
 rejected by all of them, until Paramount Pictures finally expressed interest. Feldman's first choice of director was Peter 
 Weir, but he was involved in preproduction work for The Mosquito Coast and passed on the project. John Badham dismissed it 
 as \"just another cop movie\", and others Feldman approached either were committed to other projects or had no interest. 
 Then, as financial backing for The Mosquito Coast fell through, Weir became free to direct Witness, which was his first 
 American film. Starting the film immediately was imperative, because a Directors Guild of America (DGA) strike was looming. 
 David Cronenberg was offered the role of director, but declined as he \"could never be a fan of the 
 Amish\".\n\nCasting\nLynne Littman had originally been in talks to direct the film, and though she ultimately did not, she 
 recommended Lukas Haas for the part of Samuel, because she had recently worked with him on her film Testament. The role of 
 Rachel was the most difficult to cast, and after Weir grew frustrated with the auditions he had seen, he asked the casting 
 director to look for actors in Italy, because he thought they would be more \"womanly\".  As they were reviewing audition 
 tapes from Italy, Kelly McGillis came to audition, and the moment she put on the bonnet and spoke a few lines, Weir knew she 
 was the one. The casting director recommended her old friend Alexander Godunov, who had never acted before, but she thought 
 his personality would be right, and Weir agreed.\nViggo Mortensen was cast because Weir thought he had the right face for 
 the part of an Amish man. Mortensen had just started his acting career, so this was his first film acting role, and he had 
 to turn down another role as a soldier in Shakespeare in the Park's production of Henry V. He credited that decision and the 
 very positive experience on the film as the start of his film career.\n\nPre-production\nDuring the weeks before filming, 
 Ford spent time with the homicide department of the Philadelphia Police Department, researching the important details of 
 working as a homicide detective. McGillis did research by moving in with an Amish widow and her seven children, learning how 
 to milk cows and practicing their Pennsylvania German dialect.\nWeir and cinematographer John Seale went on a trip to the 
 Philadelphia Museum of Art, which was running an exhibition of 17th-century Dutch Masters. Weir drew attention to the 
 paintings of Johannes Vermeer, which were used as inspiration for the lighting and composition of the film, especially in 
 the scenes where John Book is recovering from a gunshot wound in Rachel's house.\n\nFilming\nPrincipal photography took 
 place between April 27, 1984 and June 29, 1984. The film was shot on location in Philadelphia and the city and towns of 
 Intercourse, Lancaster, Strasburg, and Parkesburg. Local Amish were willing to work as carpenters and electricians, but 
 declined to appear on film, so many of the extras were actually Mennonites. Halfway through filming, the title was changed 
 from Called Home to Witness at the behest of Paramount's marketing department, which felt the original title posed too much 
 of a promotional challenge. Principal photography was completed three days before the scheduled DGA strike, which ultimately 
 failed to materialize.\nDuring the set-up and rehearsal of each scene, as well as during dailies, Weir would play music to 
 set the mood, with the idea that it prevented the actors from thinking too much and let them listen to their other 
 instincts. The barn-raising scene was only a short paragraph in the script, but Weir thought it was important to highlight 
 that aspect of Amish community life. They shot the scene in a day and did, in fact, build a barn, albeit with the aid of 
 cranes off-camera. To film the scene in the corn silo, corn was actually dropped onto the actor, while a scuba diving 
 regulator with a compressed air tank was hidden on the floor so the actor would be able to breathe.\nOriginally, the script 
 ended with a scene of Book and Rachel each explaining their feelings for each other to the audience, but Weir felt the scene 
 was unnecessary and decided not to shoot it. The studio executives were concerned that the audience would not understand the 
 conclusion, and tried to convince him otherwise, but Weir insisted that the characters' emotions could be expressed only 
 with visuals.\n\nRelease\nWitness had its world premiere at the Fulton Opera House in Lancaster, Pennsylvania in on February 
 7, 1985. The film was screened out of competition at the 1985 Cannes Film Festival.\n\nBox office\nThe film opened 
 theatrically in 876 theaters in the United States on February 8, 1985, and grossed $4,539,990 in its opening weekend, 
 ranking number two behind Beverly Hills Cop. The film went on to become a sleeper hit, topping the charts in its fifth week 
 of release. It eventually earned a total of $68,706,993 in North America. Internationally, it grossed $47.4 million for a 
 worldwide total of $116.1 million.\n\nHome media\nParamount Home Entertainment released Witness on VHS, with a DVD in 
 initially in 1999 and then in 2005, along with a Blu-ray Disc in 2015.\nBritish boutique label Arrow Films released the film 
 in the United States on 4K Ultra HD disc and remastered Blu-ray on October 31, 2023.\n\nReception\nWitness received critical 
 acclaim, with particular praise towards Ford's performance. Roger Ebert of the Chicago Sun-Times rated the film four out of 
 four stars, calling it: [F]irst of all, an electrifying and poignant love story. Then it is a movie about the choices we 
 make in life and the choices that other people make for us. Only then is it a thriller—one that Alfred Hitchcock would have 
 been proud to make... We have lately been getting so many pallid, bloodless little movies—mostly recycled teenage 
 exploitation films made by ambitious young stylists without a thought in their heads—that Witness arrives like a fresh new 
 day. It is a movie about adults whose lives have dignity and whose choices matter to them. And it is also one hell of a 
 thriller. Ebert also praised Ford's work and believed he had \"never given a better performance in a movie.\"\nVincent Canby 
 of The New York Times was much more negative, saying of the film:\n\nIt's not really awful, but it's not much fun. It's 
 pretty to look at and it contains a number of good performances, but there is something exhausting about its neat balancing 
 of opposing manners and values... One might be made to care about all this if the direction by the talented Australian film 
 maker, Peter Weir... were less perfunctory and if the screenplay... did not seem so strangely familiar. One follows Witness 
 as if touring one's old hometown, guided by an outsider who refuses to believe that one knows the territory better than he 
 does. There's not a character, an event, or a plot twist that one hasn't anticipated long before its arrival, which gives 
 one the feeling of waiting around for people who are always late.\nVariety said the film was \"at times a gentle, affecting 
 story of star-crossed lovers limited within the fascinating Amish community. Too often, however, this fragile romance is 
 crushed by a thoroughly absurd shoot-'em-up, like ketchup poured over a delicate Pennsylvania Dutch dinner.\"\nTime Out New 
 York observed, \"Powerful, assured, full of beautiful imagery and thankfully devoid of easy moralizing, it also offers a 
 performance of surprising skill and sensitivity from Ford.\"\nHalliwell's Film Guide chose Witness as one of only two films 
 from 1985 to receive a four-star review, describing it as \"one of those lucky movies which works out well on all counts and 
 shows that there are still craftsmen lurking in Hollywood.\"\nRadio Times called the film \"partly a love story and partly a 
 thriller, but mainly a study of cultural collision – it's as if the world of Dirty Harry had suddenly stumbled into a canvas 
 by Brueghel.\" It added, \"[I]t's Weir's delicacy of touch that impresses the most. He ably juggles the various elements of 
 the story and makes the violence seem even more shocking when it's played out on the fields of Amish denial.\"\nOn Rotten 
 Tomatoes the film scores 92% based on 49 reviews. Its Metacritic score is 76 out of 100 based on 14 critics.\nIn 2006, 
 Writers Guild of America West ranked its screenplay 80th in WGA’s list of 101 Greatest 
 Screenplays.\n\nAccolades\nControversy\nLeading up to and following its release, Witness was met with controversy from the 
 Amish communities where it was filmed, and was subject to debate from editors, scholars, and other parties regarding its 
 depiction of the Amish. Some accused the film of exploiting the Amish community for commercial purposes, while others felt 
 that the depiction of Amish characters in an R-rated film was insensitive to the Amish's beliefs.\nA statement released by a 
 law firm associated with the Amish claimed that their portrayal in the movie was not accurate. The National Committee for 
 Amish Religious Freedom called for a boycott of the movie soon after its release, citing fears that these communities were 
 being \"overrun by tourists\" as a result of the popularity of the movie, and worried that \"the crowding, souvenir-hunting, 
 photographing and trespassing on Amish farmsteads will increase.\" After the movie was completed, Pennsylvania governor Dick 
 Thornburgh agreed not to promote Amish communities as future film sites. A similar concern was voiced within the movie 
 itself, where Rachel tells a recovering Book that tourists often consider her fellow Amish something to stare at, with some 
 even being so rude as to trespass on their private property.\n\nLegacy\nNegotiation expert William Ury summarised the film's 
 climactic scene in a chapter titled \"The Witness\" in his 1999 book Getting to Peace (later republished with the 
 alternative title The Third Side: Why We Fight and How We Can Stop) and used the scene as a symbol of the power of ordinary 
 citizens to resolve conflicts and stop violence.\n\nThis scene from the popular movie Witness captures the power of ordinary 
 community members to contain violence. The Amish farmers were present as the third side in perhaps its most elemental form, 
 seemingly doing nothing, but in fact playing the critical role of Witness. Like the Amish, we are all potential 
 Witnesses.\nJapanese filmmaker Akira Kurosawa cited Witness as one of his favorite films of all 
 time.\n\nNotes\nReferences\nSources\nFurther reading\nWahlbrinck, Bernd. WITNESS Revisited: An Appreciation of Peter Weir's 
 Famous Film, Tumbleweed 2020, ISBN 978-3-9821463-5-5\nKelley, William and Earl W. Wallace (based on the screenplay by Earl 
 W. Wallace and William Kelley). Witness, Pocket Books; Media Tie In, 1985  ISBN 978-0671545956\n\nExternal links\n\nWitness 
 at the AFI Catalog of Feature Films\nWitness at IMDb\nWitness at the TCM Movie Database (archived)\nWitness at Box Office 
 Mojo\nWitness at Rotten 
 Tomatoes","url":"https://en.wikipedia.org/wiki/Witness_(1985_film)","sections":[{"title":"Plot","level":0,"text":"In a quiet 
 Amish community outside Lancaster, Pennsylvania, friends and family attend the funeral of Jacob Lapp, leaving behind his 
 wife, Rachel, and eight-year-old son, Samuel. Rachel and Samuel travel by train to visit Rachel's sister, which takes them 
 into Philadelphia. While at the 30th Street Station waiting for a connecting train, Samuel goes into the men's room and 
 witnesses the murder of undercover police officer Detective Ian Zenovich.\nDetective Captain John Book and his partner, 
 Sergeant Elton Carter, are assigned to the case. They question Samuel, who is unable to identify the perpetrator from 
 mugshots or a lineup. Samuel then sees a newspaper clipping in a trophy case of narcotics officer Lieutenant James McFee and 
 points him out to Book as the murderer.\nBook investigates McFee and discovers that he was previously responsible for a 
 seizure of expensive chemicals used to make black-market amphetamine, after which the chemicals disappeared. Book surmises 
 that McFee sold the chemicals back to drug dealers, and Zenovich was investigating. Book expresses his suspicions to Chief 
 of Police Paul Schaeffer, who advises Book to keep the case secret so that they can determine how to proceed. Book is later 
 ambushed in his apartment parking garage by McFee, who shoots and wounds him before fleeing. Since only Schaeffer knew of 
 Book's suspicions, Book realizes that Schaeffer is corrupt and tipped off McFee.\nKnowing that Samuel and Rachel are now in 
 danger, Book orders Carter to hide their police files. He then drives them back to their farm. While beginning his drive 
 back to Philadelphia, he passes out from his wounds and crashes into their birdhouse. Rachel insists that he be taken to a 
 hospital, but Book refuses and states that going there would allow him and, by extension, them to be found. Rachel's 
 father-in-law, Eli, reluctantly agrees to shelter Book.\nBook slowly recovers in their care and begins to blend into the 
 Amish community and lifestyle. He and Rachel develop feelings for each other, which becomes a source of friction for Daniel 
 Hochleitner (a neighbor who had hoped to court Rachel after her husband's death). Book's relationship with the Amish 
 community deepens as they learn that he is skilled at carpentry and seems like a decent, hard-working man. He is invited to 
 participate in a barn raising for a newly-married couple, gaining Hochleitner's respect. However, the attraction between 
 Book and Rachel is evident and causes gossip in the tight-knit community.\nMeanwhile, Schaeffer searches for Book by 
 contacting authorities in the Amish area. However, since Amish communities have no modern means of communication and little 
 contact with the outside world, he hits repeated dead ends.\nWhen Book goes into town with Eli to use a payphone to call his 
 precinct, he learns that Carter was killed in the line of duty. Realizing that Schaeffer was behind it, Book calls him at 
 his home (where the call cannot be traced), chastises him for being corrupt and threatens to kill him. As they leave town, a 
 group of locals harass the Amish. Book retaliates, breaking with the Amish tradition of non-violence. The assault is 
 reported to the local police, and word eventually gets back to Schaeffer.\nUpset with Book over the assault, Eli orders him 
 to leave. Rachel approaches Book in a field, where they passionately embrace, finally acting on their feelings. Soon after 
 this, Schaeffer, McFee and another corrupt cop, Sergeant Leon \"Fergie\" Ferguson, arrive at the Lapp farm and take Rachel 
 and Eli hostage. Eli manages to alert Book, and Book tells Samuel to hide at Hochleitner's farm. Book tricks Fergie into the 
 corn silo and suffocates him under tons of corn, then uses Fergie's shotgun to kill McFee. Schaeffer holds Rachel and Eli at 
 gunpoint, but Samuel secretly comes back to ring the Lapp farm's bell. Book confronts Schaeffer, who threatens to kill 
 Rachel, but the bell has alerted and summoned all of the neighbors. With so many witnesses present, Schaeffer surrenders and 
 is later arrested.\nWith Rachel and Samuel no longer in danger, Book departs for Philadelphia, bidding farewell. Before he 
 drives off, Eli wishes Book well by saying, \"You be careful out there among them 
 English.”","sections":[]},{"title":"Cast","level":0,"text":"Per the film's end 
 credits:","sections":[]},{"title":"Themes","level":0,"text":"In his book The Amish in the American Imagination (2001), 
 scholar David Weaver-Zercher notes that Witness is primarily concerned with the intersection of contrasting cultures, a 
 recurring theme in several of Weir's films, including The Last Wave (1977) and The Year of Living Dangerously (1982). 
 Weaver-Zercher notes that the conflict between Amish and non-Amish as depicted in Witness \"reflect[s] well on the Amish 
 ways\" and also serves as a redemption story for Captain Book, who regains a new sense of humanity during his displacement 
 in the Amish 
 community.","sections":[]},{"title":"Production","level":0,"text":"","sections":[{"title":"Development","level":1,"text":"Pr 
 oducer Edward S. Feldman, who was in a \"first-look\" development deal with 20th Century Fox at the time, first received the 
 screenplay for Witness in 1983. Originally titled Called Home, which is the Amish term for death, it ran for 182 pages, the 
 equivalent of three hours of screen time. The script, which had been circulating in Hollywood for several years, began with 
 an idea by novelist Pamela Wallace for a novel about an Amish woman who witnesses a murder in Los Angeles. Earl W. Wallace, 
 who wrote for the television Western How the West Was Won recalled an episode with a similar plot and contacted its writer, 
 William Kelley. Kelley had reworked the plot for the show from a script he had written for a 1972 episode of Gunsmoke. Earl 
 Wallace and Kelley wrote the original screenplay together.\nFeldman liked the concept, but felt too much of the script was 
 devoted to Amish traditions, diluting the thriller aspects of the story. He offered Kelley and Wallace $25,000 for a 
 one-year option and one rewrite, and an additional $225,000 if the film actually were made. They submitted the revised 
 screenplay in less than six weeks, and Feldman delivered it to Fox. Joe Wizan, the studio's head of production, rejected it 
 with the statement that Fox did not make \"rural movies\".\nFeldman sent the screenplay to Harrison Ford's agent Phil Gersh, 
 who contacted the producer four days later and advised him his client was willing to commit to the film. Certain the 
 attachment of a major star would change Wizan's mind, Feldman approached him once again, but Wizan insisted that as much as 
 the studio liked Ford, they still were not interested in making a \"rural movie\".\nFeldman sent the screenplay to numerous 
 studios, and was rejected by all of them, until Paramount Pictures finally expressed interest. Feldman's first choice of 
 director was Peter Weir, but he was involved in preproduction work for The Mosquito Coast and passed on the project. John 
 Badham dismissed it as \"just another cop movie\", and others Feldman approached either were committed to other projects or 
 had no interest. Then, as financial backing for The Mosquito Coast fell through, Weir became free to direct Witness, which 
 was his first American film. Starting the film immediately was imperative, because a Directors Guild of America (DGA) strike 
 was looming. David Cronenberg was offered the role of director, but declined as he \"could never be a fan of the 
 Amish\".","sections":[]},{"title":"Casting","level":1,"text":"Lynne Littman had originally been in talks to direct the film, 
 and though she ultimately did not, she recommended Lukas Haas for the part of Samuel, because she had recently worked with 
 him on her film Testament. The role of Rachel was the most difficult to cast, and after Weir grew frustrated with the 
 auditions he had seen, he asked the casting director to look for actors in Italy, because he thought they would be more 
 \"womanly\". As they were reviewing audition tapes from Italy, Kelly McGillis came to audition, and the moment she put on 
 the bonnet and spoke a few lines, Weir knew she was the one. The casting director recommended her old friend Alexander 
 Godunov, who had never acted before, but she thought his personality would be right, and Weir agreed.\nViggo Mortensen was 
 cast because Weir thought he had the right face for the part of an Amish man. Mortensen had just started his acting career, 
 so this was his first film acting role, and he had to turn down another role as a soldier in Shakespeare in the Park's 
 production of Henry V. He credited that decision and the very positive experience on the film as the start of his film 
 career.","sections":[]},{"title":"Pre-production","level":1,"text":"During the weeks before filming, Ford spent time with 
 the homicide department of the Philadelphia Police Department, researching the important details of working as a homicide 
 detective. McGillis did research by moving in with an Amish widow and her seven children, learning how to milk cows and 
 practicing their Pennsylvania German dialect.\nWeir and cinematographer John Seale went on a trip to the Philadelphia Museum 
 of Art, which was running an exhibition of 17th-century Dutch Masters. Weir drew attention to the paintings of Johannes 
 Vermeer, which were used as inspiration for the lighting and composition of the film, especially in the scenes where John 
 Book is recovering from a gunshot wound in Rachel's house.","sections":[]},{"title":"Filming","level":1,"text":"Principal 
 photography took place between April 27, 1984 and June 29, 1984. The film was shot on location in Philadelphia and the city 
 and towns of Intercourse, Lancaster, Strasburg, and Parkesburg. Local Amish were willing to work as carpenters and 
 electricians, but declined to appear on film, so many of the extras were actually Mennonites. Halfway through filming, the 
 title was changed from Called Home to Witness at the behest of Paramount's marketing department, which felt the original 
 title posed too much of a promotional challenge. Principal photography was completed three days before the scheduled DGA 
 strike, which ultimately failed to materialize.\nDuring the set-up and rehearsal of each scene, as well as during dailies, 
 Weir would play music to set the mood, with the idea that it prevented the actors from thinking too much and let them listen 
 to their other instincts. The barn-raising scene was only a short paragraph in the script, but Weir thought it was important 
 to highlight that aspect of Amish community life. They shot the scene in a day and did, in fact, build a barn, albeit with 
 the aid of cranes off-camera. To film the scene in the corn silo, corn was actually dropped onto the actor, while a scuba 
 diving regulator with a compressed air tank was hidden on the floor so the actor would be able to breathe.\nOriginally, the 
 script ended with a scene of Book and Rachel each explaining their feelings for each other to the audience, but Weir felt 
 the scene was unnecessary and decided not to shoot it. The studio executives were concerned that the audience would not 
 understand the conclusion, and tried to convince him otherwise, but Weir insisted that the characters' emotions could be 
 expressed only with visuals.","sections":[]}]},{"title":"Release","level":0,"text":"Witness had its world premiere at the 
 Fulton Opera House in Lancaster, Pennsylvania in on February 7, 1985. The film was screened out of competition at the 1985 
 Cannes Film Festival.","sections":[{"title":"Box office","level":1,"text":"The film opened theatrically in 876 theaters in 
 the United States on February 8, 1985, and grossed $4,539,990 in its opening weekend, ranking number two behind Beverly 
 Hills Cop. The film went on to become a sleeper hit, topping the charts in its fifth week of release. It eventually earned a 
 total of $68,706,993 in North America. Internationally, it grossed $47.4 million for a worldwide total of $116.1 
 million.","sections":[]},{"title":"Home media","level":1,"text":"Paramount Home Entertainment released Witness on VHS, with 
 a DVD in initially in 1999 and then in 2005, along with a Blu-ray Disc in 2015.\nBritish boutique label Arrow Films released 
 the film in the United States on 4K Ultra HD disc and remastered Blu-ray on October 31, 
 2023.","sections":[]}]},{"title":"Reception","level":0,"text":"Witness received critical acclaim, with particular praise 
 towards Ford's performance. Roger Ebert of the Chicago Sun-Times rated the film four out of four stars, calling it: [F]irst 
 of all, an electrifying and poignant love story. Then it is a movie about the choices we make in life and the choices that 
 other people make for us. Only then is it a thriller—one that Alfred Hitchcock would have been proud to make... We have 
 lately been getting so many pallid, bloodless little movies—mostly recycled teenage exploitation films made by ambitious 
 young stylists without a thought in their heads—that Witness arrives like a fresh new day. It is a movie about adults whose 
 lives have dignity and whose choices matter to them. And it is also one hell of a thriller. Ebert also praised Ford's work 
 and believed he had \"never given a better performance in a movie.\"\nVincent Canby of The New York Times was much more 
 negative, saying of the film:\n\nIt's not really awful, but it's not much fun. It's pretty to look at and it contains a 
 number of good performances, but there is something exhausting about its neat balancing of opposing manners and values... 
 One might be made to care about all this if the direction by the talented Australian film maker, Peter Weir... were less 
 perfunctory and if the screenplay... did not seem so strangely familiar. One follows Witness as if touring one's old 
 hometown, guided by an outsider who refuses to believe that one knows the territory better than he does. There's not a 
 character, an event, or a plot twist that one hasn't anticipated long before its arrival, which gives one the feeling of 
 waiting around for people who are always late.\nVariety said the film was \"at times a gentle, affecting story of 
 star-crossed lovers limited within the fascinating Amish community. Too often, however, this fragile romance is crushed by a 
 thoroughly absurd shoot-'em-up, like ketchup poured over a delicate Pennsylvania Dutch dinner.\"\nTime Out New York 
 observed, \"Powerful, assured, full of beautiful imagery and thankfully devoid of easy moralizing, it also offers a 
 performance of surprising skill and sensitivity from Ford.\"\nHalliwell's Film Guide chose Witness as one of only two films 
 from 1985 to receive a four-star review, describing it as \"one of those lucky movies which works out well on all counts and 
 shows that there are still craftsmen lurking in Hollywood.\"\nRadio Times called the film \"partly a love story and partly a 
 thriller, but mainly a study of cultural collision – it's as if the world of Dirty Harry had suddenly stumbled into a canvas 
 by Brueghel.\" It added, \"[I]t's Weir's delicacy of touch that impresses the most. He ably juggles the various elements of 
 the story and makes the violence seem even more shocking when it's played out on the fields of Amish denial.\"\nOn Rotten 
 Tomatoes the film scores 92% based on 49 reviews. Its Metacritic score is 76 out of 100 based on 14 critics.\nIn 2006, 
 Writers Guild of America West ranked its screenplay 80th in WGA’s list of 101 Greatest 
 Screenplays.","sections":[{"title":"Accolades","level":1,"text":"","sections":[]},{"title":"Controversy","level":1,"text":"L 
 eading up to and following its release, Witness was met with controversy from the Amish communities where it was filmed, and 
 was subject to debate from editors, scholars, and other parties regarding its depiction of the Amish. Some accused the film 
 of exploiting the Amish community for commercial purposes, while others felt that the depiction of Amish characters in an 
 R-rated film was insensitive to the Amish's beliefs.\nA statement released by a law firm associated with the Amish claimed 
 that their portrayal in the movie was not accurate. The National Committee for Amish Religious Freedom called for a boycott 
 of the movie soon after its release, citing fears that these communities were being \"overrun by tourists\" as a result of 
 the popularity of the movie, and worried that \"the crowding, souvenir-hunting, photographing and trespassing on Amish 
 farmsteads will increase.\" After the movie was completed, Pennsylvania governor Dick Thornburgh agreed not to promote Amish 
 communities as future film sites. A similar concern was voiced within the movie itself, where Rachel tells a recovering Book 
 that tourists often consider her fellow Amish something to stare at, with some even being so rude as to trespass on their 
 private property.","sections":[]}]},{"title":"Legacy","level":0,"text":"Negotiation expert William Ury summarised the film's 
 climactic scene in a chapter titled \"The Witness\" in his 1999 book Getting to Peace (later republished with the 
 alternative title The Third Side: Why We Fight and How We Can Stop) and used the scene as a symbol of the power of ordinary 
 citizens to resolve conflicts and stop violence.\n\nThis scene from the popular movie Witness captures the power of ordinary 
 community members to contain violence. The Amish farmers were present as the third side in perhaps its most elemental form, 
 seemingly doing nothing, but in fact playing the critical role of Witness. Like the Amish, we are all potential 
 Witnesses.\nJapanese filmmaker Akira Kurosawa cited Witness as one of his favorite films of all 
 time.","sections":[]},{"title":"Notes","level":0,"text":"","sections":[]},{"title":"References","level":0,"text":"","section 
 s":[]},{"title":"Sources","level":0,"text":"","sections":[]},{"title":"Further reading","level":0,"text":"Wahlbrinck, Bernd. 
 WITNESS Revisited: An Appreciation of Peter Weir's Famous Film, Tumbleweed 2020, ISBN 978-3-9821463-5-5\nKelley, William and 
 Earl W. Wallace (based on the screenplay by Earl W. Wallace and William Kelley). Witness, Pocket Books; Media Tie In, 1985 
 ISBN 978-0671545956","sections":[]},{"title":"External links","level":0,"text":"\nWitness at the AFI Catalog of Feature 
 Films\nWitness at IMDb\nWitness at the TCM Movie Database (archived)\nWitness at Box Office Mojo\nWitness at Rotten 
 Tomatoes","sections":[]}],"categories":["Category:1985 American films","Category:1985 crime drama films","Category:1985 
 films","Category:All Wikipedia articles written in American English","Category:All accuracy disputes","Category:All articles 
 with unsourced statements","Category:American crime drama films","Category:American neo-noir films","Category:American 
 police detective films","Category:American thriller films","Category:Amish in films","Category:Articles with disputed 
 statements from September 2025","Category:Articles with short description","Category:Articles with unsourced statements from 
 September 2022","Category:CS1 maint: bot: original URL status unknown","Category:CS1 maint: deprecated archival 
 service","Category:Edgar Award–winning works","Category:Fictional portrayals of the Philadelphia Police 
 Department","Category:Films about families","Category:Films about grief","Category:Films about mother–son 
 relationships","Category:Films about murder","Category:Films about police misconduct","Category:Films about witness 
 protection","Category:Films directed by Peter Weir","Category:Films produced by Edward S. Feldman","Category:Films scored by 
 Maurice Jarre","Category:Films set in 1984","Category:Films set in Pennsylvania","Category:Films set in 
 Philadelphia","Category:Films set on farms","Category:Films shot in Philadelphia","Category:Films whose editor won the Best 
 Film Editing Academy Award","Category:Films whose writer won the Best Original Screenplay Academy Award","Category:Paramount 
 Pictures films","Category:Rail transport films","Category:Rotten Tomatoes ID same as Wikidata","Category:Short description 
 is different from Wikidata","Category:Template film date with 1 release date","Category:Use American English from January 
 2025","Category:Use mdy dates from August 2020"],"links":["/Film","12 Angry Men","1985 Cannes Film Festival","20th Century 
 Studios","30th Street Station","3 to Go","58th Academy Awards","AFI Catalog of Feature Films","A Man and a Woman","Academy 
 Award for Best Actor","Academy Award for Best Cinematography","Academy Award for Best Director","Academy Award for Best Film 
 Editing","Academy Award for Best Original Score","Academy Award for Best Original Screenplay","Academy Award for Best 
 Picture","Academy Award for Best Production Design","Akira Kurosawa","Alain Silver","Alexander Godunov","Alfred 
 Hitchcock","Amazon (company)","American Cinema Editors","Amish","Amphetamine","Angus MacInnes","Arrow 
 Films","Assault","Australian Cinematographers Society","BAFTA Award for Best Actor in a Leading Role","BAFTA Award for Best 
 Actress in a Leading Role","BAFTA Award for Best Cinematography","BAFTA Award for Best Editing","BAFTA Award for Best 
 Film","BAFTA Award for Best Original Music","BAFTA Award for Best Original Screenplay","Barn raising","Beverly Hills 
 Cop","Birdhouse","Black Swan (film)","Blu-ray","Blue Ribbon Award for Best Foreign Film","Bobbie Wygant","Bohemian Rhapsody 
 (film)","Box Office Mojo","Brent Jennings","British Academy Film Awards","British Board of Film Classification","British 
 Society of Cinematographers","Chicago Sun-Times","Conclave (film)","Conversation Piece (film)","Crime 
 film","DVD","Dailies","Dancer in the Dark","Danny Glover","David Cronenberg","Dead Poets Society","Dick Thornburgh","Die 
 Hard","Directors Guild of America","Directors Guild of America Award for Outstanding Directing – Feature Film","Dirty 
 Harry","District 9","Donald Kraybill","Dreamgirls (film)","E.T. the Extra-Terrestrial","Earl W. Wallace","East of Eden 
 (film)","Edward S. Feldman","Extra (acting)","Faber and Faber","Fearless (1993 film)","Field of Dreams","Flags of Our 
 Fathers (film)","Flashdance","Forbidden Games","Frederick Rolf","Fulton Opera House","Gallipoli (1981 film)","Gervaise 
 (film)","Golden Globe Award for Best Actor – Motion Picture Drama","Golden Globe Award for Best Director","Golden Globe 
 Award for Best Motion Picture – Drama","Golden Globe Award for Best Original Score","Golden Globe Award for Best 
 Screenplay","Golden Globe Award for Best Supporting Actress – Motion Picture","Golden Globe Awards","Grain 
 entrapment","Grammy Award for Best Score Soundtrack for Visual Media","Grammy Awards","Gran Torino","Gravity (2013 
 film)","Green Card (film)","Gunsmoke","Harrison Ford","Henry V (play)","Hidden Figures","Homesdale"],"exists":true} 

ASSISTANT: 1985年公開のアメリカ映画『刑事ジョン・ブック目撃者』(原題: Witness)についてまとめます。

【あらすじ】 フィラデルフィアの駅で、ある殺人事件を偶然目撃したアーミッシュの少年サミュエル。彼を保護することになった刑事ジョン・ブックは、警察内部に犯人と繋がる腐敗した権力があることを突き止めます。身の危険を感じたブックは、サミュエルと母レイチェルを連れて、外部との接触を断ったアーミッシュのコミュニティへ逃げ込みます。静謐な村での生活を通じて、ブックは彼らの価値観に触れ、レイチェルとの間に愛が芽生えますが、執拗に追う腐敗警官たちの手が及ぼうとしていました。

【監督・主なキャスト】

  • 監督: ピーター・ウィアー
  • 主な登場人物・キャスト:
    • ジョン・ブック刑事:ハリソン・フォード
    • レイチェル(サミュエルの母):ケリー・マクギリス
    • サミュエル:ルーカス・ハース

【受賞歴】 第58回アカデミー賞で8部門にノミネートされ、「脚本賞」「編集賞」を受賞しました。また、BAFTA賞ではモーリス・ジャールによる音楽が評価され、「最優秀音楽賞」を受賞しています。


ツールとしてwikipedia_mcp_search_wikipediawikipedia_mcp_get_articleを実行後に上記の出力が得られた。かなり時間はかかるが内容的には完璧である👍✨ wikipedia-mcp-serverwikipedia-mcpのインストール方法は別の記事としてまとめる予定。

感想

AIエージェントにこのレベルの調べごとをさせるならもう少し早いマシンが欲しくなる。MINISFORUM MS-S1 MAXgemma-4-31B-it-Q4_K_Mで11トークン/秒くらい出るらしい。これはLM-790Proの約4倍の速度だ。AMD Ryzen AI Haloもアメリカでは販売開始した。これもRyzen AI MAX +395という同じSoC(System on a Chip)だから同じくらいの速度だろう。

日本で販売開始されるのは秋頃といううわさがある。米国価格4,000ドルは為替レート163円/ドルとしても652,000円である。高いよな〜。でも今から40年前に発表された初代マッキントッシュ(Macintosh 128K)は698,000円だった。メモリサイズが10の6乗倍(10万倍)、演算性能はおそらく10の8乗倍(1000万倍)でも同じ価格と思えば妥当な価格なのかな〜。

docker環境で「言語処理100本ノック」を試す

家族で果実園でランチ。ランチメニューのあとでフルーツパフェを食す。フルーツパーラーに入るのもフルーツパフェを食べるのも私の人生で初だと思うので本記事と無関係だが記念に写真をアップする。パフェはかなりのボリュームがあり家族でシェアした。ランチメニューのあと一人で食べるには大きい。2人くらいでシェアしてちょうどいいボリュームかと思う。

本題に戻す。

AIエージェントに「言語処理100本ノック」の課題を解かせるためsandbox(日本語で砂場?)が必要になった。sandboxとはAIエージェントがroot権限でコマンドを自由に実行できる環境のことである。sandboxとしてdockerイメージ(リポジトリともいう)を作成し、課題ごとにdocker環境(コンテナともいう)を起動する環境をようやく整えることができた。

環境設定、起動方法などの備忘録的メモ

私が今愛用しているモデルはローカルで動作するgemma-4-26B-A4Bである。このモデルでいくつかの課題を解かせたところ、このクラスであれば問題なく課題を理解し処理できることが分かった。

AIエージェントの解いた結果だけ書くのも味気ないので結果は記事の最後に載せるとして、環境設定、起動方法などについてメモしておきたい。これも興味のない方には退屈な内容かと思うが、書いておかないと私自身がすぐに忘れてしまうので😅

環境設定

  • 作業用ディレクトリ

    • 作業用ディレクトリがdockerの/workspaceにマウントされる。
    • 今回は「言語処理100本ノック」課題8用にpi-nlp100-8を用意した。
  • システムプロンプト

    • pi-nlp100-8/.ai/SYSTEM.mdに用意。以下のように設定した。
あなたは優秀なアシスタントです。
Userへの回答は日本語を使用してください。
作業を進める上で複数の選択肢が考えられ、その選択により作業規模や作業効率が大きく変わるような場合には、事前にどの選択肢で進めるかをUserに相談してください。
  • 使用モデル定義
    • llama-serverの使用モデルをpi- nlp100-8/.pi/agent/models.jsonに定義。
    • ホームディレクトリの~/.pi/agent/models.jsonと別に定義することでdocker用とオリジナル用を併用できる。
    • 以下のように設定した。/modelコマンドでモデルを切り替えることができる。(※注:AIサーバーの再起動も必要)
{
  "providers": {
    "llama-server": {
      "baseUrl": "http://host.docker.internal:8080/v1",
      "api": "openai-completions",
      "apiKey": "llama-server",
      "compat": {
        "supportsDeveloperRole": false
      },
      "models": [
        {
          "id": "unsloth/gemma-4-26B-A4B-it-GGUF",
          "name": "gemma-4-26B(Local)"
        },
        {
          "id": "unsloth/Qwen3.6-35B-A3B-GGUF",
          "name": "Qwen3.6-35B-A3B(Local)"
        }
      ]
    }
  }
}
  • Pi Agent作業用コンテナ
    • 未作成の場合は以下の作業が必要。詳細は先日の記事を参照。
      • dockerイメージのビルド ※pi-agent用にdockerfileからイメージをビルド
      • コンテナの作成 ※課題ごとにdockerイメージからコンテナを作成

起動方法

Pi Agent作業用コンテナが作成済みであれば以下の手順で起動する。

  • AIサーバーの起動
    • 私の場合はllama-serverを起動している。AIモデルを指定して起動する。
  • 作業用コンテナの起動
  • pI Agentの起動
    • piまたはpi -r

運用方法

  • 不要コンテナの削除
    • 間違って作成したコンテナ、不要なコンテナは以下のコマンドで削除できる。
    • コンテナID、コンテナ名はdocker psまたはdocker ps -aで確認できる。
$ docker rm -f コンテナIDまたはコンテナ名
  • コンテナ名の変更
    • docker runコマンドでコンテナを作成するとコンテナ名は自動生成される。
    • 後で管理しやすいようにコンテナ名を変更しておくこと。以下のコマンドで変更できる。
$ docker rename 現在のコンテナ名 変更後のコンテナ名
  • Pi Agentセッションのマークダウン出力
    • /mdコマンドでセッションがマークダウンで出力される。
    • 出力先は~/.pi/agent/pi-session-extracted/またはクリップボード。
    • 本機能は拡張機能pi-md-exportのインストールが必要。インストールコマンドはpi install npm:pi-md-export

課題8「機会学習」の結果

システムプロンプトの設定によりAIは作業中にも適宜作業方針を確認してくれるようになった。 Python環境が導入済みかAIが確認しようとしていたので以下のように指示した。

USER: Pythonはインストールされていないため仮想環境にPythonをインストールしていいです

これにより無駄な作業を省略できた。これ以下はずっと「進めてください」と指示するだけだった。 トータルで1時間程度で10個の課題を全て完了したので一つひとつの課題にかかる時間は5分程度だったと思う。

課題8の「機械学習」を解かせたセッションをマークダウン出力したのでセッション内容を以下に貼り付ける。


PI SESSION (processed) mode: branch leaf: 2580be49 id: 019f7de2-c04a-70bf-b0e7-69016f323d2d started: 2026-07-20T04:57:20.202Z cwd: ~/pj/node-js/pi-nlp100-8 source: ~/.pi/agent/sessions/--home-pj-node-js-pi-nlp100-8--/2026-07-20T04-57-20-202Z_019f7de2-c04a-70bf-b0e7-69016f323d2d.jsonl

USER: hello!

ASSISTANT: こんにちは!何かお手伝いできることはありますか?

USER: 自己紹介してください

ASSISTANT: 私は、Googleによってトレーニングされた、大規模な言語モデルです。

特定の「個人」ではありませんが、以下のような特徴を持っています。

🚀 私ができること

  • 質問への回答: 歴史、科学、文化、日常的な疑問など、幅広い知識に基づいた回答を生成します。
  • 文章の作成・編集: メール、レポート、物語、詩の作成から、文章の校正や要約まで行えます。
  • プログラミングのサポート: コードの記述、デバッグ、アルゴリズムの解説など、技術的な質問にお答えします。
  • 翻訳: 多様な言語間での翻訳をサポートします。
  • アイデア出し: 企画のブレインストーミングや、新しいプロジェクトの提案など、クリエイティブなパートナーとして機能します。

🛠 私のスタイル

  • 丁寧かつ正確に: ユーザーの意図を汲み取り、分かりやすく正確な情報を提供することを目指しています。
  • 柔軟な対応: フォーマルなトーンから、親しみやすい会話形式まで、指示に合わせてスタイルを変えられます。
  • 継続的な学習: 常に新しい情報を処理し、より高度な対話ができるよう設計されています。

⚠️ 注意点

  • 情報の正確性: 非常に高い精度を目指していますが、時には誤った情報(ハルシネーション)を提供してしまう可能性があります。重要な判断が必要な場合は、必ず公式な情報源で確認をお願いします。
  • 感情や意識: 私は高度な計算に基づいてテキストを生成していますが、人間のような感情、意識、個人的な経験を持っているわけではありません。

何か具体的な作業や、知りたいことがあれば、いつでもお気軽に話しかけてくださいね!

USER: 言語処理を志す人を対象としたプログラミングのトレーニング問題集「言語処理100本ノック2015」の中から「機械学習」の課題を与える。 nlp100-8.mdを読み課題70から課題79に対応するプログラムを実装し、正しく処理できることを確認せよ。

ASSISTANT: 了解いたしました。「言語処理100本ノック2015」の「機械学習」セクション(課題70〜79)の実装ですね。

作業を開始する前に、現在の環境を確認し、進め方についてご相談させてください。

1. 現状の確認

まず、対象となるファイル nlp100-8.md が存在するか、およびその内容を確認する必要があります。以下のコマンドを実行して確認します。

ASSISTANT: ファイルの内容を確認しました。課題は「Movie Review Data」を用いた、文の極性分析(ポジティブ/ネガティブ分類)ですね。

実装を進めるにあたり、作業規模と効率に関する重要な相談があります。

相談事項:データの入手と実装方針について

この課題を完遂するには、以下の2つのステップが必要です。

1. データの準備(課題70に関連)

課題70では、外部サイトから rt-polaritydata.tar.gz をダウンロードして解凍し、sentiment.txt を作成する必要があります。

  • 選択肢A(推奨): 私がプログラム(Python)を書き、そのプログラムを実行してデータをダウンロード・解凍・整形まで自動で行う。

  • 選択肢B: ユーザー側でデータを準備し、ファイルパスを指定して実装を進める。

推奨理由: 課題70自体が「データの入手・整形」というプログラミング課題であるため、選択肢Aで進めることで、環境構築から一貫して動作を確認できます。

2. 実装の進め方

課題72以降(素性抽出・学習・予測など)は、機械学習ライブラリ(scikit-learn など)を使用するのが一般的ですが、どのような構成で進めるべきでしょうか?

  • 選択肢C(スクリプト分割型): 各課題(70, 71, 72...)ごとに、独立した .py ファイルを作成していく。
    • メリット: 各課題の要件が明確になり、テストがしやすい。
  • 選択肢D(統合パイプライン型): 1つの大きなスクリプト、またはモジュール構成にして、データの準備からグラフ描画まで一連の流れとして実装する。
    • メリット: 機械学習のワークフロー(前処理 $\to$ 学習 $\to$ 評価)として理解しやすい。

提案: 私は 「選択肢A + 選択肢C」 の組み合わせを提案します。 具体的には、以下の手順で進めます。

  1. task70.py を作成し、データのダウンロードから sentiment.txt の作成までを行う。
  2. 順次、task71.py, task72.py... と、課題番号に対応したファイルを作成していく。
  3. 各ステップで、課題が要求する出力(正例の数、テスト結果、モデルの重み、グラフなど)が正しく得られるかを確認する。

この方針で進めてよろしいでしょうか? 「まずは課題70から始めてほしい」「ライブラリはこれを使ってほしい」などのご要望があれば教えてください。

USER: 進めてください

ASSISTANT: 承知いたしました。それでは、「選択肢A(自動データ取得)+ 選択肢C(課題ごとの個別実装)」の方針で進めていきます。

まずは、課題70「データの入手・整形」から着手します。

課題70: データの入手・整形

この課題では、以下の作業を行います。 1. 指定されたURLから rt-polaritydata.tar.gz をダウンロードする。 2. 解凍して rt-polarity.posrt-polarity.neg を取り出す。 3. 各行の先頭にラベル(+1 または -1)を付与する。 4. データを結合し、ランダムにシャッフルして sentiment.txt として保存する。 5. 正例と負例の数を確認する。

まず、必要なライブラリ(requests など)が利用可能か確認しつつ、実装を行います。

import os
import tarfile
import requests
import random

def task70():
    url = "http://www.cs.cornell.edu/people/pabo/movie-review-data/rt-polaritydata.tar.gz"
    archive_name = "rt-polaritydata.tar.gz"
    extract_dir = "rt-polaritydata"
    output_file = "sentiment.txt"

    # 1. データのダウンロード
    if not os.path.exists(archive_name):
        print(f"Downloading {url}...")
        response = requests.get(url)
        with open(archive_name, "wb") as f:
            f.write(response.content)
        print("Download complete.")
    else:
        print(f"{archive_name} already exists.")

    # 2. 解凍
    if not os.path.exists(extract_dir):
        print(f"Extracting {archive_name}...")
        with tarfile.open(archive_name, "r:gz") as tar:
            tar.extractall()
        print("Extraction complete.")
    else:
        print(f"Directory {extract_dir} already exists.")

    # 3 & 4. データの整形と結合
    print("Formatting data...")
    pos_lines = []
    neg_lines = []

    # rt-polarity.pos の読み込み
    # 解凍後のパスを確認する必要があるため、一旦中身を探索
    pos_path = os.path.join(extract_dir, "rt-polarity.pos")
    neg_path = os.path.join(extract_dir, "rt-polarity.neg")

    with open(pos_path, "r", encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if line:
                pos_lines.append(f"+1 {line}")

    with open(neg_path, "r", encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if line:
                neg_lines.append(f"-1 {line}")

    # 結合してシャッフル
    all_lines = pos_lines + neg_lines
    random.shuffle(all_lines)

    # sentiment.txt に書き出し
    with open(output_file, "w", encoding="utf-8") as f:
        for line in all_lines:
            f.write(line + "\n")
    
    print(f"Created {output_file}")

    # 5. 正例と負例の数の確認
    pos_count = sum(1 for line in all_lines if line.startswith("+1"))
    neg_count = sum(1 for line in all_lines if line.startswith("-1"))

    print(f"Positive samples: {pos_count}")
    print(f"Negative samples: {neg_count}")

    return pos_count, neg_count

if __name__ == "__main__":
    task70()

それでは、このコードを task70.py として保存し、実行します。

ASSISTANT: 申し訳ありません。環境を確認したところ、python3 コマンドが見つからないようです。まず、利用可能なコマンドを確認します。

ASSISTANT: 申し訳ありません。実行環境に python または python3 が直接パスに通っていない、あるいはインストールされていない可能性があります。

まず、環境を調査するために以下のコマンドを試みます。

  1. env でパスを確認する
  2. pythonpython3 がどこにあるか、あるいは他の名前(ipython など)で利用可能か探る

もしPython環境が全く利用できない場合は、この環境での課題遂行が難しくなります。

確認コマンド:

ASSISTANT: 大変失礼いたしました。現在のコンテナ環境には python がインストールされていないようです。

しかし、このタスクは「言語処理」の課題であり、通常は Python を用いて行われます。環境を再確認し、Python をインストールできるか、あるいは最初から入っているはずのパスを再度探ります。

一度、ls / でシステム全体をざっと見てみます。また、pipconda があるかどうかも確認します。

USER: Pythonはインストールされていないため仮想環境にPythonをインストールしていいです

ASSISTANT: 承知いたしました。仮想環境を作成し、Pythonをインストールして作業を進めます。 まずは、Pythonをインストールするための手段(pyenvconda、あるいは apt など)を確認しつつ、環境構築を進めます。

現在の環境で apt が使えるか確認し、Pythonをインストールします。

手順

  1. apt-get update を実行。
  2. python3 および python3-pip, python3-venv をインストール。
  3. 仮想環境 venv を作成。
  4. 仮想環境を有効化し、必要なライブラリ(requests, scikit-learn, pandas, numpy, matplotlib, nltk など)をインストール。

まずは apt-get の確認から始めます。

USER: 進めてください

ASSISTANT: Python3のインストールが完了しました!

次に、仮想環境を作成し、必要なライブラリをインストールします。

手順

  1. python3 -m venv venv で仮想環境を作成。
  2. venv/bin/pip install requests scikit-learn pandas numpy matplotlib nltk を実行。

ライブラリのインストールには少し時間がかかるかもしれません。

nltk は課題72のステミング処理などで使う可能性があるため、あらかじめ入れておきます。また、scikit-learn は課題73のロジスティック回帰に必須です。

USER: 進めてください

ASSISTANT: 環境構築が完了しました!

それでは、改めて 課題70 を実行して、データの準備を完了させます。 先ほど作成した task70.py を、新しく作成した仮想環境の Python で実行します。

USER: 進めてください

ASSISTANT: 申し訳ありません。UnicodeDecodeError が発生しました。 原因は、ダウンロードした rt-polarity.pos および neg ファイルが UTF-8 ではなく、別のエンコーディング(恐らく ISO-8859-1 または Latin-1)で保存されているためです。

映画のレビューデータには特殊文字が含まれることが多いため、エンコーディングを latin-1 に変更して、再度 task70.py を修正して実行します。

修正内容

  • open(..., encoding="utf-8")open(..., encoding="latin-1") に変更。

修正して再度実行します。

USER: 進めてください

ASSISTANT: 課題70が成功しました!

課題70の結果: * sentiment.txt が作成されました。 * 正例(Positive): 5331 件 * 負例(Negative): 5331 件

これで、機械学習のためのデータ準備が整いました。次は 課題71「ストップワード」 に進みます。

課題71: ストップワード

要件: 1. 英語のストップワードのリストを作成する。 2. 引数に与えられた単語がストップリストに含まれているか判定する関数を実装する。 3. その関数に対するテストを記述する。

実装を開始します。

USER: 進めてください

ASSISTANT: 課題71が完了しました!

実装内容: * is_stopword 関数を実装。 * 単語の比較時に .lower() を使用することで、大文字小文字の区別なく判定できるようにしました。 * unittest を用いて、「含まれる場合」「含まれない場合」「大文字小文字の揺れ」の3つのテストケースをパスすることを確認しました。


次は 課題72「素性抽出」 に進みます。

課題72: 素性抽出

要件:

  • 極性分析に有用そうな素性を設計し、学習データ(sentiment.txt)から抽出する。

  • 最低限のベースラインとして、「ストップワードの除去」および「ステミング(Stemming)処理」を行う。

設計方針:

  1. 前処理:

    • 小文字化
    • 記号・数字の除去
    • トークナイズ(単語分割)
    • ストップワードの除去
    • ステミング(nltkPorterStemmer を使用)
  2. 素性化:

    • 各文を単語の集合(Bag of Words)として扱い、各単語を素性とする。

実装を開始します。まずは、本格的なストップワードリストを準備し、nltk のデータもダウンロードしておく必要があります。

USER: 進めてください

ASSISTANT: 課題72が完了しました!

実装内容:

  • FeatureExtractor クラスを作成。

  • 前処理の流れ: 小文字化 $\to$ 正規表現による単語抽出 $\to$ ストップワード除去 $\to$ PorterStemmer によるステミング。

  • データ読み込み: sentiment.txt を読み込み、ラベル(1 または -1)と、抽出された単語リストのペアを返します。

  • テスト結果: Original: The movies are absolutely wonderful and amazing! に対して ['movi', 'absolut', 'wonder', 'amaz'] と正しくステミングされた単語が得られることを確認しました。


次は 課題73「学習」 に進みます。

課題73: 学習

要件:

  • 72で抽出した素性を用いて、ロジスティック回帰モデルを学習せよ。

実装方針:

  1. scikit-learnLogisticRegression を使用します。

  2. テキスト(単語の集合)を数値ベクトルに変換するために CountVectorizer または TfidfVectorizer を使いたいところですが、すでに task72.py で「ステミング済みの単語リスト」という素性を抽出済みなので、これを利用します。

  3. CountVectorizeranalyzer=lambda x: x を指定することで、すでにトークナイズ済みのリストをそのまま入力として扱うことができます。

実装を開始します。

USER: 進めてください

ASSISTANT: 申し訳ありません。joblib(または pickle)で CountVectorizer を保存しようとした際、lambda 関数(analyzer=lambda x: x)が原因でエラーが発生しました。lambda 関数はシリアライズ(保存)できないためです。

修正方針

lambda 関数の代わりに、名前の付いた関数を定義することで、シリアライズ可能にします。

修正して再度実行します。

USER: 進めてください

ASSISTANT: 課題73が完了しました!

実装内容:

  • identity_analyzer 関数を定義し、CountVectorizeranalyzer に指定することで、モデルとベクトル化器を正常に joblib で保存できるようにしました。

  • 学習済みのモデル (model.pkl), ベクトル化器 (vectorizer.pkl), 素性抽出器 (extractor.pkl) がすべて保存されました。


次は 課題74「予測」 に進みます。

課題74: 予測

要件: * 73で学習したロジスティック回帰モデルを用い、与えられた文の極性ラベル(正例なら "+1"、負例なら "-1")と、その予測確率を計算するプログラムを実装せよ。

実装方針:

  1. 保存した model.pkl, vectorizer.pkl, extractor.pkl をロードする。

  2. 与えられた文(文字列)を受け取り、以下の手順で処理する。

    • extractor でステミング済みの単語リストへ変換。
    • vectorizer でベクトル化。
    • model でラベル(1 or -1)と、確率(predict_proba)を予測。
  3. 結果を整形して出力する。

実装を開始します。

USER: 進めてください

ASSISTANT: 申し訳ありません。joblib.loadvectorizer.pkl をロードする際、vectorizer が作成時に使用した identity_analyzer という関数が、現在の task74.py の中(__main__ モジュール)に見当たらないため、AttributeError が発生しました。

修正方針

identity_analyzertask74.py にも定義するか、あるいは共通のモジュール(例:utils.py)に切り出して、両方のスクリプトからインポートできるようにします。

今回は、今後の課題(75〜79)でも共通して使う可能性があるため、utils.py というファイルに共通関数をまとめる方法で修正します。

手順

  1. utils.py を作成し、identity_analyzer を配置する。

  2. task73.py を修正して、identity_analyzerutils からインポートするようにする。

  3. task74.py を修正して、identity_analyzerutils からインポートするようにする。

  4. task73.py を再実行して、モデルを正しく保存し直す。

  5. task74.py を実行する。

この手順で進めてよろしいでしょうか?

USER: 進めてください

ASSISTANT: task73.py の修正が完了し、モデルの保存まで成功しました!

次に、task74.py を修正して、utils.py から identity_analyzer をインポートするようにします。その後、task74.py を実行します。

手順

  1. task74.py を修正。

  2. task74.py を実行。

修正を行います。

USER: 進めてください

ASSISTANT: 課題74が完了しました!

実行結果: * 与えられたテストケースに対して、ラベル(+1 または -1)と予測確率が正しく出力されました。 * identity_analyzerutils.py からインポートするように修正したことで、モデルのロードエラーも解消されました。


次は 課題75「素性の重み」 に進みます。

課題75: 素性の重み

要件: * 73で学習したロジスティック回帰モデルの中で、重みの高い素性トップ10と、重みの低い素性トップ10を確認せよ。

実装方針:

  1. 保存した model.pklvectorizer.pkl をロードする。

  2. model.coef_ から重みを取得する。

  3. vectorizer.get_feature_names_out() を用いて、重みに対応する単語を取得する。

  4. 重みの絶対値が大きい順(または値そのもの)にソートして、トップ10とボトム10を表示する。

実装を開始します。

USER: 進めてください

ASSISTANT: 課題75が完了しました!

実行結果:

  • 重みの高い素性(ポジティブな影響を与える単語)のトップ10が表示されました(例: engross, refresh, marvel など)。

  • 重みの低い素性(ネガティブな影響を与える単語)のトップ10が表示されました(例: bore, dull, wast など)。

  • ステミング処理(engross $\to$ engross はそのままですが、wonderful $\to$ wonder のような形)が効いていることが確認できます。


次は 課題76「ラベル付け」 に進みます。

課題76: ラベル付け

要件:

  • 学習データに対してロジスティック回帰モデルを適用し、正解のラベル、予測されたラベル、予測確率をタブ区切り形式で出力せよ。

実装方針:

  1. task72.pyFeatureExtractor を使って、sentiment.txt からラベルと素性リストを読み込む。

  2. task73.py で保存した model.pklvectorizer.pkl をロードする。

  3. 全データに対して model.predictmodel.predict_proba を実行する。

  4. 正解ラベル \t 予測ラベル \t 予測確率 の形式でファイル(例: predictions.txt)に出力する。

実装を開始します。

USER: 進めてください

ASSISTANT: 課題76が完了しました!

実装内容:

  • 学習データ(sentiment.txt)に対して、モデルによる予測を行い、predictions.txt に保存しました。

  • 保存形式は、課題の指示通り 正解ラベル \t 予測ラベル \t 予測確率(タブ区切り)です。


次は 課題77「正解率の計測」 に進みます。

課題77: 正解率の計測

要件:

  • 76の出力を受け取り、予測の正解率、正例に関する適合率、再現率、F1スコアを求めるプログラムを作成せよ。

実装方針:

  1. predictions.txt を読み込む。

  2. 各行から 正解, 予測, 確率 を抽出する。

  3. 混同行列(Confusion Matrix)の要素(TP, FP, TN, FN)をカウントする。

    • 正例(Positive)を +1 とする。
  4. 各指標を計算する。

    • 正解率 (Accuracy) = (TP + TN) / Total
    • 適合率 (Precision) = TP / (TP + FP)
    • 再現率 (Recall) = TP / (TP + FN)
    • F1スコア = 2 * (Precision * Recall) / (Precision + Recall)
  5. 結果を表示する。

実装を開始します。

USER: 進めてください

ASSISTANT: 課題77が完了しました!

実行結果:

  • predictions.txt を解析し、正解率、適合率、再現率、F1スコアを算出しました。

  • Accuracy: 0.9396

  • Precision: 0.9431

  • Recall: 0.9357

  • F1 Score: 0.9394 (非常に高い性能であることがわかります。)


次は 課題78「5分割交差検定」 に進みます。

課題78: 5分割交差検定

要件: * 5分割交差検定(5-fold Cross-Validation)により、極性分類の正解率、適合率、再現率、F1スコアを求めよ。

実装方針:

  1. scikit-learnKFold または StratifiedKFold を使用します。

  2. データセットを5つのグループに分割します。

  3. 各分割について以下のプロセスを繰り返します。

    • 4つのグループを学習データ、1つのグループをテストデータとして使用。
    • データの抽出 $\to$ ベクトル化 $\to$ 学習 $\to$ 予測。
    • 評価指標(Accuracy, Precision, Recall, F1)を計算。
  4. 5回分の評価結果の平均値を最終的な結果として出力します。

※ 毎回データのロードと学習を行うため、実行には少し時間がかかります。

実装を開始します。

USER: 進めてください

ASSISTANT: 課題78が完了しました!

実行結果:

  • 5分割交差検定を実施しました。

  • Average Accuracy: 0.7545

  • Average Precision: 0.7540

  • Average Recall: 0.7558

  • Average F1 Score: 0.7549

考察: 課題77(学習データに対する評価)では Accuracy が約 0.94 でしたが、交差検定の結果は約 0.75 となりました。これは、課題77が「モデルが既に知っているデータ」に対する評価(丸暗記の評価)であったのに対し、課題78は「未知のデータ」に対する汎化性能を測定しているためです。この差は、モデルが訓練データに対して過学習(Overfitting)気味であることを示唆しています。


最後は 課題79「適合率-再現率グラフの描画」 です。

課題79: 適合率-再現率グラフの描画

要件: * ロジスティック回帰モデルの分類の閾値を変化させることで、適合率-再現率(Precision-Recall)グラフを描画せよ。

実装方針:

  1. 学習済みモデル、ベクトル化器、抽出器をロードする。

  2. テスト用のデータセットを用意する(ここでは、学習データの一部をテスト用として使うか、あるいは全データを使用する)。

  3. 分類境界(閾値)を 0.0 から 1.0 まで変化させる。

    • ロジスティック回帰の predict_proba を使用。
    • 閾値 $\tau$ に対して、確率 $P(y=1) \ge \tau$ ならば $1$、そうでなければ $-1$ と判定する。
  4. 各閾値における Precision と Recall を計算し、リストに格納する。

  5. matplotlib を用いて、横軸を Recall、縦軸を Precision としたグラフを描画する。

  6. グラフを画像ファイル(例: precision_recall_curve.png)として保存する。

実装を開始します。

USER: 進めてください

ASSISTANT: 課題79が完了しました!

実装内容:

  • precision_recall_curve 関数を使用して、閾値を変化させた際の Precision と Recall の関係を計算しました。

  • グラフを precision_recall_curve.png として保存しました。


🏁 全課題の完了報告

「言語処理100本ノック2015」第8章「機械学習」の課題70から課題79までの実装がすべて完了しました。

実装したファイル一覧

ファイル名 課題番号 内容
task70.py 70 データの入手・整形 (sentiment.txt の作成)
task71.py 71 ストップワード判定関数とテスト
task72.py 72 素性抽出器 (FeatureExtractor クラス)
task73.py 73 ロジスティック回帰モデルの学習と保存
task74.py 74 文の極性予測プログラム
task75.py 75 モデルの素性重み解析
task76.py 76 学習データへのラベル付けと出力
task77.py 77 予測精度(Accuracy, Precision, Recall, F1)の計測
task78.py 78 5分割交差検定による汎化性能の評価
task79.py 79 Precision-Recall 曲線(グラフ)の描画
utils.py - 共通関数 (identity_analyzer)

使用した環境・ライブラリ

  • Language: Python 3.11

  • Libraries: scikit-learn, numpy, pandas, matplotlib, nltk, joblib, requests

お疲れ様でした!他に何かお手伝いできることはありますか?


Pi-Agent用のdocker環境(Sandbox)を構築する

Pi-Agentを動作させる環境としてSandboxの環境が必要と思うようになった。必要なライブラリやソフトをいちいち私が導入するのも効率が悪い。全てPi-Agentで動作するAIにやらせたい。AIが何をしても安心な仮想環境がやはり必要なのだ。

UbuntuでSandboxを運用するにはdockerを使うことになる。私はdockerが未だに苦手である。ollamaのインストールなどで使ったことはあるがインストールマニュアル通りに操作しただけでコマンドの意味は全く理解していない。

docker環境でPi-Agentを動作させる方法を自分で調べるにしてもPi-Agentに関する情報はネットにはまだ少ない。今回はgemma-4-26B-A4Bに聞くことにした。

gemma-4にdocker環境の構築方法を聞く

Pi-Agentでgemma-4-26B-A4Bを立ち上げて以下のプロンプトを投げる。

User:

docker環境でPi-Agentが動かす方法を調べてください。

調べた結果はREPORT.mdにまとめて出力してください。

調べる主な項目

・Pi-Agent用のdocker環境構築方法(リポジトリ追加など)

・Pi-Agentのバージョンをアップデートする方法

・使用するモデル(ローカルAI)を導入する方法

動作環境はUbuntu22.04でdockerはすでに導入済みとします。

AI:

Docker環境でPi-Agentを動作させる方法について調査し、REPORT.md にまとめました。

調査結果の要点は以下の通りです:

  1. 構築方法:

    • Node.jsベースのDockerfileを作成し、@earendil-works/pi-coding-agent をグローバルにインストールして運用します。
    • ホストのファイルを操作させるため、作業ディレクトリをボリュームマウント (-v) して使用します。
  2. アップデート方法:

    • Docker環境では、イメージを --no-cache で再ビルドする方法が最もクリーンで推奨されます。
    • コンテナ内での pi update --self はレイヤーが永続化されないため、再起動すると元のイメージに戻ってしまう点に注意が必要です。
  3. ローカルAIの導入:

    • OllamaなどのローカルAIサーバーをホスト側で起動し、コンテナ内から host.docker.internal を経由してアクセスします。
    • Linux環境では docker run 時に --add-host=host.docker.internal:host-gateway オプションを付与する必要があります。
    • ~/.pi/agent/models.json にカスタムプロバイダーの設定を記述することで、ローカルモデルを認識させることができます。

詳細な手順や設定例(Dockerfile、JSON設定、実行コマンド)は REPORT.md をご確認ください。

備忘録的メモ

gemma-4が作成したREPORT.mdの内容は本記事の最後にそのまま貼り付ける。

私はREPORT.mdに書かれた内容に従ってdocker環境を構築することができた。

途中でコンテナのビルド方法や、既に動作しているllama-serverとの接続方法などを別途質問しながら作業したのだが基本的にREPORT.mdに書かれている内容の通りだった。

注意点としては以下の2点である。

  1. コンテナ起動時(docker run)に--rmは指定しない
    • これはコンテナが停止(終了)した際に、そのコンテナを自動的に削除するためのフラグである。私はこれを指定したため折角構築した環境が全て削除されてしまった。
  2. コンテナ起動時にシェルを起動する方法
    • デフォルトではPi-Agentが起動するようになっており、Pi-Agentを終了するとコンテナも終了してしまう。シェルを最初に起動したい場合には以下のコマンドになる。
# コンテナが起動しているか確認する。起動していないと表示されない。
$ docker ps

# 起動していないコンテナも含めて表示するコマンド
$ docker ps -a

# コンテナが起動していな場合は起動する
$ docker restart IDまたはコンテナ名

# コンテナが起動している場合は以下のコマンドでコンテナのシェルが起動する
$ docker exec -it IDまたはコンテナ名 /bin/bash

感想

2年前にはAIエージェントが使えてこんなことができれば便利だろうな〜と思っていた。 2024-10-23 ローカル環境で動くAIエージェントを試してみた

2年後の今は普通にローカルPCの環境の中でAIエージェントが使えるようになった。便利になったものである。


Pi-Agent Docker環境での運用

本レポートでは、Ubuntu 22.04 (Docker導入済み) 環境において、Pi-AgentをDockerコンテナ上で動作させる方法、アップデート方法、およびローカルAIモデルの導入方法についてまとめます。

1. Pi-Agent用 Docker環境の構築方法

Pi-Agent自体はNode.jsアプリケーションであるため、公式のDockerイメージが提供されていない場合は、Dockerfileを作成して環境を構築します。

構築の考え方

Pi-Agentは、ファイル操作 (read, write, edit) やシェル実行 (bash) を行うため、コンテナ内からホスト側のファイルにアクセスしたり、コンテナ内でコマンドを実行したりする必要があります。

実装例 (Dockerfile)

以下の Dockerfile を作成し、プロジェクトディレクトリでビルドします。

# ベースイメージにNode.jsを使用
FROM node:22-slim

# 必要なシステムパッケージのインストール (git, curl, bash等)
RUN apt-get update && apt-get install -y \
    git \
    curl \
    ca-certificates \
    && rm -rf /var/lib/apt/lists/*

# Pi-Agentのインストール
RUN npm install -g @earendil-works/pi-coding-agent

# 作業ディレクトリの設定
WORKDIR /workspace

# コンテナ起動時のデフォルトコマンド
# 環境変数などでAPIキーを渡す運用を想定
CMD ["pi"]

コンテナの起動方法

ホストのカレントディレクトリをコンテナ内の /workspace にマウントして起動します。

# ビルド
docker build -t pi-agent .

# 実行 (AnthropicのAPIキーを使用する例)
docker run -it --rm \
  -e ANTHROPIC_API_KEY=$ANTHROPIC_API_KEY \
  -v $(pwd):/workspace \
  pi-agent

注意点:

  • 権限: コンテナ内で作成されたファイルは root 所有になる可能性があるため、必要に応じて user 指定や chmod の調整を行ってください。
  • リポジトリ追加: Pi-Agentの拡張機能(Extensions)やスキル(Skills)を使用する場合、それらもボリュームマウントするか、Dockerfile内でインストールする必要があります。

2. Pi-Agentのバージョンをアップデートする方法

Docker環境では、イメージを再ビルドするか、実行中のコンテナ内で npm を使用してアップデートします。

方法A: イメージの再ビルド (推奨)

Dockerfileを最新の状態(またはキャッシュなし)でビルドし直す方法です。これが最もクリーンです。

docker build --no-cache -t pi-agent .

方法B: 実行中のコンテナ内でのアップデート

既に起動しているコンテナに入り、直接 npm コマンドを実行します。

docker exec -it <container_id> npm install -g @earendil-works/pi-coding-agent

方法C: Piの組み込みコマンドを使用

Pi-Agentには自身をアップデートするコマンドが用意されています。

# コンテナ内で実行
pi update --self

※ただし、Dockerコンテナの場合はレイヤーが永続化されないため、コンテナを再起動すると元のイメージの状態に戻ります。したがって、方法A(再ビルド)が基本となります。


3. 使用するモデル(ローカルAI)を導入する方法

ローカルAI(Ollama, LM Studio, vLLM等)を使用する場合、Dockerコンテナからホスト側のAIサーバーへ通信を行う必要があります。

ステップ1: ローカルAIサーバーの準備

例えば、ホスト側で Ollama を動かしている場合、コンテナからアクセスできるように待ち受け設定を確認します。

  • Ollamaの環境変数 OLLAMA_HOST=0.0.0.0 を設定して起動していること。

ステップ2: Pi-Agentの設定 (models.json)

Pi-Agentの設定ファイル ~/.pi/agent/models.json (Docker内では /root/.pi/agent/models.json 等) に、ローカルモデルの定義を追加します。

Docker環境でのネットワーク設定のコツ: コンテナからホストマシンを指す場合、localhost ではなく host.docker.internal を使用します(Linuxの場合は --add-host オプションが必要な場合があります)。

{
  "providers": {
    "ollama": {
      "baseUrl": "http://host.docker.internal:11434/v1",
      "api": "openai-completions",
      "apiKey": "ollama",
      "compat": {
        "supportsDeveloperRole": false,
        "supportsReasoningEffort": false
      },
      "models": [
        { "id": "llama3.1:8b" },
        { "id": "qwen2.5-coder:7b" }
      ]
    }
  }
}

ステップ3: コンテナの起動

host.docker.internal を解決できるように、--add-host オプションを付けて起動します。

docker run -it --rm \
  --add-host=host.docker.internal:host-gateway \
  -v $(pwd):/workspace \
  -v ~/.pi/agent:/root/.pi/agent \
  pi-agent

設定のポイント:

  • -v ~/.pi/agent:/root/.pi/agent: ホスト側の設定ファイルをコンテナにマウントすることで、models.json の変更を即座に反映できます。
  • --add-host: Linux環境のDockerにおいて、コンテナ内からホストのIPを host.docker.internal として参照するために必須です。

まとめ

項目 推奨される方法
構築 Dockerfileを作成し、ソースコードをボリュームマウントして実行
アップデート docker build --no-cache によるイメージの再作成
ローカルAI導入 host.docker.internal を介してホストのAPIへ接続し、models.json を設定

「言語処理100本ノック 2015」の英語テキスト処理をgemma-4にやらせてみた

前回に引き続き「言語処理100本ノック」をAIに解かせた結果を報告したい。 今回試した課題は「英語テキストの処理」である。ローカルAIエージェントにはgemma-4を使用した。 モデルとしてはgemma-4-26B-A4Bを主に使用したが試行錯誤する中でgemma-4-31Bも併用した。

英語テキストの処理

説明のため東北大学の「言語処理100本ノック」のページから実行した課題の「第6章: 英語テキストの処理」を引用する。

英語のテキスト(nlp.txt)に対して,以下の処理を実行せよ.

  • (50)文区切り: (. or ; or : or ? or !) → 空白文字 → 英大文字というパターンを文の区切りと見なし,入力された文書を1行1文の形式で出力せよ.

  • (51)単語の切り出し: 空白を単語の区切りとみなし,50の出力を入力として受け取り,1行1単語の形式で出力せよ.ただし,文の終端では空行を出力せよ.

  • (52)ステミング: 51の出力を入力として受け取り,Porterのステミングアルゴリズムを適用し,単語と語幹をタブ区切り形式で出力せよ. Pythonでは,Porterのステミングアルゴリズムの実装としてstemmingモジュールを利用するとよい.

  • (53)Tokenization: Stanford Core NLPを用い,入力テキストの解析結果をXML形式で得よ.また,このXMLファイルを読み込み,入力テキストを1行1単語の形式で出力せよ.

  • (54)品詞タグ付け: Stanford Core NLPの解析結果XMLを読み込み,単語,レンマ,品詞をタブ区切り形式で出力せよ.

  • (55)固有表現抽出: 入力文中の人名をすべて抜き出せ.

  • (56)共参照解析: Stanford Core NLPの共参照解析の結果に基づき,文中の参照表現(mention)を代表参照表現(representative mention)に置換せよ.ただし,置換するときは,「代表参照表現(参照表現)」のように,元の参照表現が分かるように配慮せよ.

  • (57)係り受け解析: Stanford Core NLPの係り受け解析の結果(collapsed-dependencies)を有向グラフとして可視化せよ.可視化には,係り受け木をDOT言語に変換し,Graphvizを用いるとよい.また,Pythonから有向グラフを直接的に可視化するには,pydotを使うとよい.

  • (58)タプルの抽出: Stanford Core NLPの係り受け解析の結果(collapsed-dependencies)に基づき,「主語 述語 目的語」の組をタブ区切り形式で出力せよ.ただし,主語,述語,目的語の定義は以下を参考にせよ.

・述語: nsubj関係とdobj関係の子(dependant)を持つ単語

・主語: 述語からnsubj関係にある子(dependent)

・目的語: 述語からdobj関係にある子(dependent)

  • (59)S式の解析: Stanford Core NLPの句構造解析の結果(S式)を読み込み,文中のすべての名詞句(NP)を表示せよ.入れ子になっている名詞句もすべて表示すること.

実行結果

gemma-4は以下のPythonスクリプトsolution.pyを作成した。

Pythonスクリプトsolution.pyを開く

import re
import sys
import os
import subprocess
import xml.etree.ElementTree as ET
from nltk.stem import PorterStemmer
import pydot

def solve_50(input_text):
    # (. or ; or : or ? or !) -> 空白文字 -> 英大文字
    # The pattern is: (punctuation)(whitespace)(uppercase)
    # We want to split at these points.
    # A more robust way: use regex to find the boundaries.
    # The instruction says "split the document into 1 sentence per line"
    # based on the pattern.
    
    # Pattern: (. or ; or : or ? or !) followed by whitespace, followed by uppercase.
    # Let's use lookbehind and lookahead to split without consuming.
    pattern = r'(?<=[.;:?!])\s+(?=[A-Z])'
    sentences = re.split(pattern, input_text)
    return sentences

def solve_51(sentences):
    # 51. 50の出力を入力として受け取り,1行1単語の形式で出力せよ.ただし,文の終端では空行を出力せよ.
    # 空白を単語の区切りとみなし
    output = []
    for sentence in sentences:
        words = sentence.split()
        for word in words:
            output.append(word)
        output.append("") # 文の終端で空行
    return output

def solve_52(words):
    # 52. 51の出力を入力として受け取り,Porterのステミングアルゴリズムを適用し,単語と語幹をタブ区切り形式で出力せよ.
    stemmer = PorterStemmer()
    output = []
    for word in words:
        if word == "":
            output.append("")
        else:
            stem = stemmer.stem(word)
            output.append(f"{word}\t{stem}")
    return output

# For 53-59, we need Stanford CoreNLP running.
# Since it's in ./data/stanford-corenlp-4.5.10, I'll assume I can start it.
# However, starting a Java server in a script might be tricky.
# I will write the logic assuming a server is running on localhost:9000.

def run_corenlp(text, annotators):
    import urllib.request
    import urllib.parse

    """CoreNLPサーバーにリクエストを送信"""
    params = {
        'annotators': annotators,
        'outputFormat': 'xml'
    }
    query_string = urllib.parse.urlencode(params)
    url = f"http://localhost:9000?{query_string}"
    
    data = text.encode('utf-8')
    
    # POSTリクエストを送信 (Content-Typeを明示的に指定してサーバー側の誤認を防ぐ)
    req = urllib.request.Request(url, data=data, method='POST')
    req.add_header('Content-Type', 'text/plain; charset=utf-8')
    
    try:
        with urllib.request.urlopen(req) as f:
            return f.read().decode('utf-8')
    except urllib.error.HTTPError as e:
        # サーバーから返された詳細なエラーメッセージ(スタックトレース)を読み出す
        error_body = e.read().decode('utf-8')
        print(f"HTTP Error {e.code}: {e.reason}")
        print(f"Response body:\n{error_body}")
        raise Exception(f"CoreNLP Server Error {e.code}: {error_body}")


def solve_53(xml_text):
    """53. Tokenization: XMLから1行1単語"""
    root = ET.fromstring(xml_text)
    words = []
    # <sentence> -> <tokens> -> <token> -> <word> の階層を辿る
    for sentence in root.findall('.//sentence'):
        tokens_container = sentence.find('tokens')
        if tokens_container is not None:
            for token in tokens_container.findall('token'):
                word_el = token.find('word')
                if word_el is not None and word_el.text:
                    words.append(word_el.text)
        words.append("") # 文の終端で空行
    return words

def solve_54(xml_text):
    """54. 品詞タグ付け: 単語\tレンマ\t品詞"""
    root = ET.fromstring(xml_text)
    output = []
    for token in root.findall('.//token'):
        word = token.find('word').text if token.find('word') is not None else ""
        lemma = token.find('lemma').text if token.find('lemma') is not None else ""
        # タグ名が <POS> (大文字) であることに注意
        pos = token.find('POS').text if token.find('POS') is not None else ""
        output.append(f"{word}\t{lemma}\t{pos}")
    return output

def solve_55(xml_text):
    """55. 固有表現抽出: 人名をすべて抜き出せ"""
    root = ET.fromstring(xml_text)
    names = []
    current_name = []
    
    # すべてのトークンを走査し、NERが PERSON のものを結合する
    for token in root.findall('.//token'):
        ner = token.find('NER').text if token.find('NER') is not None else "O"
        word = token.find('word').text if token.find('word') is not None else ""
        
        if ner == 'PERSON':
            current_name.append(word)
        else:
            if current_name:
                names.append(" ".join(current_name))
                current_name = []
    
    if current_name: # 最後に名前が残っていた場合
        names.append(" ".join(current_name))
        
    return names
    
def solve_56(text, xml_text):
    """56. 共参照解析: 代表参照表現に置換せよ.「代表参照表現(参照表現)」のように"""
    try:
        root = ET.fromstring(xml_text)
    except ET.ParseError:
        return text

    # Try to find <coref> anywhere in the document
    coref = root.find('.//coref')
    if coref is None:
        return text

    replacements = []
    for chain in coref.findall('corefChain'):
        rep = chain.get('representativeMention')
        if rep is None:
            continue
            
        for mention in chain.findall('mention'):
            try:
                start = int(mention.get('startOffset'))
                end = int(mention.get('endOffset'))
                mention_text = text[start:end]
                replacements.append((start, end, rep, mention_text))
            except (TypeError, ValueError):
                continue

    # Sort replacements by start offset in descending order to avoid shifting offsets.
    # If start is the same, sort by end descending to handle larger mentions first.
    replacements.sort(key=lambda x: (x[0], x[1]), reverse=True)

    result_text = text
    last_start = len(text) + 1
    
    for start, end, rep, mention_text in replacements:
        # To prevent overlapping replacements, ensure this mention ends before the last one started.
        if end <= last_start:
            replacement = f"{rep}({mention_text})"
            result_text = result_text[:start] + replacement + result_text[end:]
            last_start = start
            
    return result_text

def solve_57(xml_text):
    root = ET.fromstring(xml_text)
    graph = pydot.Dot(graph_type='digraph')

    token_map = {'0': 'ROOT'}  # ROOT をあらかじめ追加しておく

    for token in root.findall('.//token'):
        word_el = token.find('word')
        if word_el is not None:
            token_map[token.get('id')] = word_el.text

    # CoreNLP XML structure: <collapsed-dependencies> contains <dep> elements.
    # <dep> elements have 'type', 'governor', and 'dependent' attributes.
    # Note: The original code used 'rel' and 'dep' as attribute names, but
    # according to the sample XML, they are 'type', 'governor', and 'dependent'.

    # We search for <dep> tags inside <dependencies type="collapsed-dependencies">
    # The XML structure is: <dep type="rel"><governor idx="G"/><dependent idx="D"/></dep>
    for dep in root.findall('.//dependencies[@type="collapsed-dependencies"]/dep'):
        rel = dep.get('type')
        gov_el = dep.find('governor')
        dep_el = dep.find('dependent')
        
        if gov_el is not None and dep_el is not None:
            gov_idx = gov_el.get('idx')
            dep_idx = dep_el.get('idx')
            
            if gov_idx in token_map and dep_idx in token_map:
                edge = pydot.Edge(token_map[gov_idx], token_map[dep_idx], label=rel)
                graph.add_edge(edge)

    graph.write_png('dependency_graph.png')
    return "Saved dependency_graph.png"

def solve_58(xml_text):
    """58. タプルの抽出: 主語\t述語\t目的語"""
    root = ET.fromstring(xml_text)
    triplets = []
    
    for sentence in root.findall('.//sentence'):
        # tokenのIDをキーに、<word>の内容を保存するマップを作成
        tokens = {}
        tokens_container = sentence.find('tokens')
        if tokens_container is not None:
            for token in tokens_container.findall('token'):
                word_el = token.find('word')
                if word_el is not None:
                    tokens[token.get('id')] = word_el.text
        # XMLの構造に合わせて, collapsed-dependencies内のdepを探す
        # <dependencies type="collapsed-dependencies"> を経由して探す
        deps = sentence.findall('.//dependencies[@type="collapsed-dependencies"]/dep')
        
        predicates = {}
        for d in deps:
            rel = d.get('type')
            gov_el = d.find('governor')
            dep_el = d.find('dependent')
            
            if gov_el is not None and dep_el is not None:
                gov_id = gov_el.get('idx')
                dep_id = dep_el.get('idx')
                
                if rel in ['nsubj', 'dobj', 'obj']:
                    if gov_id not in predicates: 
                        predicates[gov_id] = {'nsubj': None, 'dobj': None}
                    if rel == 'nsubj': 
                        predicates[gov_id]['nsubj'] = tokens.get(dep_id)
                    elif rel == 'dobj' or rel == 'obj':
                        predicates[gov_id]['dobj'] = tokens.get(dep_id)
        
        for gov_id, parts in predicates.items():
            if parts['nsubj'] and parts['dobj']:
                pred_text = tokens.get(gov_id, "")
                triplets.append(f"{parts['nsubj']}\t{pred_text}\t{parts['dobj']}")
    return triplets

def solve_59(xml_text):
    # 59. S式の解析: 句構造解析のS式を読み込み,すべての名詞句(NP)を表示せよ.
    # CoreNLP XML for constituency parse is in <parse> tags with S-expression format.
    # Example: (ROOT (S (NP (NNP Alan)) (VP (VBZ published) ...)))
    root = ET.fromstring(xml_text)
    s_expressions = []
    for parse in root.findall('.//parse'):
        s_expressions.append(parse.text)
    
    # We need to parse the S-expression to find (NP ...)
    # This is a recursive descent parser for the S-expression.
    
    def find_nps(s_expr):
        # This is a simple way to find (NP ...) in an S-expression string.
        # We can use a stack-based approach.
        nps = []
        i = 0
        while i < len(s_expr):
            if s_expr[i:i+3] == "(NP":
                # Find the matching closing parenthesis
                start = i
                count = 0
                for j in range(i, len(s_expr)):
                    if s_expr[j] == '(':
                        count += 1
                    elif s_expr[j] == ')':
                        count -= 1
                        if count == 0:
                            nps.append(s_expr[start:j+1])
                            i = j
                            break
                i += 1
            else:
                i += 1
        return nps

    all_nps = []
    for s_expr in s_expressions:
        all_nps.extend(find_nps(s_expr))
    return all_nps

def main():
    input_path = 'data/nlp.txt'
    if not os.path.exists(input_path):
        print(f"Error: {input_path} not found.")
        return

    with open(input_path, 'r', encoding='utf-8') as f:
        text = f.read()

    print("--- 50. Sentence Segmentation ---")
    sentences = solve_50(text)
    for s in sentences:
        print(s)
    
    print("\n--- 51. Word Tokenization ---")
    words = solve_51(sentences)
    for w in words:
        print(w)

    print("\n--- 52. Stemming ---")
    stemmed = solve_52(words)
    for s in stemmed:
        print(s)

    # For 53-59, we need to interact with CoreNLP server.
    # I'll assume it's running on localhost:9000.
    # If not, I'll skip or print a message.
    
    print("\n--- Starting CoreNLP tasks (Assuming server is running on localhost:9000) ---")
    try:
        # 順序を整理し、一般的によく使われる順序に変更
        xml_text = run_corenlp(text, 'tokenize,ssplit,pos,lemma,ner,parse,depparse,coref')

        
        print("\n--- 53. Tokenization (XML to Words) ---")
        print(xml_text)
        words_53 = solve_53(xml_text)
        for w in words_53:
            print(w)
            
        print("\n--- 54. POS Tagging ---")
        pos_tags = solve_54(xml_text)
        for pt in pos_tags:
            print(pt)
            
        print("\n--- 55. NER (Person Names) ---")
        names = solve_55(xml_text)
        for name in names:
            print(name)
            
        print("\n--- 56. Coreference Resolution ---")
        coref_text = solve_56(text, xml_text)
        print(coref_text)

        print("\n--- 57. Dependency Visualization ---")
        print(solve_57(xml_text))

        print("\n--- 58. Triplets (Subj-Pred-Obj) ---")
        triplets = solve_58(xml_text)
        for t in triplets:
            print(t)
            
        print("\n--- 59. NP Extraction (from S-expression) ---")
        nps = solve_59(xml_text)
        for np in nps:
            print(np)

    except Exception as e:
        print(f"CoreNLP tasks failed: {e}")
        print("Make sure Stanford CoreNLP is running on localhost:9000.")

if __name__ == "__main__":
    main()

solution.pyを実行すると以下の結果が得られた。ただし英語テキストnlp.txtの全文を使用すると課題によっては出力が膨大になるため最初の6行のみとして行った結果である。

solution.pyが出力したテキストは以下の通り。

solution.pyが出力したテキストを開く

--- 50. Sentence Segmentation ---
Natural language processing
From Wikipedia, the free encyclopedia

Natural language processing (NLP) is a field of computer science, artificial intelligence, and linguistics concerned with the interactions between computers and human (natural) languages.
As such, NLP is related to the area of humani-computer interaction.
Many challenges in NLP involve natural language understanding, that is, enabling computers to derive meaning from human or natural language input, and others involve natural language generation.
History

The history of NLP generally starts in the 1950s, although work can be found from earlier periods.
In 1950, Alan Turing published an article titled "Computing Machinery and Intelligence" which proposed what is now called the Turing test as a criterion of intelligence.
The Georgetown experiment in 1954 involved fully automatic translation of more than sixty Russian sentences into English.
The authors claimed that within three or five years, machine translation would be a solved problem.
However, real progress was much slower, and after the ALPAC report in 1966, which found that ten year long research had failed to fulfill the expectations, funding for machine translation was dramatically reduced.
Little further research in machine translation was conducted until the late 1980s, when the first statistical machine translation systems were developed.


--- 51. Word Tokenization ---
Natural
language
processing
From
Wikipedia,
the
free
encyclopedia
Natural
language
processing
(NLP)
is
a
field
of
computer
science,
artificial
intelligence,
and
linguistics
concerned
with
the
interactions
between
computers
and
human
(natural)
languages.

As
such,
NLP
is
related
to
the
area
of
humani-computer
interaction.

Many
challenges
in
NLP
involve
natural
language
understanding,
that
is,
enabling
computers
to
derive
meaning
from
human
or
natural
language
input,
and
others
involve
natural
language
generation.

History
The
history
of
NLP
generally
starts
in
the
1950s,
although
work
can
be
found
from
earlier
periods.

In
1950,
Alan
Turing
published
an
article
titled
"Computing
Machinery
and
Intelligence"
which
proposed
what
is
now
called
the
Turing
test
as
a
criterion
of
intelligence.

The
Georgetown
experiment
in
1954
involved
fully
automatic
translation
of
more
than
sixty
Russian
sentences
into
English.

The
authors
claimed
that
within
three
or
five
years,
machine
translation
would
be
a
solved
problem.

However,
real
progress
was
much
slower,
and
after
the
ALPAC
report
in
1966,
which
found
that
ten
year
long
research
had
failed
to
fulfill
the
expectations,
funding
for
machine
translation
was
dramatically
reduced.

Little
further
research
in
machine
translation
was
conducted
until
the
late
1980s,
when
the
first
statistical
machine
translation
systems
were
developed.


--- 52. Stemming ---
Natural natur
language    languag
processing  process
From    from
Wikipedia,  wikipedia,
the the
free    free
encyclopedia    encyclopedia
Natural natur
language    languag
processing  process
(NLP)   (nlp)
is  is
a   a
field   field
of  of
computer    comput
science,    science,
artificial  artifici
intelligence,   intelligence,
and and
linguistics linguist
concerned   concern
with    with
the the
interactions    interact
between between
computers   comput
and and
human   human
(natural)   (natural)
languages.  languages.

As  as
such,   such,
NLP nlp
is  is
related relat
to  to
the the
area    area
of  of
humani-computer humani-comput
interaction.    interaction.

Many    mani
challenges  challeng
in  in
NLP nlp
involve involv
natural natur
language    languag
understanding,  understanding,
that    that
is, is,
enabling    enabl
computers   comput
to  to
derive  deriv
meaning mean
from    from
human   human
or  or
natural natur
language    languag
input,  input,
and and
others  other
involve involv
natural natur
language    languag
generation. generation.

History histori
The the
history histori
of  of
NLP nlp
generally   gener
starts  start
in  in
the the
1950s,  1950s,
although    although
work    work
can can
be  be
found   found
from    from
earlier earlier
periods.    periods.

In  in
1950,   1950,
Alan    alan
Turing  ture
published   publish
an  an
article articl
titled  titl
"Computing  "comput
Machinery   machineri
and and
Intelligence"   intelligence"
which   which
proposed    propos
what    what
is  is
now now
called  call
the the
Turing  ture
test    test
as  as
a   a
criterion   criterion
of  of
intelligence.   intelligence.

The the
Georgetown  georgetown
experiment  experi
in  in
1954    1954
involved    involv
fully   fulli
automatic   automat
translation translat
of  of
more    more
than    than
sixty   sixti
Russian russian
sentences   sentenc
into    into
English.    english.

The the
authors author
claimed claim
that    that
within  within
three   three
or  or
five    five
years,  years,
machine machin
translation translat
would   would
be  be
a   a
solved  solv
problem.    problem.

However,    however,
real    real
progress    progress
was wa
much    much
slower, slower,
and and
after   after
the the
ALPAC   alpac
report  report
in  in
1966,   1966,
which   which
found   found
that    that
ten ten
year    year
long    long
research    research
had had
failed  fail
to  to
fulfill fulfil
the the
expectations,   expectations,
funding fund
for for
machine machin
translation translat
was wa
dramatically    dramat
reduced.    reduced.

Little  littl
further further
research    research
in  in
machine machin
translation translat
was wa
conducted   conduct
until   until
the the
late    late
1980s,  1980s,
when    when
the the
first   first
statistical statist
machine machin
translation translat
systems system
were    were
developed.  developed.


--- Starting CoreNLP tasks (Assuming server is running on localhost:9000) ---

--- 53. Tokenization (XML to Words) ---
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet href="CoreNLP-to-HTML.xsl" type="text/xsl"?>
<root>
  <document>
    <sentences>
      <sentence id="1">
        <tokens>
          <token id="1">
            <word>Natural</word>
            <lemma>natural</lemma>
            <CharacterOffsetBegin>0</CharacterOffsetBegin>
            <CharacterOffsetEnd>7</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="2">
            <word>language</word>
            <lemma>language</lemma>
            <CharacterOffsetBegin>8</CharacterOffsetBegin>
            <CharacterOffsetEnd>16</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="3">
            <word>processing</word>
            <lemma>processing</lemma>
            <CharacterOffsetBegin>17</CharacterOffsetBegin>
            <CharacterOffsetEnd>27</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="4">
            <word>From</word>
            <lemma>from</lemma>
            <CharacterOffsetBegin>28</CharacterOffsetBegin>
            <CharacterOffsetEnd>32</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="5">
            <word>Wikipedia</word>
            <lemma>Wikipedia</lemma>
            <CharacterOffsetBegin>33</CharacterOffsetBegin>
            <CharacterOffsetEnd>42</CharacterOffsetEnd>
            <POS>NNP</POS>
            <NER>ORGANIZATION</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="6">
            <word>,</word>
            <lemma>,</lemma>
            <CharacterOffsetBegin>42</CharacterOffsetBegin>
            <CharacterOffsetEnd>43</CharacterOffsetEnd>
            <POS>,</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="7">
            <word>the</word>
            <lemma>the</lemma>
            <CharacterOffsetBegin>44</CharacterOffsetBegin>
            <CharacterOffsetEnd>47</CharacterOffsetEnd>
            <POS>DT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="8">
            <word>free</word>
            <lemma>free</lemma>
            <CharacterOffsetBegin>48</CharacterOffsetBegin>
            <CharacterOffsetEnd>52</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="9">
            <word>encyclopedia</word>
            <lemma>encyclopedia</lemma>
            <CharacterOffsetBegin>53</CharacterOffsetBegin>
            <CharacterOffsetEnd>65</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>MISC</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="10">
            <word>Natural</word>
            <lemma>natural</lemma>
            <CharacterOffsetBegin>67</CharacterOffsetBegin>
            <CharacterOffsetEnd>74</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>MISC</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="11">
            <word>language</word>
            <lemma>language</lemma>
            <CharacterOffsetBegin>75</CharacterOffsetBegin>
            <CharacterOffsetEnd>83</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="12">
            <word>processing</word>
            <lemma>processing</lemma>
            <CharacterOffsetBegin>84</CharacterOffsetBegin>
            <CharacterOffsetEnd>94</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="13">
            <word>(</word>
            <lemma>(</lemma>
            <CharacterOffsetBegin>95</CharacterOffsetBegin>
            <CharacterOffsetEnd>96</CharacterOffsetEnd>
            <POS>-LRB-</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="14">
            <word>NLP</word>
            <lemma>nlp</lemma>
            <CharacterOffsetBegin>96</CharacterOffsetBegin>
            <CharacterOffsetEnd>99</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="15">
            <word>)</word>
            <lemma>)</lemma>
            <CharacterOffsetBegin>99</CharacterOffsetBegin>
            <CharacterOffsetEnd>100</CharacterOffsetEnd>
            <POS>-RRB-</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="16">
            <word>is</word>
            <lemma>be</lemma>
            <CharacterOffsetBegin>101</CharacterOffsetBegin>
            <CharacterOffsetEnd>103</CharacterOffsetEnd>
            <POS>VBZ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="17">
            <word>a</word>
            <lemma>a</lemma>
            <CharacterOffsetBegin>104</CharacterOffsetBegin>
            <CharacterOffsetEnd>105</CharacterOffsetEnd>
            <POS>DT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="18">
            <word>field</word>
            <lemma>field</lemma>
            <CharacterOffsetBegin>106</CharacterOffsetBegin>
            <CharacterOffsetEnd>111</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="19">
            <word>of</word>
            <lemma>of</lemma>
            <CharacterOffsetBegin>112</CharacterOffsetBegin>
            <CharacterOffsetEnd>114</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="20">
            <word>computer</word>
            <lemma>computer</lemma>
            <CharacterOffsetBegin>115</CharacterOffsetBegin>
            <CharacterOffsetEnd>123</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="21">
            <word>science</word>
            <lemma>science</lemma>
            <CharacterOffsetBegin>124</CharacterOffsetBegin>
            <CharacterOffsetEnd>131</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="22">
            <word>,</word>
            <lemma>,</lemma>
            <CharacterOffsetBegin>131</CharacterOffsetBegin>
            <CharacterOffsetEnd>132</CharacterOffsetEnd>
            <POS>,</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="23">
            <word>artificial</word>
            <lemma>artificial</lemma>
            <CharacterOffsetBegin>133</CharacterOffsetBegin>
            <CharacterOffsetEnd>143</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="24">
            <word>intelligence</word>
            <lemma>intelligence</lemma>
            <CharacterOffsetBegin>144</CharacterOffsetBegin>
            <CharacterOffsetEnd>156</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="25">
            <word>,</word>
            <lemma>,</lemma>
            <CharacterOffsetBegin>156</CharacterOffsetBegin>
            <CharacterOffsetEnd>157</CharacterOffsetEnd>
            <POS>,</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="26">
            <word>and</word>
            <lemma>and</lemma>
            <CharacterOffsetBegin>158</CharacterOffsetBegin>
            <CharacterOffsetEnd>161</CharacterOffsetEnd>
            <POS>CC</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="27">
            <word>linguistics</word>
            <lemma>linguistics</lemma>
            <CharacterOffsetBegin>162</CharacterOffsetBegin>
            <CharacterOffsetEnd>173</CharacterOffsetEnd>
            <POS>NNS</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="28">
            <word>concerned</word>
            <lemma>concern</lemma>
            <CharacterOffsetBegin>174</CharacterOffsetBegin>
            <CharacterOffsetEnd>183</CharacterOffsetEnd>
            <POS>VBN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="29">
            <word>with</word>
            <lemma>with</lemma>
            <CharacterOffsetBegin>184</CharacterOffsetBegin>
            <CharacterOffsetEnd>188</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="30">
            <word>the</word>
            <lemma>the</lemma>
            <CharacterOffsetBegin>189</CharacterOffsetBegin>
            <CharacterOffsetEnd>192</CharacterOffsetEnd>
            <POS>DT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="31">
            <word>interactions</word>
            <lemma>interaction</lemma>
            <CharacterOffsetBegin>193</CharacterOffsetBegin>
            <CharacterOffsetEnd>205</CharacterOffsetEnd>
            <POS>NNS</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="32">
            <word>between</word>
            <lemma>between</lemma>
            <CharacterOffsetBegin>206</CharacterOffsetBegin>
            <CharacterOffsetEnd>213</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="33">
            <word>computers</word>
            <lemma>computer</lemma>
            <CharacterOffsetBegin>214</CharacterOffsetBegin>
            <CharacterOffsetEnd>223</CharacterOffsetEnd>
            <POS>NNS</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="34">
            <word>and</word>
            <lemma>and</lemma>
            <CharacterOffsetBegin>224</CharacterOffsetBegin>
            <CharacterOffsetEnd>227</CharacterOffsetEnd>
            <POS>CC</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="35">
            <word>human</word>
            <lemma>human</lemma>
            <CharacterOffsetBegin>228</CharacterOffsetBegin>
            <CharacterOffsetEnd>233</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="36">
            <word>(</word>
            <lemma>(</lemma>
            <CharacterOffsetBegin>234</CharacterOffsetBegin>
            <CharacterOffsetEnd>235</CharacterOffsetEnd>
            <POS>-LRB-</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="37">
            <word>natural</word>
            <lemma>natural</lemma>
            <CharacterOffsetBegin>235</CharacterOffsetBegin>
            <CharacterOffsetEnd>242</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="38">
            <word>)</word>
            <lemma>)</lemma>
            <CharacterOffsetBegin>242</CharacterOffsetBegin>
            <CharacterOffsetEnd>243</CharacterOffsetEnd>
            <POS>-RRB-</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="39">
            <word>languages</word>
            <lemma>language</lemma>
            <CharacterOffsetBegin>244</CharacterOffsetBegin>
            <CharacterOffsetEnd>253</CharacterOffsetEnd>
            <POS>NNS</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="40">
            <word>.</word>
            <lemma>.</lemma>
            <CharacterOffsetBegin>253</CharacterOffsetBegin>
            <CharacterOffsetEnd>254</CharacterOffsetEnd>
            <POS>.</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
        </tokens>
        <parse>(ROOT (S (PP (NP (JJ Natural) (NN language) (NN processing)) (IN From) (NP (NNP Wikipedia))) (, ,) (NP (NP (DT the) (JJ free) (NN encyclopedia)) (NP (JJ Natural) (NN language) (NN processing)) (PRN (-LRB- -LRB-) (NP (NN NLP)) (-RRB- -RRB-))) (VP (VBZ is) (NP (NP (DT a) (NN field)) (PP (IN of) (NP (NP (NN computer) (NN science)) (, ,) (NP (JJ artificial) (NN intelligence)) (, ,) (CC and) (NP (NP (NNS linguistics)) (VP (VBN concerned) (PP (IN with) (NP (NP (DT the) (NNS interactions)) (PP (IN between) (NP (NP (NNS computers)) (CC and) (NP (JJ human) (-LRB- -LRB-) (JJ natural) (-RRB- -RRB-) (NNS languages)))))))))))) (. .))) </parse>
        <dependencies type="basic-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="18">field</dependent>
          </dep>
          <dep type="amod">
            <governor idx="2">language</governor>
            <dependent idx="1">Natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="3">processing</governor>
            <dependent idx="2">language</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="18">field</governor>
            <dependent idx="3">processing</dependent>
          </dep>
          <dep type="case">
            <governor idx="5">Wikipedia</governor>
            <dependent idx="4">From</dependent>
          </dep>
          <dep type="nmod">
            <governor idx="3">processing</governor>
            <dependent idx="5">Wikipedia</dependent>
          </dep>
          <dep type="punct">
            <governor idx="3">processing</governor>
            <dependent idx="6">,</dependent>
          </dep>
          <dep type="det">
            <governor idx="14">NLP</governor>
            <dependent idx="7">the</dependent>
          </dep>
          <dep type="amod">
            <governor idx="9">encyclopedia</governor>
            <dependent idx="8">free</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">processing</governor>
            <dependent idx="9">encyclopedia</dependent>
          </dep>
          <dep type="amod">
            <governor idx="11">language</governor>
            <dependent idx="10">Natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">processing</governor>
            <dependent idx="11">language</dependent>
          </dep>
          <dep type="dep">
            <governor idx="14">NLP</governor>
            <dependent idx="12">processing</dependent>
          </dep>
          <dep type="punct">
            <governor idx="14">NLP</governor>
            <dependent idx="13">(</dependent>
          </dep>
          <dep type="appos">
            <governor idx="3">processing</governor>
            <dependent idx="14">NLP</dependent>
          </dep>
          <dep type="punct">
            <governor idx="18">field</governor>
            <dependent idx="15">)</dependent>
          </dep>
          <dep type="cop">
            <governor idx="18">field</governor>
            <dependent idx="16">is</dependent>
          </dep>
          <dep type="det">
            <governor idx="18">field</governor>
            <dependent idx="17">a</dependent>
          </dep>
          <dep type="case">
            <governor idx="21">science</governor>
            <dependent idx="19">of</dependent>
          </dep>
          <dep type="compound">
            <governor idx="21">science</governor>
            <dependent idx="20">computer</dependent>
          </dep>
          <dep type="nmod">
            <governor idx="18">field</governor>
            <dependent idx="21">science</dependent>
          </dep>
          <dep type="punct">
            <governor idx="21">science</governor>
            <dependent idx="22">,</dependent>
          </dep>
          <dep type="amod">
            <governor idx="24">intelligence</governor>
            <dependent idx="23">artificial</dependent>
          </dep>
          <dep type="conj">
            <governor idx="21">science</governor>
            <dependent idx="24">intelligence</dependent>
          </dep>
          <dep type="punct">
            <governor idx="21">science</governor>
            <dependent idx="25">,</dependent>
          </dep>
          <dep type="cc">
            <governor idx="27">linguistics</governor>
            <dependent idx="26">and</dependent>
          </dep>
          <dep type="conj">
            <governor idx="21">science</governor>
            <dependent idx="27">linguistics</dependent>
          </dep>
          <dep type="amod">
            <governor idx="18">field</governor>
            <dependent idx="28">concerned</dependent>
          </dep>
          <dep type="case">
            <governor idx="31">interactions</governor>
            <dependent idx="29">with</dependent>
          </dep>
          <dep type="det">
            <governor idx="31">interactions</governor>
            <dependent idx="30">the</dependent>
          </dep>
          <dep type="obl">
            <governor idx="28">concerned</governor>
            <dependent idx="31">interactions</dependent>
          </dep>
          <dep type="case">
            <governor idx="33">computers</governor>
            <dependent idx="32">between</dependent>
          </dep>
          <dep type="nmod">
            <governor idx="31">interactions</governor>
            <dependent idx="33">computers</dependent>
          </dep>
          <dep type="cc">
            <governor idx="39">languages</governor>
            <dependent idx="34">and</dependent>
          </dep>
          <dep type="amod">
            <governor idx="39">languages</governor>
            <dependent idx="35">human</dependent>
          </dep>
          <dep type="punct">
            <governor idx="39">languages</governor>
            <dependent idx="36">(</dependent>
          </dep>
          <dep type="amod">
            <governor idx="39">languages</governor>
            <dependent idx="37">natural</dependent>
          </dep>
          <dep type="punct">
            <governor idx="39">languages</governor>
            <dependent idx="38">)</dependent>
          </dep>
          <dep type="conj">
            <governor idx="33">computers</governor>
            <dependent idx="39">languages</dependent>
          </dep>
          <dep type="punct">
            <governor idx="18">field</governor>
            <dependent idx="40">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="18">field</dependent>
          </dep>
          <dep type="amod">
            <governor idx="2">language</governor>
            <dependent idx="1">Natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="3">processing</governor>
            <dependent idx="2">language</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="18">field</governor>
            <dependent idx="3">processing</dependent>
          </dep>
          <dep type="case">
            <governor idx="5">Wikipedia</governor>
            <dependent idx="4">From</dependent>
          </dep>
          <dep type="nmod:from">
            <governor idx="3">processing</governor>
            <dependent idx="5">Wikipedia</dependent>
          </dep>
          <dep type="punct">
            <governor idx="3">processing</governor>
            <dependent idx="6">,</dependent>
          </dep>
          <dep type="det">
            <governor idx="14">NLP</governor>
            <dependent idx="7">the</dependent>
          </dep>
          <dep type="amod">
            <governor idx="9">encyclopedia</governor>
            <dependent idx="8">free</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">processing</governor>
            <dependent idx="9">encyclopedia</dependent>
          </dep>
          <dep type="amod">
            <governor idx="11">language</governor>
            <dependent idx="10">Natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">processing</governor>
            <dependent idx="11">language</dependent>
          </dep>
          <dep type="dep">
            <governor idx="14">NLP</governor>
            <dependent idx="12">processing</dependent>
          </dep>
          <dep type="punct">
            <governor idx="14">NLP</governor>
            <dependent idx="13">(</dependent>
          </dep>
          <dep type="appos">
            <governor idx="3">processing</governor>
            <dependent idx="14">NLP</dependent>
          </dep>
          <dep type="punct">
            <governor idx="18">field</governor>
            <dependent idx="15">)</dependent>
          </dep>
          <dep type="cop">
            <governor idx="18">field</governor>
            <dependent idx="16">is</dependent>
          </dep>
          <dep type="det">
            <governor idx="18">field</governor>
            <dependent idx="17">a</dependent>
          </dep>
          <dep type="case">
            <governor idx="21">science</governor>
            <dependent idx="19">of</dependent>
          </dep>
          <dep type="compound">
            <governor idx="21">science</governor>
            <dependent idx="20">computer</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="18">field</governor>
            <dependent idx="21">science</dependent>
          </dep>
          <dep type="punct">
            <governor idx="21">science</governor>
            <dependent idx="22">,</dependent>
          </dep>
          <dep type="amod">
            <governor idx="24">intelligence</governor>
            <dependent idx="23">artificial</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="21">science</governor>
            <dependent idx="24">intelligence</dependent>
          </dep>
          <dep type="punct">
            <governor idx="21">science</governor>
            <dependent idx="25">,</dependent>
          </dep>
          <dep type="cc">
            <governor idx="27">linguistics</governor>
            <dependent idx="26">and</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="21">science</governor>
            <dependent idx="27">linguistics</dependent>
          </dep>
          <dep type="amod">
            <governor idx="18">field</governor>
            <dependent idx="28">concerned</dependent>
          </dep>
          <dep type="case">
            <governor idx="31">interactions</governor>
            <dependent idx="29">with</dependent>
          </dep>
          <dep type="det">
            <governor idx="31">interactions</governor>
            <dependent idx="30">the</dependent>
          </dep>
          <dep type="obl:with">
            <governor idx="28">concerned</governor>
            <dependent idx="31">interactions</dependent>
          </dep>
          <dep type="case">
            <governor idx="33">computers</governor>
            <dependent idx="32">between</dependent>
          </dep>
          <dep type="nmod:between">
            <governor idx="31">interactions</governor>
            <dependent idx="33">computers</dependent>
          </dep>
          <dep type="cc">
            <governor idx="39">languages</governor>
            <dependent idx="34">and</dependent>
          </dep>
          <dep type="amod">
            <governor idx="39">languages</governor>
            <dependent idx="35">human</dependent>
          </dep>
          <dep type="punct">
            <governor idx="39">languages</governor>
            <dependent idx="36">(</dependent>
          </dep>
          <dep type="amod">
            <governor idx="39">languages</governor>
            <dependent idx="37">natural</dependent>
          </dep>
          <dep type="punct">
            <governor idx="39">languages</governor>
            <dependent idx="38">)</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="33">computers</governor>
            <dependent idx="39">languages</dependent>
          </dep>
          <dep type="punct">
            <governor idx="18">field</governor>
            <dependent idx="40">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-ccprocessed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="18">field</dependent>
          </dep>
          <dep type="amod">
            <governor idx="2">language</governor>
            <dependent idx="1">Natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="3">processing</governor>
            <dependent idx="2">language</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="18">field</governor>
            <dependent idx="3">processing</dependent>
          </dep>
          <dep type="case">
            <governor idx="5">Wikipedia</governor>
            <dependent idx="4">From</dependent>
          </dep>
          <dep type="nmod:from">
            <governor idx="3">processing</governor>
            <dependent idx="5">Wikipedia</dependent>
          </dep>
          <dep type="punct">
            <governor idx="3">processing</governor>
            <dependent idx="6">,</dependent>
          </dep>
          <dep type="det">
            <governor idx="14">NLP</governor>
            <dependent idx="7">the</dependent>
          </dep>
          <dep type="amod">
            <governor idx="9">encyclopedia</governor>
            <dependent idx="8">free</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">processing</governor>
            <dependent idx="9">encyclopedia</dependent>
          </dep>
          <dep type="amod">
            <governor idx="11">language</governor>
            <dependent idx="10">Natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">processing</governor>
            <dependent idx="11">language</dependent>
          </dep>
          <dep type="dep">
            <governor idx="14">NLP</governor>
            <dependent idx="12">processing</dependent>
          </dep>
          <dep type="punct">
            <governor idx="14">NLP</governor>
            <dependent idx="13">(</dependent>
          </dep>
          <dep type="appos">
            <governor idx="3">processing</governor>
            <dependent idx="14">NLP</dependent>
          </dep>
          <dep type="punct">
            <governor idx="18">field</governor>
            <dependent idx="15">)</dependent>
          </dep>
          <dep type="cop">
            <governor idx="18">field</governor>
            <dependent idx="16">is</dependent>
          </dep>
          <dep type="det">
            <governor idx="18">field</governor>
            <dependent idx="17">a</dependent>
          </dep>
          <dep type="case">
            <governor idx="21">science</governor>
            <dependent idx="19">of</dependent>
          </dep>
          <dep type="compound">
            <governor idx="21">science</governor>
            <dependent idx="20">computer</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="18">field</governor>
            <dependent idx="21">science</dependent>
          </dep>
          <dep type="punct">
            <governor idx="21">science</governor>
            <dependent idx="22">,</dependent>
          </dep>
          <dep type="amod">
            <governor idx="24">intelligence</governor>
            <dependent idx="23">artificial</dependent>
          </dep>
          <dep type="nmod:of" extra="true">
            <governor idx="18">field</governor>
            <dependent idx="24">intelligence</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="21">science</governor>
            <dependent idx="24">intelligence</dependent>
          </dep>
          <dep type="punct">
            <governor idx="21">science</governor>
            <dependent idx="25">,</dependent>
          </dep>
          <dep type="cc">
            <governor idx="27">linguistics</governor>
            <dependent idx="26">and</dependent>
          </dep>
          <dep type="nmod:of" extra="true">
            <governor idx="18">field</governor>
            <dependent idx="27">linguistics</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="21">science</governor>
            <dependent idx="27">linguistics</dependent>
          </dep>
          <dep type="amod">
            <governor idx="18">field</governor>
            <dependent idx="28">concerned</dependent>
          </dep>
          <dep type="case">
            <governor idx="31">interactions</governor>
            <dependent idx="29">with</dependent>
          </dep>
          <dep type="det">
            <governor idx="31">interactions</governor>
            <dependent idx="30">the</dependent>
          </dep>
          <dep type="obl:with">
            <governor idx="28">concerned</governor>
            <dependent idx="31">interactions</dependent>
          </dep>
          <dep type="case">
            <governor idx="33">computers</governor>
            <dependent idx="32">between</dependent>
          </dep>
          <dep type="nmod:between">
            <governor idx="31">interactions</governor>
            <dependent idx="33">computers</dependent>
          </dep>
          <dep type="cc">
            <governor idx="39">languages</governor>
            <dependent idx="34">and</dependent>
          </dep>
          <dep type="amod">
            <governor idx="39">languages</governor>
            <dependent idx="35">human</dependent>
          </dep>
          <dep type="punct">
            <governor idx="39">languages</governor>
            <dependent idx="36">(</dependent>
          </dep>
          <dep type="amod">
            <governor idx="39">languages</governor>
            <dependent idx="37">natural</dependent>
          </dep>
          <dep type="punct">
            <governor idx="39">languages</governor>
            <dependent idx="38">)</dependent>
          </dep>
          <dep type="nmod:between" extra="true">
            <governor idx="31">interactions</governor>
            <dependent idx="39">languages</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="33">computers</governor>
            <dependent idx="39">languages</dependent>
          </dep>
          <dep type="punct">
            <governor idx="18">field</governor>
            <dependent idx="40">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="18">field</dependent>
          </dep>
          <dep type="amod">
            <governor idx="2">language</governor>
            <dependent idx="1">Natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="3">processing</governor>
            <dependent idx="2">language</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="18">field</governor>
            <dependent idx="3">processing</dependent>
          </dep>
          <dep type="case">
            <governor idx="5">Wikipedia</governor>
            <dependent idx="4">From</dependent>
          </dep>
          <dep type="nmod:from">
            <governor idx="3">processing</governor>
            <dependent idx="5">Wikipedia</dependent>
          </dep>
          <dep type="punct">
            <governor idx="3">processing</governor>
            <dependent idx="6">,</dependent>
          </dep>
          <dep type="det">
            <governor idx="14">NLP</governor>
            <dependent idx="7">the</dependent>
          </dep>
          <dep type="amod">
            <governor idx="9">encyclopedia</governor>
            <dependent idx="8">free</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">processing</governor>
            <dependent idx="9">encyclopedia</dependent>
          </dep>
          <dep type="amod">
            <governor idx="11">language</governor>
            <dependent idx="10">Natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">processing</governor>
            <dependent idx="11">language</dependent>
          </dep>
          <dep type="dep">
            <governor idx="14">NLP</governor>
            <dependent idx="12">processing</dependent>
          </dep>
          <dep type="punct">
            <governor idx="14">NLP</governor>
            <dependent idx="13">(</dependent>
          </dep>
          <dep type="appos">
            <governor idx="3">processing</governor>
            <dependent idx="14">NLP</dependent>
          </dep>
          <dep type="punct">
            <governor idx="18">field</governor>
            <dependent idx="15">)</dependent>
          </dep>
          <dep type="cop">
            <governor idx="18">field</governor>
            <dependent idx="16">is</dependent>
          </dep>
          <dep type="det">
            <governor idx="18">field</governor>
            <dependent idx="17">a</dependent>
          </dep>
          <dep type="case">
            <governor idx="21">science</governor>
            <dependent idx="19">of</dependent>
          </dep>
          <dep type="compound">
            <governor idx="21">science</governor>
            <dependent idx="20">computer</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="18">field</governor>
            <dependent idx="21">science</dependent>
          </dep>
          <dep type="punct">
            <governor idx="21">science</governor>
            <dependent idx="22">,</dependent>
          </dep>
          <dep type="amod">
            <governor idx="24">intelligence</governor>
            <dependent idx="23">artificial</dependent>
          </dep>
          <dep type="nmod:of" extra="true">
            <governor idx="18">field</governor>
            <dependent idx="24">intelligence</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="21">science</governor>
            <dependent idx="24">intelligence</dependent>
          </dep>
          <dep type="punct">
            <governor idx="21">science</governor>
            <dependent idx="25">,</dependent>
          </dep>
          <dep type="cc">
            <governor idx="27">linguistics</governor>
            <dependent idx="26">and</dependent>
          </dep>
          <dep type="nmod:of" extra="true">
            <governor idx="18">field</governor>
            <dependent idx="27">linguistics</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="21">science</governor>
            <dependent idx="27">linguistics</dependent>
          </dep>
          <dep type="amod">
            <governor idx="18">field</governor>
            <dependent idx="28">concerned</dependent>
          </dep>
          <dep type="case">
            <governor idx="31">interactions</governor>
            <dependent idx="29">with</dependent>
          </dep>
          <dep type="det">
            <governor idx="31">interactions</governor>
            <dependent idx="30">the</dependent>
          </dep>
          <dep type="obl:with">
            <governor idx="28">concerned</governor>
            <dependent idx="31">interactions</dependent>
          </dep>
          <dep type="case">
            <governor idx="33">computers</governor>
            <dependent idx="32">between</dependent>
          </dep>
          <dep type="nmod:between">
            <governor idx="31">interactions</governor>
            <dependent idx="33">computers</dependent>
          </dep>
          <dep type="cc">
            <governor idx="39">languages</governor>
            <dependent idx="34">and</dependent>
          </dep>
          <dep type="amod">
            <governor idx="39">languages</governor>
            <dependent idx="35">human</dependent>
          </dep>
          <dep type="punct">
            <governor idx="39">languages</governor>
            <dependent idx="36">(</dependent>
          </dep>
          <dep type="amod">
            <governor idx="39">languages</governor>
            <dependent idx="37">natural</dependent>
          </dep>
          <dep type="punct">
            <governor idx="39">languages</governor>
            <dependent idx="38">)</dependent>
          </dep>
          <dep type="nmod:between" extra="true">
            <governor idx="31">interactions</governor>
            <dependent idx="39">languages</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="33">computers</governor>
            <dependent idx="39">languages</dependent>
          </dep>
          <dep type="punct">
            <governor idx="18">field</governor>
            <dependent idx="40">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-plus-plus-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="18">field</dependent>
          </dep>
          <dep type="amod">
            <governor idx="2">language</governor>
            <dependent idx="1">Natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="3">processing</governor>
            <dependent idx="2">language</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="18">field</governor>
            <dependent idx="3">processing</dependent>
          </dep>
          <dep type="case">
            <governor idx="5">Wikipedia</governor>
            <dependent idx="4">From</dependent>
          </dep>
          <dep type="nmod:from">
            <governor idx="3">processing</governor>
            <dependent idx="5">Wikipedia</dependent>
          </dep>
          <dep type="punct">
            <governor idx="3">processing</governor>
            <dependent idx="6">,</dependent>
          </dep>
          <dep type="det">
            <governor idx="14">NLP</governor>
            <dependent idx="7">the</dependent>
          </dep>
          <dep type="amod">
            <governor idx="9">encyclopedia</governor>
            <dependent idx="8">free</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">processing</governor>
            <dependent idx="9">encyclopedia</dependent>
          </dep>
          <dep type="amod">
            <governor idx="11">language</governor>
            <dependent idx="10">Natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">processing</governor>
            <dependent idx="11">language</dependent>
          </dep>
          <dep type="dep">
            <governor idx="14">NLP</governor>
            <dependent idx="12">processing</dependent>
          </dep>
          <dep type="punct">
            <governor idx="14">NLP</governor>
            <dependent idx="13">(</dependent>
          </dep>
          <dep type="appos">
            <governor idx="3">processing</governor>
            <dependent idx="14">NLP</dependent>
          </dep>
          <dep type="punct">
            <governor idx="18">field</governor>
            <dependent idx="15">)</dependent>
          </dep>
          <dep type="cop">
            <governor idx="18">field</governor>
            <dependent idx="16">is</dependent>
          </dep>
          <dep type="det">
            <governor idx="18">field</governor>
            <dependent idx="17">a</dependent>
          </dep>
          <dep type="case">
            <governor idx="21">science</governor>
            <dependent idx="19">of</dependent>
          </dep>
          <dep type="compound">
            <governor idx="21">science</governor>
            <dependent idx="20">computer</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="18">field</governor>
            <dependent idx="21">science</dependent>
          </dep>
          <dep type="punct">
            <governor idx="21">science</governor>
            <dependent idx="22">,</dependent>
          </dep>
          <dep type="amod">
            <governor idx="24">intelligence</governor>
            <dependent idx="23">artificial</dependent>
          </dep>
          <dep type="nmod:of" extra="true">
            <governor idx="18">field</governor>
            <dependent idx="24">intelligence</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="21">science</governor>
            <dependent idx="24">intelligence</dependent>
          </dep>
          <dep type="punct">
            <governor idx="21">science</governor>
            <dependent idx="25">,</dependent>
          </dep>
          <dep type="cc">
            <governor idx="27">linguistics</governor>
            <dependent idx="26">and</dependent>
          </dep>
          <dep type="nmod:of" extra="true">
            <governor idx="18">field</governor>
            <dependent idx="27">linguistics</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="21">science</governor>
            <dependent idx="27">linguistics</dependent>
          </dep>
          <dep type="amod">
            <governor idx="18">field</governor>
            <dependent idx="28">concerned</dependent>
          </dep>
          <dep type="case">
            <governor idx="31">interactions</governor>
            <dependent idx="29">with</dependent>
          </dep>
          <dep type="det">
            <governor idx="31">interactions</governor>
            <dependent idx="30">the</dependent>
          </dep>
          <dep type="obl:with">
            <governor idx="28">concerned</governor>
            <dependent idx="31">interactions</dependent>
          </dep>
          <dep type="case">
            <governor idx="33">computers</governor>
            <dependent idx="32">between</dependent>
          </dep>
          <dep type="nmod:between">
            <governor idx="31">interactions</governor>
            <dependent idx="33">computers</dependent>
          </dep>
          <dep type="cc">
            <governor idx="39">languages</governor>
            <dependent idx="34">and</dependent>
          </dep>
          <dep type="amod">
            <governor idx="39">languages</governor>
            <dependent idx="35">human</dependent>
          </dep>
          <dep type="punct">
            <governor idx="39">languages</governor>
            <dependent idx="36">(</dependent>
          </dep>
          <dep type="amod">
            <governor idx="39">languages</governor>
            <dependent idx="37">natural</dependent>
          </dep>
          <dep type="punct">
            <governor idx="39">languages</governor>
            <dependent idx="38">)</dependent>
          </dep>
          <dep type="nmod:between" extra="true">
            <governor idx="31">interactions</governor>
            <dependent idx="39">languages</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="33">computers</governor>
            <dependent idx="39">languages</dependent>
          </dep>
          <dep type="punct">
            <governor idx="18">field</governor>
            <dependent idx="40">.</dependent>
          </dep>
        </dependencies>
      </sentence>
      <sentence id="2">
        <tokens>
          <token id="1">
            <word>As</word>
            <lemma>as</lemma>
            <CharacterOffsetBegin>255</CharacterOffsetBegin>
            <CharacterOffsetEnd>257</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="2">
            <word>such</word>
            <lemma>such</lemma>
            <CharacterOffsetBegin>258</CharacterOffsetBegin>
            <CharacterOffsetEnd>262</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="3">
            <word>,</word>
            <lemma>,</lemma>
            <CharacterOffsetBegin>262</CharacterOffsetBegin>
            <CharacterOffsetEnd>263</CharacterOffsetEnd>
            <POS>,</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="4">
            <word>NLP</word>
            <lemma>nlp</lemma>
            <CharacterOffsetBegin>264</CharacterOffsetBegin>
            <CharacterOffsetEnd>267</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>ORGANIZATION</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="5">
            <word>is</word>
            <lemma>be</lemma>
            <CharacterOffsetBegin>268</CharacterOffsetBegin>
            <CharacterOffsetEnd>270</CharacterOffsetEnd>
            <POS>VBZ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="6">
            <word>related</word>
            <lemma>relate</lemma>
            <CharacterOffsetBegin>271</CharacterOffsetBegin>
            <CharacterOffsetEnd>278</CharacterOffsetEnd>
            <POS>VBN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="7">
            <word>to</word>
            <lemma>to</lemma>
            <CharacterOffsetBegin>279</CharacterOffsetBegin>
            <CharacterOffsetEnd>281</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="8">
            <word>the</word>
            <lemma>the</lemma>
            <CharacterOffsetBegin>282</CharacterOffsetBegin>
            <CharacterOffsetEnd>285</CharacterOffsetEnd>
            <POS>DT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="9">
            <word>area</word>
            <lemma>area</lemma>
            <CharacterOffsetBegin>286</CharacterOffsetBegin>
            <CharacterOffsetEnd>290</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="10">
            <word>of</word>
            <lemma>of</lemma>
            <CharacterOffsetBegin>291</CharacterOffsetBegin>
            <CharacterOffsetEnd>293</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="11">
            <word>humani</word>
            <lemma>humani</lemma>
            <CharacterOffsetBegin>294</CharacterOffsetBegin>
            <CharacterOffsetEnd>300</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="12">
            <word>-</word>
            <lemma>-</lemma>
            <CharacterOffsetBegin>300</CharacterOffsetBegin>
            <CharacterOffsetEnd>301</CharacterOffsetEnd>
            <POS>HYPH</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="13">
            <word>computer</word>
            <lemma>computer</lemma>
            <CharacterOffsetBegin>301</CharacterOffsetBegin>
            <CharacterOffsetEnd>309</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="14">
            <word>interaction</word>
            <lemma>interaction</lemma>
            <CharacterOffsetBegin>310</CharacterOffsetBegin>
            <CharacterOffsetEnd>321</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="15">
            <word>.</word>
            <lemma>.</lemma>
            <CharacterOffsetBegin>321</CharacterOffsetBegin>
            <CharacterOffsetEnd>322</CharacterOffsetEnd>
            <POS>.</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
        </tokens>
        <parse>(ROOT (S (PP (IN As) (ADJP (JJ such))) (, ,) (NP (NN NLP)) (VP (VBZ is) (VP (VBN related) (PP (IN to) (NP (NP (DT the) (NN area)) (PP (IN of) (NP (ADJP (JJ humani) (HYPH -) (NN computer)) (NN interaction))))))) (. .))) </parse>
        <dependencies type="basic-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="6">related</dependent>
          </dep>
          <dep type="case">
            <governor idx="2">such</governor>
            <dependent idx="1">As</dependent>
          </dep>
          <dep type="obl">
            <governor idx="6">related</governor>
            <dependent idx="2">such</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">related</governor>
            <dependent idx="3">,</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="6">related</governor>
            <dependent idx="4">NLP</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="6">related</governor>
            <dependent idx="5">is</dependent>
          </dep>
          <dep type="case">
            <governor idx="9">area</governor>
            <dependent idx="7">to</dependent>
          </dep>
          <dep type="det">
            <governor idx="9">area</governor>
            <dependent idx="8">the</dependent>
          </dep>
          <dep type="obl">
            <governor idx="6">related</governor>
            <dependent idx="9">area</dependent>
          </dep>
          <dep type="case">
            <governor idx="14">interaction</governor>
            <dependent idx="10">of</dependent>
          </dep>
          <dep type="amod">
            <governor idx="13">computer</governor>
            <dependent idx="11">humani</dependent>
          </dep>
          <dep type="punct">
            <governor idx="13">computer</governor>
            <dependent idx="12">-</dependent>
          </dep>
          <dep type="compound">
            <governor idx="14">interaction</governor>
            <dependent idx="13">computer</dependent>
          </dep>
          <dep type="nmod">
            <governor idx="9">area</governor>
            <dependent idx="14">interaction</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">related</governor>
            <dependent idx="15">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="6">related</dependent>
          </dep>
          <dep type="case">
            <governor idx="2">such</governor>
            <dependent idx="1">As</dependent>
          </dep>
          <dep type="obl:as">
            <governor idx="6">related</governor>
            <dependent idx="2">such</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">related</governor>
            <dependent idx="3">,</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="6">related</governor>
            <dependent idx="4">NLP</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="6">related</governor>
            <dependent idx="5">is</dependent>
          </dep>
          <dep type="case">
            <governor idx="9">area</governor>
            <dependent idx="7">to</dependent>
          </dep>
          <dep type="det">
            <governor idx="9">area</governor>
            <dependent idx="8">the</dependent>
          </dep>
          <dep type="obl:to">
            <governor idx="6">related</governor>
            <dependent idx="9">area</dependent>
          </dep>
          <dep type="case">
            <governor idx="14">interaction</governor>
            <dependent idx="10">of</dependent>
          </dep>
          <dep type="amod">
            <governor idx="13">computer</governor>
            <dependent idx="11">humani</dependent>
          </dep>
          <dep type="punct">
            <governor idx="13">computer</governor>
            <dependent idx="12">-</dependent>
          </dep>
          <dep type="compound">
            <governor idx="14">interaction</governor>
            <dependent idx="13">computer</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="9">area</governor>
            <dependent idx="14">interaction</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">related</governor>
            <dependent idx="15">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-ccprocessed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="6">related</dependent>
          </dep>
          <dep type="case">
            <governor idx="2">such</governor>
            <dependent idx="1">As</dependent>
          </dep>
          <dep type="obl:as">
            <governor idx="6">related</governor>
            <dependent idx="2">such</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">related</governor>
            <dependent idx="3">,</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="6">related</governor>
            <dependent idx="4">NLP</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="6">related</governor>
            <dependent idx="5">is</dependent>
          </dep>
          <dep type="case">
            <governor idx="9">area</governor>
            <dependent idx="7">to</dependent>
          </dep>
          <dep type="det">
            <governor idx="9">area</governor>
            <dependent idx="8">the</dependent>
          </dep>
          <dep type="obl:to">
            <governor idx="6">related</governor>
            <dependent idx="9">area</dependent>
          </dep>
          <dep type="case">
            <governor idx="14">interaction</governor>
            <dependent idx="10">of</dependent>
          </dep>
          <dep type="amod">
            <governor idx="13">computer</governor>
            <dependent idx="11">humani</dependent>
          </dep>
          <dep type="punct">
            <governor idx="13">computer</governor>
            <dependent idx="12">-</dependent>
          </dep>
          <dep type="compound">
            <governor idx="14">interaction</governor>
            <dependent idx="13">computer</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="9">area</governor>
            <dependent idx="14">interaction</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">related</governor>
            <dependent idx="15">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="6">related</dependent>
          </dep>
          <dep type="case">
            <governor idx="2">such</governor>
            <dependent idx="1">As</dependent>
          </dep>
          <dep type="obl:as">
            <governor idx="6">related</governor>
            <dependent idx="2">such</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">related</governor>
            <dependent idx="3">,</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="6">related</governor>
            <dependent idx="4">NLP</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="6">related</governor>
            <dependent idx="5">is</dependent>
          </dep>
          <dep type="case">
            <governor idx="9">area</governor>
            <dependent idx="7">to</dependent>
          </dep>
          <dep type="det">
            <governor idx="9">area</governor>
            <dependent idx="8">the</dependent>
          </dep>
          <dep type="obl:to">
            <governor idx="6">related</governor>
            <dependent idx="9">area</dependent>
          </dep>
          <dep type="case">
            <governor idx="14">interaction</governor>
            <dependent idx="10">of</dependent>
          </dep>
          <dep type="amod">
            <governor idx="13">computer</governor>
            <dependent idx="11">humani</dependent>
          </dep>
          <dep type="punct">
            <governor idx="13">computer</governor>
            <dependent idx="12">-</dependent>
          </dep>
          <dep type="compound">
            <governor idx="14">interaction</governor>
            <dependent idx="13">computer</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="9">area</governor>
            <dependent idx="14">interaction</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">related</governor>
            <dependent idx="15">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-plus-plus-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="6">related</dependent>
          </dep>
          <dep type="case">
            <governor idx="2">such</governor>
            <dependent idx="1">As</dependent>
          </dep>
          <dep type="obl:as">
            <governor idx="6">related</governor>
            <dependent idx="2">such</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">related</governor>
            <dependent idx="3">,</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="6">related</governor>
            <dependent idx="4">NLP</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="6">related</governor>
            <dependent idx="5">is</dependent>
          </dep>
          <dep type="case">
            <governor idx="9">area</governor>
            <dependent idx="7">to</dependent>
          </dep>
          <dep type="det">
            <governor idx="9">area</governor>
            <dependent idx="8">the</dependent>
          </dep>
          <dep type="obl:to">
            <governor idx="6">related</governor>
            <dependent idx="9">area</dependent>
          </dep>
          <dep type="case">
            <governor idx="14">interaction</governor>
            <dependent idx="10">of</dependent>
          </dep>
          <dep type="amod">
            <governor idx="13">computer</governor>
            <dependent idx="11">humani</dependent>
          </dep>
          <dep type="punct">
            <governor idx="13">computer</governor>
            <dependent idx="12">-</dependent>
          </dep>
          <dep type="compound">
            <governor idx="14">interaction</governor>
            <dependent idx="13">computer</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="9">area</governor>
            <dependent idx="14">interaction</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">related</governor>
            <dependent idx="15">.</dependent>
          </dep>
        </dependencies>
      </sentence>
      <sentence id="3">
        <tokens>
          <token id="1">
            <word>Many</word>
            <lemma>many</lemma>
            <CharacterOffsetBegin>323</CharacterOffsetBegin>
            <CharacterOffsetEnd>327</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="2">
            <word>challenges</word>
            <lemma>challenge</lemma>
            <CharacterOffsetBegin>328</CharacterOffsetBegin>
            <CharacterOffsetEnd>338</CharacterOffsetEnd>
            <POS>NNS</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="3">
            <word>in</word>
            <lemma>in</lemma>
            <CharacterOffsetBegin>339</CharacterOffsetBegin>
            <CharacterOffsetEnd>341</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="4">
            <word>NLP</word>
            <lemma>nlp</lemma>
            <CharacterOffsetBegin>342</CharacterOffsetBegin>
            <CharacterOffsetEnd>345</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="5">
            <word>involve</word>
            <lemma>involve</lemma>
            <CharacterOffsetBegin>346</CharacterOffsetBegin>
            <CharacterOffsetEnd>353</CharacterOffsetEnd>
            <POS>VBP</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="6">
            <word>natural</word>
            <lemma>natural</lemma>
            <CharacterOffsetBegin>354</CharacterOffsetBegin>
            <CharacterOffsetEnd>361</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="7">
            <word>language</word>
            <lemma>language</lemma>
            <CharacterOffsetBegin>362</CharacterOffsetBegin>
            <CharacterOffsetEnd>370</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="8">
            <word>understanding</word>
            <lemma>understanding</lemma>
            <CharacterOffsetBegin>371</CharacterOffsetBegin>
            <CharacterOffsetEnd>384</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="9">
            <word>,</word>
            <lemma>,</lemma>
            <CharacterOffsetBegin>384</CharacterOffsetBegin>
            <CharacterOffsetEnd>385</CharacterOffsetEnd>
            <POS>,</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="10">
            <word>that</word>
            <lemma>that</lemma>
            <CharacterOffsetBegin>386</CharacterOffsetBegin>
            <CharacterOffsetEnd>390</CharacterOffsetEnd>
            <POS>DT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="11">
            <word>is</word>
            <lemma>be</lemma>
            <CharacterOffsetBegin>391</CharacterOffsetBegin>
            <CharacterOffsetEnd>393</CharacterOffsetEnd>
            <POS>VBZ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="12">
            <word>,</word>
            <lemma>,</lemma>
            <CharacterOffsetBegin>393</CharacterOffsetBegin>
            <CharacterOffsetEnd>394</CharacterOffsetEnd>
            <POS>,</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="13">
            <word>enabling</word>
            <lemma>enable</lemma>
            <CharacterOffsetBegin>395</CharacterOffsetBegin>
            <CharacterOffsetEnd>403</CharacterOffsetEnd>
            <POS>VBG</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="14">
            <word>computers</word>
            <lemma>computer</lemma>
            <CharacterOffsetBegin>404</CharacterOffsetBegin>
            <CharacterOffsetEnd>413</CharacterOffsetEnd>
            <POS>NNS</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="15">
            <word>to</word>
            <lemma>to</lemma>
            <CharacterOffsetBegin>414</CharacterOffsetBegin>
            <CharacterOffsetEnd>416</CharacterOffsetEnd>
            <POS>TO</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="16">
            <word>derive</word>
            <lemma>derive</lemma>
            <CharacterOffsetBegin>417</CharacterOffsetBegin>
            <CharacterOffsetEnd>423</CharacterOffsetEnd>
            <POS>VB</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="17">
            <word>meaning</word>
            <lemma>mean</lemma>
            <CharacterOffsetBegin>424</CharacterOffsetBegin>
            <CharacterOffsetEnd>431</CharacterOffsetEnd>
            <POS>VBG</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="18">
            <word>from</word>
            <lemma>from</lemma>
            <CharacterOffsetBegin>432</CharacterOffsetBegin>
            <CharacterOffsetEnd>436</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="19">
            <word>human</word>
            <lemma>human</lemma>
            <CharacterOffsetBegin>437</CharacterOffsetBegin>
            <CharacterOffsetEnd>442</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="20">
            <word>or</word>
            <lemma>or</lemma>
            <CharacterOffsetBegin>443</CharacterOffsetBegin>
            <CharacterOffsetEnd>445</CharacterOffsetEnd>
            <POS>CC</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="21">
            <word>natural</word>
            <lemma>natural</lemma>
            <CharacterOffsetBegin>446</CharacterOffsetBegin>
            <CharacterOffsetEnd>453</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="22">
            <word>language</word>
            <lemma>language</lemma>
            <CharacterOffsetBegin>454</CharacterOffsetBegin>
            <CharacterOffsetEnd>462</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="23">
            <word>input</word>
            <lemma>input</lemma>
            <CharacterOffsetBegin>463</CharacterOffsetBegin>
            <CharacterOffsetEnd>468</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="24">
            <word>,</word>
            <lemma>,</lemma>
            <CharacterOffsetBegin>468</CharacterOffsetBegin>
            <CharacterOffsetEnd>469</CharacterOffsetEnd>
            <POS>,</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="25">
            <word>and</word>
            <lemma>and</lemma>
            <CharacterOffsetBegin>470</CharacterOffsetBegin>
            <CharacterOffsetEnd>473</CharacterOffsetEnd>
            <POS>CC</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="26">
            <word>others</word>
            <lemma>other</lemma>
            <CharacterOffsetBegin>474</CharacterOffsetBegin>
            <CharacterOffsetEnd>480</CharacterOffsetEnd>
            <POS>NNS</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="27">
            <word>involve</word>
            <lemma>involve</lemma>
            <CharacterOffsetBegin>481</CharacterOffsetBegin>
            <CharacterOffsetEnd>488</CharacterOffsetEnd>
            <POS>VBP</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="28">
            <word>natural</word>
            <lemma>natural</lemma>
            <CharacterOffsetBegin>489</CharacterOffsetBegin>
            <CharacterOffsetEnd>496</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="29">
            <word>language</word>
            <lemma>language</lemma>
            <CharacterOffsetBegin>497</CharacterOffsetBegin>
            <CharacterOffsetEnd>505</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="30">
            <word>generation</word>
            <lemma>generation</lemma>
            <CharacterOffsetBegin>506</CharacterOffsetBegin>
            <CharacterOffsetEnd>516</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="31">
            <word>.</word>
            <lemma>.</lemma>
            <CharacterOffsetBegin>516</CharacterOffsetBegin>
            <CharacterOffsetEnd>517</CharacterOffsetEnd>
            <POS>.</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
        </tokens>
        <parse>(ROOT (S (S (NP (NP (JJ Many) (NNS challenges)) (PP (IN in) (NP (NN NLP)))) (VP (VBP involve) (NP (NML (JJ natural) (NN language)) (NN understanding)))) (, ,) (S (NP (DT that)) (VP (VBZ is) (, ,) (S (NP (VBG enabling) (NNS computers)) (VP (TO to) (VP (VB derive) (S (VP (VBG meaning) (PP (IN from) (NP (UCP (JJ human) (CC or) (NML (JJ natural) (NN language))) (NN input)))))))))) (, ,) (CC and) (S (NP (NNS others)) (VP (VBP involve) (NP (NML (JJ natural) (NN language)) (NN generation)))) (. .))) </parse>
        <dependencies type="basic-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="5">involve</dependent>
          </dep>
          <dep type="amod">
            <governor idx="2">challenges</governor>
            <dependent idx="1">Many</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="5">involve</governor>
            <dependent idx="2">challenges</dependent>
          </dep>
          <dep type="case">
            <governor idx="4">NLP</governor>
            <dependent idx="3">in</dependent>
          </dep>
          <dep type="nmod">
            <governor idx="2">challenges</governor>
            <dependent idx="4">NLP</dependent>
          </dep>
          <dep type="amod">
            <governor idx="7">language</governor>
            <dependent idx="6">natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="8">understanding</governor>
            <dependent idx="7">language</dependent>
          </dep>
          <dep type="obj">
            <governor idx="5">involve</governor>
            <dependent idx="8">understanding</dependent>
          </dep>
          <dep type="punct">
            <governor idx="5">involve</governor>
            <dependent idx="9">,</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="16">derive</governor>
            <dependent idx="10">that</dependent>
          </dep>
          <dep type="fixed">
            <governor idx="10">that</governor>
            <dependent idx="11">is</dependent>
          </dep>
          <dep type="punct">
            <governor idx="16">derive</governor>
            <dependent idx="12">,</dependent>
          </dep>
          <dep type="amod">
            <governor idx="14">computers</governor>
            <dependent idx="13">enabling</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="16">derive</governor>
            <dependent idx="14">computers</dependent>
          </dep>
          <dep type="mark">
            <governor idx="16">derive</governor>
            <dependent idx="15">to</dependent>
          </dep>
          <dep type="dep">
            <governor idx="5">involve</governor>
            <dependent idx="16">derive</dependent>
          </dep>
          <dep type="xcomp">
            <governor idx="16">derive</governor>
            <dependent idx="17">meaning</dependent>
          </dep>
          <dep type="case">
            <governor idx="23">input</governor>
            <dependent idx="18">from</dependent>
          </dep>
          <dep type="amod">
            <governor idx="22">language</governor>
            <dependent idx="19">human</dependent>
          </dep>
          <dep type="cc">
            <governor idx="21">natural</governor>
            <dependent idx="20">or</dependent>
          </dep>
          <dep type="conj">
            <governor idx="19">human</governor>
            <dependent idx="21">natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="23">input</governor>
            <dependent idx="22">language</dependent>
          </dep>
          <dep type="obl">
            <governor idx="17">meaning</governor>
            <dependent idx="23">input</dependent>
          </dep>
          <dep type="punct">
            <governor idx="23">input</governor>
            <dependent idx="24">,</dependent>
          </dep>
          <dep type="cc">
            <governor idx="26">others</governor>
            <dependent idx="25">and</dependent>
          </dep>
          <dep type="conj">
            <governor idx="23">input</governor>
            <dependent idx="26">others</dependent>
          </dep>
          <dep type="dep">
            <governor idx="23">input</governor>
            <dependent idx="27">involve</dependent>
          </dep>
          <dep type="amod">
            <governor idx="29">language</governor>
            <dependent idx="28">natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="30">generation</governor>
            <dependent idx="29">language</dependent>
          </dep>
          <dep type="obj">
            <governor idx="27">involve</governor>
            <dependent idx="30">generation</dependent>
          </dep>
          <dep type="punct">
            <governor idx="5">involve</governor>
            <dependent idx="31">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="5">involve</dependent>
          </dep>
          <dep type="amod">
            <governor idx="2">challenges</governor>
            <dependent idx="1">Many</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="5">involve</governor>
            <dependent idx="2">challenges</dependent>
          </dep>
          <dep type="case">
            <governor idx="4">NLP</governor>
            <dependent idx="3">in</dependent>
          </dep>
          <dep type="nmod:in">
            <governor idx="2">challenges</governor>
            <dependent idx="4">NLP</dependent>
          </dep>
          <dep type="amod">
            <governor idx="7">language</governor>
            <dependent idx="6">natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="8">understanding</governor>
            <dependent idx="7">language</dependent>
          </dep>
          <dep type="obj">
            <governor idx="5">involve</governor>
            <dependent idx="8">understanding</dependent>
          </dep>
          <dep type="punct">
            <governor idx="5">involve</governor>
            <dependent idx="9">,</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="16">derive</governor>
            <dependent idx="10">that</dependent>
          </dep>
          <dep type="fixed">
            <governor idx="10">that</governor>
            <dependent idx="11">is</dependent>
          </dep>
          <dep type="punct">
            <governor idx="16">derive</governor>
            <dependent idx="12">,</dependent>
          </dep>
          <dep type="amod">
            <governor idx="14">computers</governor>
            <dependent idx="13">enabling</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="16">derive</governor>
            <dependent idx="14">computers</dependent>
          </dep>
          <dep type="mark">
            <governor idx="16">derive</governor>
            <dependent idx="15">to</dependent>
          </dep>
          <dep type="dep">
            <governor idx="5">involve</governor>
            <dependent idx="16">derive</dependent>
          </dep>
          <dep type="xcomp">
            <governor idx="16">derive</governor>
            <dependent idx="17">meaning</dependent>
          </dep>
          <dep type="case">
            <governor idx="23">input</governor>
            <dependent idx="18">from</dependent>
          </dep>
          <dep type="amod">
            <governor idx="22">language</governor>
            <dependent idx="19">human</dependent>
          </dep>
          <dep type="cc">
            <governor idx="21">natural</governor>
            <dependent idx="20">or</dependent>
          </dep>
          <dep type="conj:or">
            <governor idx="19">human</governor>
            <dependent idx="21">natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="23">input</governor>
            <dependent idx="22">language</dependent>
          </dep>
          <dep type="obl:from">
            <governor idx="17">meaning</governor>
            <dependent idx="23">input</dependent>
          </dep>
          <dep type="punct">
            <governor idx="23">input</governor>
            <dependent idx="24">,</dependent>
          </dep>
          <dep type="cc">
            <governor idx="26">others</governor>
            <dependent idx="25">and</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="23">input</governor>
            <dependent idx="26">others</dependent>
          </dep>
          <dep type="dep">
            <governor idx="23">input</governor>
            <dependent idx="27">involve</dependent>
          </dep>
          <dep type="amod">
            <governor idx="29">language</governor>
            <dependent idx="28">natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="30">generation</governor>
            <dependent idx="29">language</dependent>
          </dep>
          <dep type="obj">
            <governor idx="27">involve</governor>
            <dependent idx="30">generation</dependent>
          </dep>
          <dep type="punct">
            <governor idx="5">involve</governor>
            <dependent idx="31">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-ccprocessed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="5">involve</dependent>
          </dep>
          <dep type="amod">
            <governor idx="2">challenges</governor>
            <dependent idx="1">Many</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="5">involve</governor>
            <dependent idx="2">challenges</dependent>
          </dep>
          <dep type="case">
            <governor idx="4">NLP</governor>
            <dependent idx="3">in</dependent>
          </dep>
          <dep type="nmod:in">
            <governor idx="2">challenges</governor>
            <dependent idx="4">NLP</dependent>
          </dep>
          <dep type="amod">
            <governor idx="7">language</governor>
            <dependent idx="6">natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="8">understanding</governor>
            <dependent idx="7">language</dependent>
          </dep>
          <dep type="obj">
            <governor idx="5">involve</governor>
            <dependent idx="8">understanding</dependent>
          </dep>
          <dep type="punct">
            <governor idx="5">involve</governor>
            <dependent idx="9">,</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="16">derive</governor>
            <dependent idx="10">that</dependent>
          </dep>
          <dep type="fixed">
            <governor idx="10">that</governor>
            <dependent idx="11">is</dependent>
          </dep>
          <dep type="punct">
            <governor idx="16">derive</governor>
            <dependent idx="12">,</dependent>
          </dep>
          <dep type="amod">
            <governor idx="14">computers</governor>
            <dependent idx="13">enabling</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="16">derive</governor>
            <dependent idx="14">computers</dependent>
          </dep>
          <dep type="mark">
            <governor idx="16">derive</governor>
            <dependent idx="15">to</dependent>
          </dep>
          <dep type="dep">
            <governor idx="5">involve</governor>
            <dependent idx="16">derive</dependent>
          </dep>
          <dep type="xcomp">
            <governor idx="16">derive</governor>
            <dependent idx="17">meaning</dependent>
          </dep>
          <dep type="case">
            <governor idx="23">input</governor>
            <dependent idx="18">from</dependent>
          </dep>
          <dep type="amod">
            <governor idx="22">language</governor>
            <dependent idx="19">human</dependent>
          </dep>
          <dep type="cc">
            <governor idx="21">natural</governor>
            <dependent idx="20">or</dependent>
          </dep>
          <dep type="conj:or">
            <governor idx="19">human</governor>
            <dependent idx="21">natural</dependent>
          </dep>
          <dep type="amod" extra="true">
            <governor idx="22">language</governor>
            <dependent idx="21">natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="23">input</governor>
            <dependent idx="22">language</dependent>
          </dep>
          <dep type="obl:from">
            <governor idx="17">meaning</governor>
            <dependent idx="23">input</dependent>
          </dep>
          <dep type="punct">
            <governor idx="23">input</governor>
            <dependent idx="24">,</dependent>
          </dep>
          <dep type="cc">
            <governor idx="26">others</governor>
            <dependent idx="25">and</dependent>
          </dep>
          <dep type="obl:from" extra="true">
            <governor idx="17">meaning</governor>
            <dependent idx="26">others</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="23">input</governor>
            <dependent idx="26">others</dependent>
          </dep>
          <dep type="dep">
            <governor idx="23">input</governor>
            <dependent idx="27">involve</dependent>
          </dep>
          <dep type="amod">
            <governor idx="29">language</governor>
            <dependent idx="28">natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="30">generation</governor>
            <dependent idx="29">language</dependent>
          </dep>
          <dep type="obj">
            <governor idx="27">involve</governor>
            <dependent idx="30">generation</dependent>
          </dep>
          <dep type="punct">
            <governor idx="5">involve</governor>
            <dependent idx="31">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="5">involve</dependent>
          </dep>
          <dep type="amod">
            <governor idx="2">challenges</governor>
            <dependent idx="1">Many</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="5">involve</governor>
            <dependent idx="2">challenges</dependent>
          </dep>
          <dep type="case">
            <governor idx="4">NLP</governor>
            <dependent idx="3">in</dependent>
          </dep>
          <dep type="nmod:in">
            <governor idx="2">challenges</governor>
            <dependent idx="4">NLP</dependent>
          </dep>
          <dep type="amod">
            <governor idx="7">language</governor>
            <dependent idx="6">natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="8">understanding</governor>
            <dependent idx="7">language</dependent>
          </dep>
          <dep type="obj">
            <governor idx="5">involve</governor>
            <dependent idx="8">understanding</dependent>
          </dep>
          <dep type="punct">
            <governor idx="5">involve</governor>
            <dependent idx="9">,</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="16">derive</governor>
            <dependent idx="10">that</dependent>
          </dep>
          <dep type="fixed">
            <governor idx="10">that</governor>
            <dependent idx="11">is</dependent>
          </dep>
          <dep type="punct">
            <governor idx="16">derive</governor>
            <dependent idx="12">,</dependent>
          </dep>
          <dep type="amod">
            <governor idx="14">computers</governor>
            <dependent idx="13">enabling</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="16">derive</governor>
            <dependent idx="14">computers</dependent>
          </dep>
          <dep type="mark">
            <governor idx="16">derive</governor>
            <dependent idx="15">to</dependent>
          </dep>
          <dep type="dep">
            <governor idx="5">involve</governor>
            <dependent idx="16">derive</dependent>
          </dep>
          <dep type="xcomp">
            <governor idx="16">derive</governor>
            <dependent idx="17">meaning</dependent>
          </dep>
          <dep type="case">
            <governor idx="23">input</governor>
            <dependent idx="18">from</dependent>
          </dep>
          <dep type="amod">
            <governor idx="22">language</governor>
            <dependent idx="19">human</dependent>
          </dep>
          <dep type="cc">
            <governor idx="21">natural</governor>
            <dependent idx="20">or</dependent>
          </dep>
          <dep type="conj:or">
            <governor idx="19">human</governor>
            <dependent idx="21">natural</dependent>
          </dep>
          <dep type="amod" extra="true">
            <governor idx="22">language</governor>
            <dependent idx="21">natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="23">input</governor>
            <dependent idx="22">language</dependent>
          </dep>
          <dep type="obl:from">
            <governor idx="17">meaning</governor>
            <dependent idx="23">input</dependent>
          </dep>
          <dep type="punct">
            <governor idx="23">input</governor>
            <dependent idx="24">,</dependent>
          </dep>
          <dep type="cc">
            <governor idx="26">others</governor>
            <dependent idx="25">and</dependent>
          </dep>
          <dep type="obl:from" extra="true">
            <governor idx="17">meaning</governor>
            <dependent idx="26">others</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="23">input</governor>
            <dependent idx="26">others</dependent>
          </dep>
          <dep type="dep">
            <governor idx="23">input</governor>
            <dependent idx="27">involve</dependent>
          </dep>
          <dep type="amod">
            <governor idx="29">language</governor>
            <dependent idx="28">natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="30">generation</governor>
            <dependent idx="29">language</dependent>
          </dep>
          <dep type="obj">
            <governor idx="27">involve</governor>
            <dependent idx="30">generation</dependent>
          </dep>
          <dep type="punct">
            <governor idx="5">involve</governor>
            <dependent idx="31">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-plus-plus-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="5">involve</dependent>
          </dep>
          <dep type="amod">
            <governor idx="2">challenges</governor>
            <dependent idx="1">Many</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="5">involve</governor>
            <dependent idx="2">challenges</dependent>
          </dep>
          <dep type="case">
            <governor idx="4">NLP</governor>
            <dependent idx="3">in</dependent>
          </dep>
          <dep type="nmod:in">
            <governor idx="2">challenges</governor>
            <dependent idx="4">NLP</dependent>
          </dep>
          <dep type="amod">
            <governor idx="7">language</governor>
            <dependent idx="6">natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="8">understanding</governor>
            <dependent idx="7">language</dependent>
          </dep>
          <dep type="obj">
            <governor idx="5">involve</governor>
            <dependent idx="8">understanding</dependent>
          </dep>
          <dep type="punct">
            <governor idx="5">involve</governor>
            <dependent idx="9">,</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="16">derive</governor>
            <dependent idx="10">that</dependent>
          </dep>
          <dep type="fixed">
            <governor idx="10">that</governor>
            <dependent idx="11">is</dependent>
          </dep>
          <dep type="punct">
            <governor idx="16">derive</governor>
            <dependent idx="12">,</dependent>
          </dep>
          <dep type="amod">
            <governor idx="14">computers</governor>
            <dependent idx="13">enabling</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="16">derive</governor>
            <dependent idx="14">computers</dependent>
          </dep>
          <dep type="mark">
            <governor idx="16">derive</governor>
            <dependent idx="15">to</dependent>
          </dep>
          <dep type="dep">
            <governor idx="5">involve</governor>
            <dependent idx="16">derive</dependent>
          </dep>
          <dep type="xcomp">
            <governor idx="16">derive</governor>
            <dependent idx="17">meaning</dependent>
          </dep>
          <dep type="case">
            <governor idx="23">input</governor>
            <dependent idx="18">from</dependent>
          </dep>
          <dep type="amod">
            <governor idx="22">language</governor>
            <dependent idx="19">human</dependent>
          </dep>
          <dep type="cc">
            <governor idx="21">natural</governor>
            <dependent idx="20">or</dependent>
          </dep>
          <dep type="conj:or">
            <governor idx="19">human</governor>
            <dependent idx="21">natural</dependent>
          </dep>
          <dep type="amod" extra="true">
            <governor idx="22">language</governor>
            <dependent idx="21">natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="23">input</governor>
            <dependent idx="22">language</dependent>
          </dep>
          <dep type="obl:from">
            <governor idx="17">meaning</governor>
            <dependent idx="23">input</dependent>
          </dep>
          <dep type="punct">
            <governor idx="23">input</governor>
            <dependent idx="24">,</dependent>
          </dep>
          <dep type="cc">
            <governor idx="26">others</governor>
            <dependent idx="25">and</dependent>
          </dep>
          <dep type="obl:from" extra="true">
            <governor idx="17">meaning</governor>
            <dependent idx="26">others</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="23">input</governor>
            <dependent idx="26">others</dependent>
          </dep>
          <dep type="dep">
            <governor idx="23">input</governor>
            <dependent idx="27">involve</dependent>
          </dep>
          <dep type="amod">
            <governor idx="29">language</governor>
            <dependent idx="28">natural</dependent>
          </dep>
          <dep type="compound">
            <governor idx="30">generation</governor>
            <dependent idx="29">language</dependent>
          </dep>
          <dep type="obj">
            <governor idx="27">involve</governor>
            <dependent idx="30">generation</dependent>
          </dep>
          <dep type="punct">
            <governor idx="5">involve</governor>
            <dependent idx="31">.</dependent>
          </dep>
        </dependencies>
      </sentence>
      <sentence id="4">
        <tokens>
          <token id="1">
            <word>History</word>
            <lemma>history</lemma>
            <CharacterOffsetBegin>519</CharacterOffsetBegin>
            <CharacterOffsetEnd>526</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="2">
            <word>The</word>
            <lemma>the</lemma>
            <CharacterOffsetBegin>528</CharacterOffsetBegin>
            <CharacterOffsetEnd>531</CharacterOffsetEnd>
            <POS>DT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="3">
            <word>history</word>
            <lemma>history</lemma>
            <CharacterOffsetBegin>532</CharacterOffsetBegin>
            <CharacterOffsetEnd>539</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="4">
            <word>of</word>
            <lemma>of</lemma>
            <CharacterOffsetBegin>540</CharacterOffsetBegin>
            <CharacterOffsetEnd>542</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="5">
            <word>NLP</word>
            <lemma>NLP</lemma>
            <CharacterOffsetBegin>543</CharacterOffsetBegin>
            <CharacterOffsetEnd>546</CharacterOffsetEnd>
            <POS>NNP</POS>
            <NER>ORGANIZATION</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="6">
            <word>generally</word>
            <lemma>generally</lemma>
            <CharacterOffsetBegin>547</CharacterOffsetBegin>
            <CharacterOffsetEnd>556</CharacterOffsetEnd>
            <POS>RB</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="7">
            <word>starts</word>
            <lemma>start</lemma>
            <CharacterOffsetBegin>557</CharacterOffsetBegin>
            <CharacterOffsetEnd>563</CharacterOffsetEnd>
            <POS>VBZ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="8">
            <word>in</word>
            <lemma>in</lemma>
            <CharacterOffsetBegin>564</CharacterOffsetBegin>
            <CharacterOffsetEnd>566</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="9">
            <word>the</word>
            <lemma>the</lemma>
            <CharacterOffsetBegin>567</CharacterOffsetBegin>
            <CharacterOffsetEnd>570</CharacterOffsetEnd>
            <POS>DT</POS>
            <NER>DATE</NER>
            <NormalizedNER>195X</NormalizedNER>
            <Speaker>PER0</Speaker>
            <Timex tid="t1" type="DATE">195X</Timex>
          </token>
          <token id="10">
            <word>1950s</word>
            <lemma>1950</lemma>
            <CharacterOffsetBegin>571</CharacterOffsetBegin>
            <CharacterOffsetEnd>576</CharacterOffsetEnd>
            <POS>NNS</POS>
            <NER>DATE</NER>
            <NormalizedNER>195X</NormalizedNER>
            <Speaker>PER0</Speaker>
            <Timex tid="t1" type="DATE">195X</Timex>
          </token>
          <token id="11">
            <word>,</word>
            <lemma>,</lemma>
            <CharacterOffsetBegin>576</CharacterOffsetBegin>
            <CharacterOffsetEnd>577</CharacterOffsetEnd>
            <POS>,</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="12">
            <word>although</word>
            <lemma>although</lemma>
            <CharacterOffsetBegin>578</CharacterOffsetBegin>
            <CharacterOffsetEnd>586</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="13">
            <word>work</word>
            <lemma>work</lemma>
            <CharacterOffsetBegin>587</CharacterOffsetBegin>
            <CharacterOffsetEnd>591</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="14">
            <word>can</word>
            <lemma>can</lemma>
            <CharacterOffsetBegin>592</CharacterOffsetBegin>
            <CharacterOffsetEnd>595</CharacterOffsetEnd>
            <POS>MD</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="15">
            <word>be</word>
            <lemma>be</lemma>
            <CharacterOffsetBegin>596</CharacterOffsetBegin>
            <CharacterOffsetEnd>598</CharacterOffsetEnd>
            <POS>VB</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="16">
            <word>found</word>
            <lemma>find</lemma>
            <CharacterOffsetBegin>599</CharacterOffsetBegin>
            <CharacterOffsetEnd>604</CharacterOffsetEnd>
            <POS>VBN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="17">
            <word>from</word>
            <lemma>from</lemma>
            <CharacterOffsetBegin>605</CharacterOffsetBegin>
            <CharacterOffsetEnd>609</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="18">
            <word>earlier</word>
            <lemma>early</lemma>
            <CharacterOffsetBegin>610</CharacterOffsetBegin>
            <CharacterOffsetEnd>617</CharacterOffsetEnd>
            <POS>JJR</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="19">
            <word>periods</word>
            <lemma>period</lemma>
            <CharacterOffsetBegin>618</CharacterOffsetBegin>
            <CharacterOffsetEnd>625</CharacterOffsetEnd>
            <POS>NNS</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="20">
            <word>.</word>
            <lemma>.</lemma>
            <CharacterOffsetBegin>625</CharacterOffsetBegin>
            <CharacterOffsetEnd>626</CharacterOffsetEnd>
            <POS>.</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
        </tokens>
        <parse>(ROOT (S (NP (NP (NN History)) (NP (NP (DT The) (NN history)) (PP (IN of) (NP (NNP NLP))))) (ADVP (RB generally)) (VP (VBZ starts) (PP (IN in) (NP (DT the) (NNS 1950s))) (, ,) (SBAR (IN although) (S (NP (NN work)) (VP (MD can) (VP (VB be) (VP (VBN found) (PP (IN from) (NP (JJR earlier) (NNS periods))))))))) (. .))) </parse>
        <dependencies type="basic-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="1">History</dependent>
          </dep>
          <dep type="det">
            <governor idx="3">history</governor>
            <dependent idx="2">The</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="7">starts</governor>
            <dependent idx="3">history</dependent>
          </dep>
          <dep type="case">
            <governor idx="5">NLP</governor>
            <dependent idx="4">of</dependent>
          </dep>
          <dep type="nmod">
            <governor idx="3">history</governor>
            <dependent idx="5">NLP</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="7">starts</governor>
            <dependent idx="6">generally</dependent>
          </dep>
          <dep type="dep">
            <governor idx="1">History</governor>
            <dependent idx="7">starts</dependent>
          </dep>
          <dep type="case">
            <governor idx="10">1950s</governor>
            <dependent idx="8">in</dependent>
          </dep>
          <dep type="det">
            <governor idx="10">1950s</governor>
            <dependent idx="9">the</dependent>
          </dep>
          <dep type="obl">
            <governor idx="7">starts</governor>
            <dependent idx="10">1950s</dependent>
          </dep>
          <dep type="punct">
            <governor idx="7">starts</governor>
            <dependent idx="11">,</dependent>
          </dep>
          <dep type="mark">
            <governor idx="16">found</governor>
            <dependent idx="12">although</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="16">found</governor>
            <dependent idx="13">work</dependent>
          </dep>
          <dep type="aux">
            <governor idx="16">found</governor>
            <dependent idx="14">can</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="16">found</governor>
            <dependent idx="15">be</dependent>
          </dep>
          <dep type="advcl">
            <governor idx="7">starts</governor>
            <dependent idx="16">found</dependent>
          </dep>
          <dep type="case">
            <governor idx="19">periods</governor>
            <dependent idx="17">from</dependent>
          </dep>
          <dep type="amod">
            <governor idx="19">periods</governor>
            <dependent idx="18">earlier</dependent>
          </dep>
          <dep type="obl">
            <governor idx="16">found</governor>
            <dependent idx="19">periods</dependent>
          </dep>
          <dep type="punct">
            <governor idx="1">History</governor>
            <dependent idx="20">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="1">History</dependent>
          </dep>
          <dep type="det">
            <governor idx="3">history</governor>
            <dependent idx="2">The</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="7">starts</governor>
            <dependent idx="3">history</dependent>
          </dep>
          <dep type="case">
            <governor idx="5">NLP</governor>
            <dependent idx="4">of</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="3">history</governor>
            <dependent idx="5">NLP</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="7">starts</governor>
            <dependent idx="6">generally</dependent>
          </dep>
          <dep type="dep">
            <governor idx="1">History</governor>
            <dependent idx="7">starts</dependent>
          </dep>
          <dep type="case">
            <governor idx="10">1950s</governor>
            <dependent idx="8">in</dependent>
          </dep>
          <dep type="det">
            <governor idx="10">1950s</governor>
            <dependent idx="9">the</dependent>
          </dep>
          <dep type="obl:in">
            <governor idx="7">starts</governor>
            <dependent idx="10">1950s</dependent>
          </dep>
          <dep type="punct">
            <governor idx="7">starts</governor>
            <dependent idx="11">,</dependent>
          </dep>
          <dep type="mark">
            <governor idx="16">found</governor>
            <dependent idx="12">although</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="16">found</governor>
            <dependent idx="13">work</dependent>
          </dep>
          <dep type="aux">
            <governor idx="16">found</governor>
            <dependent idx="14">can</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="16">found</governor>
            <dependent idx="15">be</dependent>
          </dep>
          <dep type="advcl">
            <governor idx="7">starts</governor>
            <dependent idx="16">found</dependent>
          </dep>
          <dep type="case">
            <governor idx="19">periods</governor>
            <dependent idx="17">from</dependent>
          </dep>
          <dep type="amod">
            <governor idx="19">periods</governor>
            <dependent idx="18">earlier</dependent>
          </dep>
          <dep type="obl:from">
            <governor idx="16">found</governor>
            <dependent idx="19">periods</dependent>
          </dep>
          <dep type="punct">
            <governor idx="1">History</governor>
            <dependent idx="20">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-ccprocessed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="1">History</dependent>
          </dep>
          <dep type="det">
            <governor idx="3">history</governor>
            <dependent idx="2">The</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="7">starts</governor>
            <dependent idx="3">history</dependent>
          </dep>
          <dep type="case">
            <governor idx="5">NLP</governor>
            <dependent idx="4">of</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="3">history</governor>
            <dependent idx="5">NLP</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="7">starts</governor>
            <dependent idx="6">generally</dependent>
          </dep>
          <dep type="dep">
            <governor idx="1">History</governor>
            <dependent idx="7">starts</dependent>
          </dep>
          <dep type="case">
            <governor idx="10">1950s</governor>
            <dependent idx="8">in</dependent>
          </dep>
          <dep type="det">
            <governor idx="10">1950s</governor>
            <dependent idx="9">the</dependent>
          </dep>
          <dep type="obl:in">
            <governor idx="7">starts</governor>
            <dependent idx="10">1950s</dependent>
          </dep>
          <dep type="punct">
            <governor idx="7">starts</governor>
            <dependent idx="11">,</dependent>
          </dep>
          <dep type="mark">
            <governor idx="16">found</governor>
            <dependent idx="12">although</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="16">found</governor>
            <dependent idx="13">work</dependent>
          </dep>
          <dep type="aux">
            <governor idx="16">found</governor>
            <dependent idx="14">can</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="16">found</governor>
            <dependent idx="15">be</dependent>
          </dep>
          <dep type="advcl">
            <governor idx="7">starts</governor>
            <dependent idx="16">found</dependent>
          </dep>
          <dep type="case">
            <governor idx="19">periods</governor>
            <dependent idx="17">from</dependent>
          </dep>
          <dep type="amod">
            <governor idx="19">periods</governor>
            <dependent idx="18">earlier</dependent>
          </dep>
          <dep type="obl:from">
            <governor idx="16">found</governor>
            <dependent idx="19">periods</dependent>
          </dep>
          <dep type="punct">
            <governor idx="1">History</governor>
            <dependent idx="20">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="1">History</dependent>
          </dep>
          <dep type="det">
            <governor idx="3">history</governor>
            <dependent idx="2">The</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="7">starts</governor>
            <dependent idx="3">history</dependent>
          </dep>
          <dep type="case">
            <governor idx="5">NLP</governor>
            <dependent idx="4">of</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="3">history</governor>
            <dependent idx="5">NLP</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="7">starts</governor>
            <dependent idx="6">generally</dependent>
          </dep>
          <dep type="dep">
            <governor idx="1">History</governor>
            <dependent idx="7">starts</dependent>
          </dep>
          <dep type="case">
            <governor idx="10">1950s</governor>
            <dependent idx="8">in</dependent>
          </dep>
          <dep type="det">
            <governor idx="10">1950s</governor>
            <dependent idx="9">the</dependent>
          </dep>
          <dep type="obl:in">
            <governor idx="7">starts</governor>
            <dependent idx="10">1950s</dependent>
          </dep>
          <dep type="punct">
            <governor idx="7">starts</governor>
            <dependent idx="11">,</dependent>
          </dep>
          <dep type="mark">
            <governor idx="16">found</governor>
            <dependent idx="12">although</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="16">found</governor>
            <dependent idx="13">work</dependent>
          </dep>
          <dep type="aux">
            <governor idx="16">found</governor>
            <dependent idx="14">can</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="16">found</governor>
            <dependent idx="15">be</dependent>
          </dep>
          <dep type="advcl:although">
            <governor idx="7">starts</governor>
            <dependent idx="16">found</dependent>
          </dep>
          <dep type="case">
            <governor idx="19">periods</governor>
            <dependent idx="17">from</dependent>
          </dep>
          <dep type="amod">
            <governor idx="19">periods</governor>
            <dependent idx="18">earlier</dependent>
          </dep>
          <dep type="obl:from">
            <governor idx="16">found</governor>
            <dependent idx="19">periods</dependent>
          </dep>
          <dep type="punct">
            <governor idx="1">History</governor>
            <dependent idx="20">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-plus-plus-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="1">History</dependent>
          </dep>
          <dep type="det">
            <governor idx="3">history</governor>
            <dependent idx="2">The</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="7">starts</governor>
            <dependent idx="3">history</dependent>
          </dep>
          <dep type="case">
            <governor idx="5">NLP</governor>
            <dependent idx="4">of</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="3">history</governor>
            <dependent idx="5">NLP</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="7">starts</governor>
            <dependent idx="6">generally</dependent>
          </dep>
          <dep type="dep">
            <governor idx="1">History</governor>
            <dependent idx="7">starts</dependent>
          </dep>
          <dep type="case">
            <governor idx="10">1950s</governor>
            <dependent idx="8">in</dependent>
          </dep>
          <dep type="det">
            <governor idx="10">1950s</governor>
            <dependent idx="9">the</dependent>
          </dep>
          <dep type="obl:in">
            <governor idx="7">starts</governor>
            <dependent idx="10">1950s</dependent>
          </dep>
          <dep type="punct">
            <governor idx="7">starts</governor>
            <dependent idx="11">,</dependent>
          </dep>
          <dep type="mark">
            <governor idx="16">found</governor>
            <dependent idx="12">although</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="16">found</governor>
            <dependent idx="13">work</dependent>
          </dep>
          <dep type="aux">
            <governor idx="16">found</governor>
            <dependent idx="14">can</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="16">found</governor>
            <dependent idx="15">be</dependent>
          </dep>
          <dep type="advcl:although">
            <governor idx="7">starts</governor>
            <dependent idx="16">found</dependent>
          </dep>
          <dep type="case">
            <governor idx="19">periods</governor>
            <dependent idx="17">from</dependent>
          </dep>
          <dep type="amod">
            <governor idx="19">periods</governor>
            <dependent idx="18">earlier</dependent>
          </dep>
          <dep type="obl:from">
            <governor idx="16">found</governor>
            <dependent idx="19">periods</dependent>
          </dep>
          <dep type="punct">
            <governor idx="1">History</governor>
            <dependent idx="20">.</dependent>
          </dep>
        </dependencies>
      </sentence>
      <sentence id="5">
        <tokens>
          <token id="1">
            <word>In</word>
            <lemma>in</lemma>
            <CharacterOffsetBegin>627</CharacterOffsetBegin>
            <CharacterOffsetEnd>629</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="2">
            <word>1950</word>
            <lemma>1950</lemma>
            <CharacterOffsetBegin>630</CharacterOffsetBegin>
            <CharacterOffsetEnd>634</CharacterOffsetEnd>
            <POS>CD</POS>
            <NER>DATE</NER>
            <NormalizedNER>1950</NormalizedNER>
            <Speaker>PER0</Speaker>
            <Timex tid="t2" type="DATE">1950</Timex>
          </token>
          <token id="3">
            <word>,</word>
            <lemma>,</lemma>
            <CharacterOffsetBegin>634</CharacterOffsetBegin>
            <CharacterOffsetEnd>635</CharacterOffsetEnd>
            <POS>,</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="4">
            <word>Alan</word>
            <lemma>Alan</lemma>
            <CharacterOffsetBegin>636</CharacterOffsetBegin>
            <CharacterOffsetEnd>640</CharacterOffsetEnd>
            <POS>NNP</POS>
            <NER>PERSON</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="5">
            <word>Turing</word>
            <lemma>Turing</lemma>
            <CharacterOffsetBegin>641</CharacterOffsetBegin>
            <CharacterOffsetEnd>647</CharacterOffsetEnd>
            <POS>NNP</POS>
            <NER>PERSON</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="6">
            <word>published</word>
            <lemma>publish</lemma>
            <CharacterOffsetBegin>648</CharacterOffsetBegin>
            <CharacterOffsetEnd>657</CharacterOffsetEnd>
            <POS>VBD</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="7">
            <word>an</word>
            <lemma>a</lemma>
            <CharacterOffsetBegin>658</CharacterOffsetBegin>
            <CharacterOffsetEnd>660</CharacterOffsetEnd>
            <POS>DT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="8">
            <word>article</word>
            <lemma>article</lemma>
            <CharacterOffsetBegin>661</CharacterOffsetBegin>
            <CharacterOffsetEnd>668</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="9">
            <word>titled</word>
            <lemma>title</lemma>
            <CharacterOffsetBegin>669</CharacterOffsetBegin>
            <CharacterOffsetEnd>675</CharacterOffsetEnd>
            <POS>VBN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="10">
            <word>"</word>
            <lemma>"</lemma>
            <CharacterOffsetBegin>676</CharacterOffsetBegin>
            <CharacterOffsetEnd>677</CharacterOffsetEnd>
            <POS>``</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="11">
            <word>Computing</word>
            <lemma>Computing</lemma>
            <CharacterOffsetBegin>677</CharacterOffsetBegin>
            <CharacterOffsetEnd>686</CharacterOffsetEnd>
            <POS>NNP</POS>
            <NER>O</NER>
            <Speaker>34</Speaker>
          </token>
          <token id="12">
            <word>Machinery</word>
            <lemma>Machinery</lemma>
            <CharacterOffsetBegin>687</CharacterOffsetBegin>
            <CharacterOffsetEnd>696</CharacterOffsetEnd>
            <POS>NNP</POS>
            <NER>O</NER>
            <Speaker>34</Speaker>
          </token>
          <token id="13">
            <word>and</word>
            <lemma>and</lemma>
            <CharacterOffsetBegin>697</CharacterOffsetBegin>
            <CharacterOffsetEnd>700</CharacterOffsetEnd>
            <POS>CC</POS>
            <NER>O</NER>
            <Speaker>34</Speaker>
          </token>
          <token id="14">
            <word>Intelligence</word>
            <lemma>Intelligence</lemma>
            <CharacterOffsetBegin>701</CharacterOffsetBegin>
            <CharacterOffsetEnd>713</CharacterOffsetEnd>
            <POS>NNP</POS>
            <NER>O</NER>
            <Speaker>34</Speaker>
          </token>
          <token id="15">
            <word>"</word>
            <lemma>"</lemma>
            <CharacterOffsetBegin>713</CharacterOffsetBegin>
            <CharacterOffsetEnd>714</CharacterOffsetEnd>
            <POS>''</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="16">
            <word>which</word>
            <lemma>which</lemma>
            <CharacterOffsetBegin>715</CharacterOffsetBegin>
            <CharacterOffsetEnd>720</CharacterOffsetEnd>
            <POS>WDT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="17">
            <word>proposed</word>
            <lemma>propose</lemma>
            <CharacterOffsetBegin>721</CharacterOffsetBegin>
            <CharacterOffsetEnd>729</CharacterOffsetEnd>
            <POS>VBD</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="18">
            <word>what</word>
            <lemma>what</lemma>
            <CharacterOffsetBegin>730</CharacterOffsetBegin>
            <CharacterOffsetEnd>734</CharacterOffsetEnd>
            <POS>WP</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="19">
            <word>is</word>
            <lemma>be</lemma>
            <CharacterOffsetBegin>735</CharacterOffsetBegin>
            <CharacterOffsetEnd>737</CharacterOffsetEnd>
            <POS>VBZ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="20">
            <word>now</word>
            <lemma>now</lemma>
            <CharacterOffsetBegin>738</CharacterOffsetBegin>
            <CharacterOffsetEnd>741</CharacterOffsetEnd>
            <POS>RB</POS>
            <NER>DATE</NER>
            <NormalizedNER>PRESENT_REF</NormalizedNER>
            <Speaker>PER0</Speaker>
            <Timex tid="t3" type="DATE">PRESENT_REF</Timex>
          </token>
          <token id="21">
            <word>called</word>
            <lemma>call</lemma>
            <CharacterOffsetBegin>742</CharacterOffsetBegin>
            <CharacterOffsetEnd>748</CharacterOffsetEnd>
            <POS>VBN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="22">
            <word>the</word>
            <lemma>the</lemma>
            <CharacterOffsetBegin>749</CharacterOffsetBegin>
            <CharacterOffsetEnd>752</CharacterOffsetEnd>
            <POS>DT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="23">
            <word>Turing</word>
            <lemma>Turing</lemma>
            <CharacterOffsetBegin>753</CharacterOffsetBegin>
            <CharacterOffsetEnd>759</CharacterOffsetEnd>
            <POS>NNP</POS>
            <NER>MISC</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="24">
            <word>test</word>
            <lemma>test</lemma>
            <CharacterOffsetBegin>760</CharacterOffsetBegin>
            <CharacterOffsetEnd>764</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="25">
            <word>as</word>
            <lemma>as</lemma>
            <CharacterOffsetBegin>765</CharacterOffsetBegin>
            <CharacterOffsetEnd>767</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="26">
            <word>a</word>
            <lemma>a</lemma>
            <CharacterOffsetBegin>768</CharacterOffsetBegin>
            <CharacterOffsetEnd>769</CharacterOffsetEnd>
            <POS>DT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="27">
            <word>criterion</word>
            <lemma>criterion</lemma>
            <CharacterOffsetBegin>770</CharacterOffsetBegin>
            <CharacterOffsetEnd>779</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="28">
            <word>of</word>
            <lemma>of</lemma>
            <CharacterOffsetBegin>780</CharacterOffsetBegin>
            <CharacterOffsetEnd>782</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="29">
            <word>intelligence</word>
            <lemma>intelligence</lemma>
            <CharacterOffsetBegin>783</CharacterOffsetBegin>
            <CharacterOffsetEnd>795</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="30">
            <word>.</word>
            <lemma>.</lemma>
            <CharacterOffsetBegin>795</CharacterOffsetBegin>
            <CharacterOffsetEnd>796</CharacterOffsetEnd>
            <POS>.</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
        </tokens>
        <parse>(ROOT (S (PP (IN In) (NP (CD 1950))) (, ,) (NP (NNP Alan) (NNP Turing)) (VP (VBD published) (NP (NP (DT an) (NN article)) (VP (VBN titled) (NP (`` ") (NP (NP (NNP Computing) (NNP Machinery)) (CC and) (NP (NNP Intelligence))) ('' ") (SBAR (WHNP (WDT which)) (S (VP (VBD proposed) (SBAR (WHNP (WP what)) (S (VP (VBZ is) (ADVP (RB now)) (VP (VBN called) (NP (DT the) (NNP Turing) (NN test)) (PP (IN as) (NP (NP (DT a) (NN criterion)) (PP (IN of) (NP (NN intelligence)))))))))))))))) (. .))) </parse>
        <dependencies type="basic-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="6">published</dependent>
          </dep>
          <dep type="case">
            <governor idx="2">1950</governor>
            <dependent idx="1">In</dependent>
          </dep>
          <dep type="obl">
            <governor idx="6">published</governor>
            <dependent idx="2">1950</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">published</governor>
            <dependent idx="3">,</dependent>
          </dep>
          <dep type="compound">
            <governor idx="5">Turing</governor>
            <dependent idx="4">Alan</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="6">published</governor>
            <dependent idx="5">Turing</dependent>
          </dep>
          <dep type="det">
            <governor idx="8">article</governor>
            <dependent idx="7">an</dependent>
          </dep>
          <dep type="obj">
            <governor idx="6">published</governor>
            <dependent idx="8">article</dependent>
          </dep>
          <dep type="acl">
            <governor idx="8">article</governor>
            <dependent idx="9">titled</dependent>
          </dep>
          <dep type="punct">
            <governor idx="12">Machinery</governor>
            <dependent idx="10">"</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">Machinery</governor>
            <dependent idx="11">Computing</dependent>
          </dep>
          <dep type="obj">
            <governor idx="9">titled</governor>
            <dependent idx="12">Machinery</dependent>
          </dep>
          <dep type="cc">
            <governor idx="14">Intelligence</governor>
            <dependent idx="13">and</dependent>
          </dep>
          <dep type="conj">
            <governor idx="12">Machinery</governor>
            <dependent idx="14">Intelligence</dependent>
          </dep>
          <dep type="punct">
            <governor idx="12">Machinery</governor>
            <dependent idx="15">"</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="17">proposed</governor>
            <dependent idx="16">which</dependent>
          </dep>
          <dep type="acl:relcl">
            <governor idx="12">Machinery</governor>
            <dependent idx="17">proposed</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="21">called</governor>
            <dependent idx="18">what</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="21">called</governor>
            <dependent idx="19">is</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="21">called</governor>
            <dependent idx="20">now</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="17">proposed</governor>
            <dependent idx="21">called</dependent>
          </dep>
          <dep type="det">
            <governor idx="24">test</governor>
            <dependent idx="22">the</dependent>
          </dep>
          <dep type="compound">
            <governor idx="24">test</governor>
            <dependent idx="23">Turing</dependent>
          </dep>
          <dep type="obj">
            <governor idx="21">called</governor>
            <dependent idx="24">test</dependent>
          </dep>
          <dep type="case">
            <governor idx="27">criterion</governor>
            <dependent idx="25">as</dependent>
          </dep>
          <dep type="det">
            <governor idx="27">criterion</governor>
            <dependent idx="26">a</dependent>
          </dep>
          <dep type="obl">
            <governor idx="21">called</governor>
            <dependent idx="27">criterion</dependent>
          </dep>
          <dep type="case">
            <governor idx="29">intelligence</governor>
            <dependent idx="28">of</dependent>
          </dep>
          <dep type="nmod">
            <governor idx="27">criterion</governor>
            <dependent idx="29">intelligence</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">published</governor>
            <dependent idx="30">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="6">published</dependent>
          </dep>
          <dep type="case">
            <governor idx="2">1950</governor>
            <dependent idx="1">In</dependent>
          </dep>
          <dep type="obl:in">
            <governor idx="6">published</governor>
            <dependent idx="2">1950</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">published</governor>
            <dependent idx="3">,</dependent>
          </dep>
          <dep type="compound">
            <governor idx="5">Turing</governor>
            <dependent idx="4">Alan</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="6">published</governor>
            <dependent idx="5">Turing</dependent>
          </dep>
          <dep type="det">
            <governor idx="8">article</governor>
            <dependent idx="7">an</dependent>
          </dep>
          <dep type="obj">
            <governor idx="6">published</governor>
            <dependent idx="8">article</dependent>
          </dep>
          <dep type="acl">
            <governor idx="8">article</governor>
            <dependent idx="9">titled</dependent>
          </dep>
          <dep type="punct">
            <governor idx="12">Machinery</governor>
            <dependent idx="10">"</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">Machinery</governor>
            <dependent idx="11">Computing</dependent>
          </dep>
          <dep type="obj">
            <governor idx="9">titled</governor>
            <dependent idx="12">Machinery</dependent>
          </dep>
          <dep type="cc">
            <governor idx="14">Intelligence</governor>
            <dependent idx="13">and</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="12">Machinery</governor>
            <dependent idx="14">Intelligence</dependent>
          </dep>
          <dep type="punct">
            <governor idx="12">Machinery</governor>
            <dependent idx="15">"</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="17">proposed</governor>
            <dependent idx="16">which</dependent>
          </dep>
          <dep type="acl:relcl">
            <governor idx="12">Machinery</governor>
            <dependent idx="17">proposed</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="21">called</governor>
            <dependent idx="18">what</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="21">called</governor>
            <dependent idx="19">is</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="21">called</governor>
            <dependent idx="20">now</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="17">proposed</governor>
            <dependent idx="21">called</dependent>
          </dep>
          <dep type="det">
            <governor idx="24">test</governor>
            <dependent idx="22">the</dependent>
          </dep>
          <dep type="compound">
            <governor idx="24">test</governor>
            <dependent idx="23">Turing</dependent>
          </dep>
          <dep type="obj">
            <governor idx="21">called</governor>
            <dependent idx="24">test</dependent>
          </dep>
          <dep type="case">
            <governor idx="27">criterion</governor>
            <dependent idx="25">as</dependent>
          </dep>
          <dep type="det">
            <governor idx="27">criterion</governor>
            <dependent idx="26">a</dependent>
          </dep>
          <dep type="obl:as">
            <governor idx="21">called</governor>
            <dependent idx="27">criterion</dependent>
          </dep>
          <dep type="case">
            <governor idx="29">intelligence</governor>
            <dependent idx="28">of</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="27">criterion</governor>
            <dependent idx="29">intelligence</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">published</governor>
            <dependent idx="30">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-ccprocessed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="6">published</dependent>
          </dep>
          <dep type="case">
            <governor idx="2">1950</governor>
            <dependent idx="1">In</dependent>
          </dep>
          <dep type="obl:in">
            <governor idx="6">published</governor>
            <dependent idx="2">1950</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">published</governor>
            <dependent idx="3">,</dependent>
          </dep>
          <dep type="compound">
            <governor idx="5">Turing</governor>
            <dependent idx="4">Alan</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="6">published</governor>
            <dependent idx="5">Turing</dependent>
          </dep>
          <dep type="det">
            <governor idx="8">article</governor>
            <dependent idx="7">an</dependent>
          </dep>
          <dep type="obj">
            <governor idx="6">published</governor>
            <dependent idx="8">article</dependent>
          </dep>
          <dep type="acl">
            <governor idx="8">article</governor>
            <dependent idx="9">titled</dependent>
          </dep>
          <dep type="punct">
            <governor idx="12">Machinery</governor>
            <dependent idx="10">"</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">Machinery</governor>
            <dependent idx="11">Computing</dependent>
          </dep>
          <dep type="obj">
            <governor idx="9">titled</governor>
            <dependent idx="12">Machinery</dependent>
          </dep>
          <dep type="cc">
            <governor idx="14">Intelligence</governor>
            <dependent idx="13">and</dependent>
          </dep>
          <dep type="obj" extra="true">
            <governor idx="9">titled</governor>
            <dependent idx="14">Intelligence</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="12">Machinery</governor>
            <dependent idx="14">Intelligence</dependent>
          </dep>
          <dep type="punct">
            <governor idx="12">Machinery</governor>
            <dependent idx="15">"</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="17">proposed</governor>
            <dependent idx="16">which</dependent>
          </dep>
          <dep type="acl:relcl">
            <governor idx="12">Machinery</governor>
            <dependent idx="17">proposed</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="21">called</governor>
            <dependent idx="18">what</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="21">called</governor>
            <dependent idx="19">is</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="21">called</governor>
            <dependent idx="20">now</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="17">proposed</governor>
            <dependent idx="21">called</dependent>
          </dep>
          <dep type="det">
            <governor idx="24">test</governor>
            <dependent idx="22">the</dependent>
          </dep>
          <dep type="compound">
            <governor idx="24">test</governor>
            <dependent idx="23">Turing</dependent>
          </dep>
          <dep type="obj">
            <governor idx="21">called</governor>
            <dependent idx="24">test</dependent>
          </dep>
          <dep type="case">
            <governor idx="27">criterion</governor>
            <dependent idx="25">as</dependent>
          </dep>
          <dep type="det">
            <governor idx="27">criterion</governor>
            <dependent idx="26">a</dependent>
          </dep>
          <dep type="obl:as">
            <governor idx="21">called</governor>
            <dependent idx="27">criterion</dependent>
          </dep>
          <dep type="case">
            <governor idx="29">intelligence</governor>
            <dependent idx="28">of</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="27">criterion</governor>
            <dependent idx="29">intelligence</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">published</governor>
            <dependent idx="30">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="6">published</dependent>
          </dep>
          <dep type="case">
            <governor idx="2">1950</governor>
            <dependent idx="1">In</dependent>
          </dep>
          <dep type="obl:in">
            <governor idx="6">published</governor>
            <dependent idx="2">1950</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">published</governor>
            <dependent idx="3">,</dependent>
          </dep>
          <dep type="compound">
            <governor idx="5">Turing</governor>
            <dependent idx="4">Alan</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="6">published</governor>
            <dependent idx="5">Turing</dependent>
          </dep>
          <dep type="det">
            <governor idx="8">article</governor>
            <dependent idx="7">an</dependent>
          </dep>
          <dep type="obj">
            <governor idx="6">published</governor>
            <dependent idx="8">article</dependent>
          </dep>
          <dep type="acl">
            <governor idx="8">article</governor>
            <dependent idx="9">titled</dependent>
          </dep>
          <dep type="punct">
            <governor idx="12">Machinery</governor>
            <dependent idx="10">"</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">Machinery</governor>
            <dependent idx="11">Computing</dependent>
          </dep>
          <dep type="obj">
            <governor idx="9">titled</governor>
            <dependent idx="12">Machinery</dependent>
          </dep>
          <dep type="nsubj" extra="true">
            <governor idx="17">proposed</governor>
            <dependent idx="12">Machinery</dependent>
          </dep>
          <dep type="cc">
            <governor idx="14">Intelligence</governor>
            <dependent idx="13">and</dependent>
          </dep>
          <dep type="obj" extra="true">
            <governor idx="9">titled</governor>
            <dependent idx="14">Intelligence</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="12">Machinery</governor>
            <dependent idx="14">Intelligence</dependent>
          </dep>
          <dep type="nsubj" extra="true">
            <governor idx="17">proposed</governor>
            <dependent idx="14">Intelligence</dependent>
          </dep>
          <dep type="punct">
            <governor idx="12">Machinery</governor>
            <dependent idx="15">"</dependent>
          </dep>
          <dep type="ref">
            <governor idx="12">Machinery</governor>
            <dependent idx="16">which</dependent>
          </dep>
          <dep type="acl:relcl">
            <governor idx="12">Machinery</governor>
            <dependent idx="17">proposed</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="21">called</governor>
            <dependent idx="18">what</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="21">called</governor>
            <dependent idx="19">is</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="21">called</governor>
            <dependent idx="20">now</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="17">proposed</governor>
            <dependent idx="21">called</dependent>
          </dep>
          <dep type="det">
            <governor idx="24">test</governor>
            <dependent idx="22">the</dependent>
          </dep>
          <dep type="compound">
            <governor idx="24">test</governor>
            <dependent idx="23">Turing</dependent>
          </dep>
          <dep type="obj">
            <governor idx="21">called</governor>
            <dependent idx="24">test</dependent>
          </dep>
          <dep type="case">
            <governor idx="27">criterion</governor>
            <dependent idx="25">as</dependent>
          </dep>
          <dep type="det">
            <governor idx="27">criterion</governor>
            <dependent idx="26">a</dependent>
          </dep>
          <dep type="obl:as">
            <governor idx="21">called</governor>
            <dependent idx="27">criterion</dependent>
          </dep>
          <dep type="case">
            <governor idx="29">intelligence</governor>
            <dependent idx="28">of</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="27">criterion</governor>
            <dependent idx="29">intelligence</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">published</governor>
            <dependent idx="30">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-plus-plus-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="6">published</dependent>
          </dep>
          <dep type="case">
            <governor idx="2">1950</governor>
            <dependent idx="1">In</dependent>
          </dep>
          <dep type="obl:in">
            <governor idx="6">published</governor>
            <dependent idx="2">1950</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">published</governor>
            <dependent idx="3">,</dependent>
          </dep>
          <dep type="compound">
            <governor idx="5">Turing</governor>
            <dependent idx="4">Alan</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="6">published</governor>
            <dependent idx="5">Turing</dependent>
          </dep>
          <dep type="det">
            <governor idx="8">article</governor>
            <dependent idx="7">an</dependent>
          </dep>
          <dep type="obj">
            <governor idx="6">published</governor>
            <dependent idx="8">article</dependent>
          </dep>
          <dep type="acl">
            <governor idx="8">article</governor>
            <dependent idx="9">titled</dependent>
          </dep>
          <dep type="punct">
            <governor idx="12">Machinery</governor>
            <dependent idx="10">"</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">Machinery</governor>
            <dependent idx="11">Computing</dependent>
          </dep>
          <dep type="obj">
            <governor idx="9">titled</governor>
            <dependent idx="12">Machinery</dependent>
          </dep>
          <dep type="nsubj" extra="true">
            <governor idx="17">proposed</governor>
            <dependent idx="12">Machinery</dependent>
          </dep>
          <dep type="cc">
            <governor idx="14">Intelligence</governor>
            <dependent idx="13">and</dependent>
          </dep>
          <dep type="obj" extra="true">
            <governor idx="9">titled</governor>
            <dependent idx="14">Intelligence</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="12">Machinery</governor>
            <dependent idx="14">Intelligence</dependent>
          </dep>
          <dep type="nsubj" extra="true">
            <governor idx="17">proposed</governor>
            <dependent idx="14">Intelligence</dependent>
          </dep>
          <dep type="punct">
            <governor idx="12">Machinery</governor>
            <dependent idx="15">"</dependent>
          </dep>
          <dep type="ref">
            <governor idx="12">Machinery</governor>
            <dependent idx="16">which</dependent>
          </dep>
          <dep type="acl:relcl">
            <governor idx="12">Machinery</governor>
            <dependent idx="17">proposed</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="21">called</governor>
            <dependent idx="18">what</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="21">called</governor>
            <dependent idx="19">is</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="21">called</governor>
            <dependent idx="20">now</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="17">proposed</governor>
            <dependent idx="21">called</dependent>
          </dep>
          <dep type="det">
            <governor idx="24">test</governor>
            <dependent idx="22">the</dependent>
          </dep>
          <dep type="compound">
            <governor idx="24">test</governor>
            <dependent idx="23">Turing</dependent>
          </dep>
          <dep type="obj">
            <governor idx="21">called</governor>
            <dependent idx="24">test</dependent>
          </dep>
          <dep type="case">
            <governor idx="27">criterion</governor>
            <dependent idx="25">as</dependent>
          </dep>
          <dep type="det">
            <governor idx="27">criterion</governor>
            <dependent idx="26">a</dependent>
          </dep>
          <dep type="obl:as">
            <governor idx="21">called</governor>
            <dependent idx="27">criterion</dependent>
          </dep>
          <dep type="case">
            <governor idx="29">intelligence</governor>
            <dependent idx="28">of</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="27">criterion</governor>
            <dependent idx="29">intelligence</dependent>
          </dep>
          <dep type="punct">
            <governor idx="6">published</governor>
            <dependent idx="30">.</dependent>
          </dep>
        </dependencies>
      </sentence>
      <sentence id="6">
        <tokens>
          <token id="1">
            <word>The</word>
            <lemma>the</lemma>
            <CharacterOffsetBegin>798</CharacterOffsetBegin>
            <CharacterOffsetEnd>801</CharacterOffsetEnd>
            <POS>DT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="2">
            <word>Georgetown</word>
            <lemma>Georgetown</lemma>
            <CharacterOffsetBegin>802</CharacterOffsetBegin>
            <CharacterOffsetEnd>812</CharacterOffsetEnd>
            <POS>NNP</POS>
            <NER>CITY</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="3">
            <word>experiment</word>
            <lemma>experiment</lemma>
            <CharacterOffsetBegin>813</CharacterOffsetBegin>
            <CharacterOffsetEnd>823</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="4">
            <word>in</word>
            <lemma>in</lemma>
            <CharacterOffsetBegin>824</CharacterOffsetBegin>
            <CharacterOffsetEnd>826</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="5">
            <word>1954</word>
            <lemma>1954</lemma>
            <CharacterOffsetBegin>827</CharacterOffsetBegin>
            <CharacterOffsetEnd>831</CharacterOffsetEnd>
            <POS>CD</POS>
            <NER>DATE</NER>
            <NormalizedNER>1954</NormalizedNER>
            <Speaker>PER0</Speaker>
            <Timex tid="t4" type="DATE">1954</Timex>
          </token>
          <token id="6">
            <word>involved</word>
            <lemma>involved</lemma>
            <CharacterOffsetBegin>832</CharacterOffsetBegin>
            <CharacterOffsetEnd>840</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="7">
            <word>fully</word>
            <lemma>fully</lemma>
            <CharacterOffsetBegin>841</CharacterOffsetBegin>
            <CharacterOffsetEnd>846</CharacterOffsetEnd>
            <POS>RB</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="8">
            <word>automatic</word>
            <lemma>automatic</lemma>
            <CharacterOffsetBegin>847</CharacterOffsetBegin>
            <CharacterOffsetEnd>856</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="9">
            <word>translation</word>
            <lemma>translation</lemma>
            <CharacterOffsetBegin>857</CharacterOffsetBegin>
            <CharacterOffsetEnd>868</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="10">
            <word>of</word>
            <lemma>of</lemma>
            <CharacterOffsetBegin>869</CharacterOffsetBegin>
            <CharacterOffsetEnd>871</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="11">
            <word>more</word>
            <lemma>more</lemma>
            <CharacterOffsetBegin>872</CharacterOffsetBegin>
            <CharacterOffsetEnd>876</CharacterOffsetEnd>
            <POS>JJR</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="12">
            <word>than</word>
            <lemma>than</lemma>
            <CharacterOffsetBegin>877</CharacterOffsetBegin>
            <CharacterOffsetEnd>881</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="13">
            <word>sixty</word>
            <lemma>sixty</lemma>
            <CharacterOffsetBegin>882</CharacterOffsetBegin>
            <CharacterOffsetEnd>887</CharacterOffsetEnd>
            <POS>CD</POS>
            <NER>NUMBER</NER>
            <NormalizedNER>&gt;60.0</NormalizedNER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="14">
            <word>Russian</word>
            <lemma>Russian</lemma>
            <CharacterOffsetBegin>888</CharacterOffsetBegin>
            <CharacterOffsetEnd>895</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>NATIONALITY</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="15">
            <word>sentences</word>
            <lemma>sentence</lemma>
            <CharacterOffsetBegin>896</CharacterOffsetBegin>
            <CharacterOffsetEnd>905</CharacterOffsetEnd>
            <POS>NNS</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="16">
            <word>into</word>
            <lemma>into</lemma>
            <CharacterOffsetBegin>906</CharacterOffsetBegin>
            <CharacterOffsetEnd>910</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="17">
            <word>English</word>
            <lemma>English</lemma>
            <CharacterOffsetBegin>911</CharacterOffsetBegin>
            <CharacterOffsetEnd>918</CharacterOffsetEnd>
            <POS>NNP</POS>
            <NER>NATIONALITY</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="18">
            <word>.</word>
            <lemma>.</lemma>
            <CharacterOffsetBegin>918</CharacterOffsetBegin>
            <CharacterOffsetEnd>919</CharacterOffsetEnd>
            <POS>.</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
        </tokens>
        <parse>(ROOT (S (NP (NP (DT The) (NNP Georgetown) (NN experiment)) (PP (IN in) (NP (CD 1954)))) (VP (JJ involved) (NP (NP (ADJP (RB fully) (JJ automatic)) (NN translation)) (PP (IN of) (NP (NP (QP (JJR more) (IN than) (CD sixty)) (JJ Russian) (NNS sentences)) (PP (IN into) (NP (NNP English))))))) (. .))) </parse>
        <dependencies type="basic-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="3">experiment</dependent>
          </dep>
          <dep type="det">
            <governor idx="3">experiment</governor>
            <dependent idx="1">The</dependent>
          </dep>
          <dep type="compound">
            <governor idx="3">experiment</governor>
            <dependent idx="2">Georgetown</dependent>
          </dep>
          <dep type="case">
            <governor idx="9">translation</governor>
            <dependent idx="4">in</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="9">translation</governor>
            <dependent idx="5">1954</dependent>
          </dep>
          <dep type="amod">
            <governor idx="9">translation</governor>
            <dependent idx="6">involved</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="8">automatic</governor>
            <dependent idx="7">fully</dependent>
          </dep>
          <dep type="amod">
            <governor idx="9">translation</governor>
            <dependent idx="8">automatic</dependent>
          </dep>
          <dep type="nmod">
            <governor idx="3">experiment</governor>
            <dependent idx="9">translation</dependent>
          </dep>
          <dep type="case">
            <governor idx="15">sentences</governor>
            <dependent idx="10">of</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="13">sixty</governor>
            <dependent idx="11">more</dependent>
          </dep>
          <dep type="fixed">
            <governor idx="11">more</governor>
            <dependent idx="12">than</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="15">sentences</governor>
            <dependent idx="13">sixty</dependent>
          </dep>
          <dep type="amod">
            <governor idx="15">sentences</governor>
            <dependent idx="14">Russian</dependent>
          </dep>
          <dep type="nmod">
            <governor idx="9">translation</governor>
            <dependent idx="15">sentences</dependent>
          </dep>
          <dep type="case">
            <governor idx="17">English</governor>
            <dependent idx="16">into</dependent>
          </dep>
          <dep type="nmod">
            <governor idx="15">sentences</governor>
            <dependent idx="17">English</dependent>
          </dep>
          <dep type="punct">
            <governor idx="3">experiment</governor>
            <dependent idx="18">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="3">experiment</dependent>
          </dep>
          <dep type="det">
            <governor idx="3">experiment</governor>
            <dependent idx="1">The</dependent>
          </dep>
          <dep type="compound">
            <governor idx="3">experiment</governor>
            <dependent idx="2">Georgetown</dependent>
          </dep>
          <dep type="case">
            <governor idx="9">translation</governor>
            <dependent idx="4">in</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="9">translation</governor>
            <dependent idx="5">1954</dependent>
          </dep>
          <dep type="amod">
            <governor idx="9">translation</governor>
            <dependent idx="6">involved</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="8">automatic</governor>
            <dependent idx="7">fully</dependent>
          </dep>
          <dep type="amod">
            <governor idx="9">translation</governor>
            <dependent idx="8">automatic</dependent>
          </dep>
          <dep type="nmod:in">
            <governor idx="3">experiment</governor>
            <dependent idx="9">translation</dependent>
          </dep>
          <dep type="case">
            <governor idx="15">sentences</governor>
            <dependent idx="10">of</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="13">sixty</governor>
            <dependent idx="11">more</dependent>
          </dep>
          <dep type="fixed">
            <governor idx="11">more</governor>
            <dependent idx="12">than</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="15">sentences</governor>
            <dependent idx="13">sixty</dependent>
          </dep>
          <dep type="amod">
            <governor idx="15">sentences</governor>
            <dependent idx="14">Russian</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="9">translation</governor>
            <dependent idx="15">sentences</dependent>
          </dep>
          <dep type="case">
            <governor idx="17">English</governor>
            <dependent idx="16">into</dependent>
          </dep>
          <dep type="nmod:into">
            <governor idx="15">sentences</governor>
            <dependent idx="17">English</dependent>
          </dep>
          <dep type="punct">
            <governor idx="3">experiment</governor>
            <dependent idx="18">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-ccprocessed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="3">experiment</dependent>
          </dep>
          <dep type="det">
            <governor idx="3">experiment</governor>
            <dependent idx="1">The</dependent>
          </dep>
          <dep type="compound">
            <governor idx="3">experiment</governor>
            <dependent idx="2">Georgetown</dependent>
          </dep>
          <dep type="case">
            <governor idx="9">translation</governor>
            <dependent idx="4">in</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="9">translation</governor>
            <dependent idx="5">1954</dependent>
          </dep>
          <dep type="amod">
            <governor idx="9">translation</governor>
            <dependent idx="6">involved</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="8">automatic</governor>
            <dependent idx="7">fully</dependent>
          </dep>
          <dep type="amod">
            <governor idx="9">translation</governor>
            <dependent idx="8">automatic</dependent>
          </dep>
          <dep type="nmod:in">
            <governor idx="3">experiment</governor>
            <dependent idx="9">translation</dependent>
          </dep>
          <dep type="case">
            <governor idx="15">sentences</governor>
            <dependent idx="10">of</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="13">sixty</governor>
            <dependent idx="11">more</dependent>
          </dep>
          <dep type="fixed">
            <governor idx="11">more</governor>
            <dependent idx="12">than</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="15">sentences</governor>
            <dependent idx="13">sixty</dependent>
          </dep>
          <dep type="amod">
            <governor idx="15">sentences</governor>
            <dependent idx="14">Russian</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="9">translation</governor>
            <dependent idx="15">sentences</dependent>
          </dep>
          <dep type="case">
            <governor idx="17">English</governor>
            <dependent idx="16">into</dependent>
          </dep>
          <dep type="nmod:into">
            <governor idx="15">sentences</governor>
            <dependent idx="17">English</dependent>
          </dep>
          <dep type="punct">
            <governor idx="3">experiment</governor>
            <dependent idx="18">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="3">experiment</dependent>
          </dep>
          <dep type="det">
            <governor idx="3">experiment</governor>
            <dependent idx="1">The</dependent>
          </dep>
          <dep type="compound">
            <governor idx="3">experiment</governor>
            <dependent idx="2">Georgetown</dependent>
          </dep>
          <dep type="case">
            <governor idx="9">translation</governor>
            <dependent idx="4">in</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="9">translation</governor>
            <dependent idx="5">1954</dependent>
          </dep>
          <dep type="amod">
            <governor idx="9">translation</governor>
            <dependent idx="6">involved</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="8">automatic</governor>
            <dependent idx="7">fully</dependent>
          </dep>
          <dep type="amod">
            <governor idx="9">translation</governor>
            <dependent idx="8">automatic</dependent>
          </dep>
          <dep type="nmod:in">
            <governor idx="3">experiment</governor>
            <dependent idx="9">translation</dependent>
          </dep>
          <dep type="case">
            <governor idx="15">sentences</governor>
            <dependent idx="10">of</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="13">sixty</governor>
            <dependent idx="11">more</dependent>
          </dep>
          <dep type="fixed">
            <governor idx="11">more</governor>
            <dependent idx="12">than</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="15">sentences</governor>
            <dependent idx="13">sixty</dependent>
          </dep>
          <dep type="amod">
            <governor idx="15">sentences</governor>
            <dependent idx="14">Russian</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="9">translation</governor>
            <dependent idx="15">sentences</dependent>
          </dep>
          <dep type="case">
            <governor idx="17">English</governor>
            <dependent idx="16">into</dependent>
          </dep>
          <dep type="nmod:into">
            <governor idx="15">sentences</governor>
            <dependent idx="17">English</dependent>
          </dep>
          <dep type="punct">
            <governor idx="3">experiment</governor>
            <dependent idx="18">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-plus-plus-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="3">experiment</dependent>
          </dep>
          <dep type="det">
            <governor idx="3">experiment</governor>
            <dependent idx="1">The</dependent>
          </dep>
          <dep type="compound">
            <governor idx="3">experiment</governor>
            <dependent idx="2">Georgetown</dependent>
          </dep>
          <dep type="case">
            <governor idx="9">translation</governor>
            <dependent idx="4">in</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="9">translation</governor>
            <dependent idx="5">1954</dependent>
          </dep>
          <dep type="amod">
            <governor idx="9">translation</governor>
            <dependent idx="6">involved</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="8">automatic</governor>
            <dependent idx="7">fully</dependent>
          </dep>
          <dep type="amod">
            <governor idx="9">translation</governor>
            <dependent idx="8">automatic</dependent>
          </dep>
          <dep type="nmod:in">
            <governor idx="3">experiment</governor>
            <dependent idx="9">translation</dependent>
          </dep>
          <dep type="case">
            <governor idx="15">sentences</governor>
            <dependent idx="10">of</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="13">sixty</governor>
            <dependent idx="11">more</dependent>
          </dep>
          <dep type="fixed">
            <governor idx="11">more</governor>
            <dependent idx="12">than</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="15">sentences</governor>
            <dependent idx="13">sixty</dependent>
          </dep>
          <dep type="amod">
            <governor idx="15">sentences</governor>
            <dependent idx="14">Russian</dependent>
          </dep>
          <dep type="nmod:of">
            <governor idx="9">translation</governor>
            <dependent idx="15">sentences</dependent>
          </dep>
          <dep type="case">
            <governor idx="17">English</governor>
            <dependent idx="16">into</dependent>
          </dep>
          <dep type="nmod:into">
            <governor idx="15">sentences</governor>
            <dependent idx="17">English</dependent>
          </dep>
          <dep type="punct">
            <governor idx="3">experiment</governor>
            <dependent idx="18">.</dependent>
          </dep>
        </dependencies>
      </sentence>
      <sentence id="7">
        <tokens>
          <token id="1">
            <word>The</word>
            <lemma>the</lemma>
            <CharacterOffsetBegin>920</CharacterOffsetBegin>
            <CharacterOffsetEnd>923</CharacterOffsetEnd>
            <POS>DT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="2">
            <word>authors</word>
            <lemma>author</lemma>
            <CharacterOffsetBegin>924</CharacterOffsetBegin>
            <CharacterOffsetEnd>931</CharacterOffsetEnd>
            <POS>NNS</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="3">
            <word>claimed</word>
            <lemma>claim</lemma>
            <CharacterOffsetBegin>932</CharacterOffsetBegin>
            <CharacterOffsetEnd>939</CharacterOffsetEnd>
            <POS>VBD</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="4">
            <word>that</word>
            <lemma>that</lemma>
            <CharacterOffsetBegin>940</CharacterOffsetBegin>
            <CharacterOffsetEnd>944</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="5">
            <word>within</word>
            <lemma>within</lemma>
            <CharacterOffsetBegin>945</CharacterOffsetBegin>
            <CharacterOffsetEnd>951</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="6">
            <word>three</word>
            <lemma>three</lemma>
            <CharacterOffsetBegin>952</CharacterOffsetBegin>
            <CharacterOffsetEnd>957</CharacterOffsetEnd>
            <POS>CD</POS>
            <NER>NUMBER</NER>
            <NormalizedNER>&lt;=3.0</NormalizedNER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="7">
            <word>or</word>
            <lemma>or</lemma>
            <CharacterOffsetBegin>958</CharacterOffsetBegin>
            <CharacterOffsetEnd>960</CharacterOffsetEnd>
            <POS>CC</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="8">
            <word>five</word>
            <lemma>five</lemma>
            <CharacterOffsetBegin>961</CharacterOffsetBegin>
            <CharacterOffsetEnd>965</CharacterOffsetEnd>
            <POS>CD</POS>
            <NER>DURATION</NER>
            <NormalizedNER>P5Y</NormalizedNER>
            <Speaker>PER0</Speaker>
            <Timex tid="t5" type="DURATION">P5Y</Timex>
          </token>
          <token id="9">
            <word>years</word>
            <lemma>year</lemma>
            <CharacterOffsetBegin>966</CharacterOffsetBegin>
            <CharacterOffsetEnd>971</CharacterOffsetEnd>
            <POS>NNS</POS>
            <NER>DURATION</NER>
            <NormalizedNER>P5Y</NormalizedNER>
            <Speaker>PER0</Speaker>
            <Timex tid="t5" type="DURATION">P5Y</Timex>
          </token>
          <token id="10">
            <word>,</word>
            <lemma>,</lemma>
            <CharacterOffsetBegin>971</CharacterOffsetBegin>
            <CharacterOffsetEnd>972</CharacterOffsetEnd>
            <POS>,</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="11">
            <word>machine</word>
            <lemma>machine</lemma>
            <CharacterOffsetBegin>973</CharacterOffsetBegin>
            <CharacterOffsetEnd>980</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="12">
            <word>translation</word>
            <lemma>translation</lemma>
            <CharacterOffsetBegin>981</CharacterOffsetBegin>
            <CharacterOffsetEnd>992</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="13">
            <word>would</word>
            <lemma>would</lemma>
            <CharacterOffsetBegin>993</CharacterOffsetBegin>
            <CharacterOffsetEnd>998</CharacterOffsetEnd>
            <POS>MD</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="14">
            <word>be</word>
            <lemma>be</lemma>
            <CharacterOffsetBegin>999</CharacterOffsetBegin>
            <CharacterOffsetEnd>1001</CharacterOffsetEnd>
            <POS>VB</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="15">
            <word>a</word>
            <lemma>a</lemma>
            <CharacterOffsetBegin>1002</CharacterOffsetBegin>
            <CharacterOffsetEnd>1003</CharacterOffsetEnd>
            <POS>DT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="16">
            <word>solved</word>
            <lemma>solve</lemma>
            <CharacterOffsetBegin>1004</CharacterOffsetBegin>
            <CharacterOffsetEnd>1010</CharacterOffsetEnd>
            <POS>VBN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="17">
            <word>problem</word>
            <lemma>problem</lemma>
            <CharacterOffsetBegin>1011</CharacterOffsetBegin>
            <CharacterOffsetEnd>1018</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="18">
            <word>.</word>
            <lemma>.</lemma>
            <CharacterOffsetBegin>1018</CharacterOffsetBegin>
            <CharacterOffsetEnd>1019</CharacterOffsetEnd>
            <POS>.</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
        </tokens>
        <parse>(ROOT (S (NP (DT The) (NNS authors)) (VP (VBD claimed) (SBAR (IN that) (S (PP (IN within) (NP (QP (CD three) (CC or) (CD five)) (NNS years))) (, ,) (NP (NN machine) (NN translation)) (VP (MD would) (VP (VB be) (NP (DT a) (ADJP (VBN solved)) (NN problem))))))) (. .))) </parse>
        <dependencies type="basic-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="3">claimed</dependent>
          </dep>
          <dep type="det">
            <governor idx="2">authors</governor>
            <dependent idx="1">The</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="3">claimed</governor>
            <dependent idx="2">authors</dependent>
          </dep>
          <dep type="mark">
            <governor idx="17">problem</governor>
            <dependent idx="4">that</dependent>
          </dep>
          <dep type="case">
            <governor idx="9">years</governor>
            <dependent idx="5">within</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="9">years</governor>
            <dependent idx="6">three</dependent>
          </dep>
          <dep type="cc">
            <governor idx="8">five</governor>
            <dependent idx="7">or</dependent>
          </dep>
          <dep type="conj">
            <governor idx="6">three</governor>
            <dependent idx="8">five</dependent>
          </dep>
          <dep type="obl">
            <governor idx="17">problem</governor>
            <dependent idx="9">years</dependent>
          </dep>
          <dep type="punct">
            <governor idx="17">problem</governor>
            <dependent idx="10">,</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">translation</governor>
            <dependent idx="11">machine</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="17">problem</governor>
            <dependent idx="12">translation</dependent>
          </dep>
          <dep type="aux">
            <governor idx="17">problem</governor>
            <dependent idx="13">would</dependent>
          </dep>
          <dep type="cop">
            <governor idx="17">problem</governor>
            <dependent idx="14">be</dependent>
          </dep>
          <dep type="det">
            <governor idx="17">problem</governor>
            <dependent idx="15">a</dependent>
          </dep>
          <dep type="amod">
            <governor idx="17">problem</governor>
            <dependent idx="16">solved</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="3">claimed</governor>
            <dependent idx="17">problem</dependent>
          </dep>
          <dep type="punct">
            <governor idx="3">claimed</governor>
            <dependent idx="18">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="3">claimed</dependent>
          </dep>
          <dep type="det">
            <governor idx="2">authors</governor>
            <dependent idx="1">The</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="3">claimed</governor>
            <dependent idx="2">authors</dependent>
          </dep>
          <dep type="mark">
            <governor idx="17">problem</governor>
            <dependent idx="4">that</dependent>
          </dep>
          <dep type="case">
            <governor idx="9">years</governor>
            <dependent idx="5">within</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="9">years</governor>
            <dependent idx="6">three</dependent>
          </dep>
          <dep type="cc">
            <governor idx="8">five</governor>
            <dependent idx="7">or</dependent>
          </dep>
          <dep type="conj:or">
            <governor idx="6">three</governor>
            <dependent idx="8">five</dependent>
          </dep>
          <dep type="obl:within">
            <governor idx="17">problem</governor>
            <dependent idx="9">years</dependent>
          </dep>
          <dep type="punct">
            <governor idx="17">problem</governor>
            <dependent idx="10">,</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">translation</governor>
            <dependent idx="11">machine</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="17">problem</governor>
            <dependent idx="12">translation</dependent>
          </dep>
          <dep type="aux">
            <governor idx="17">problem</governor>
            <dependent idx="13">would</dependent>
          </dep>
          <dep type="cop">
            <governor idx="17">problem</governor>
            <dependent idx="14">be</dependent>
          </dep>
          <dep type="det">
            <governor idx="17">problem</governor>
            <dependent idx="15">a</dependent>
          </dep>
          <dep type="amod">
            <governor idx="17">problem</governor>
            <dependent idx="16">solved</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="3">claimed</governor>
            <dependent idx="17">problem</dependent>
          </dep>
          <dep type="punct">
            <governor idx="3">claimed</governor>
            <dependent idx="18">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-ccprocessed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="3">claimed</dependent>
          </dep>
          <dep type="det">
            <governor idx="2">authors</governor>
            <dependent idx="1">The</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="3">claimed</governor>
            <dependent idx="2">authors</dependent>
          </dep>
          <dep type="mark">
            <governor idx="17">problem</governor>
            <dependent idx="4">that</dependent>
          </dep>
          <dep type="case">
            <governor idx="9">years</governor>
            <dependent idx="5">within</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="9">years</governor>
            <dependent idx="6">three</dependent>
          </dep>
          <dep type="cc">
            <governor idx="8">five</governor>
            <dependent idx="7">or</dependent>
          </dep>
          <dep type="conj:or">
            <governor idx="6">three</governor>
            <dependent idx="8">five</dependent>
          </dep>
          <dep type="nummod" extra="true">
            <governor idx="9">years</governor>
            <dependent idx="8">five</dependent>
          </dep>
          <dep type="obl:within">
            <governor idx="17">problem</governor>
            <dependent idx="9">years</dependent>
          </dep>
          <dep type="punct">
            <governor idx="17">problem</governor>
            <dependent idx="10">,</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">translation</governor>
            <dependent idx="11">machine</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="17">problem</governor>
            <dependent idx="12">translation</dependent>
          </dep>
          <dep type="aux">
            <governor idx="17">problem</governor>
            <dependent idx="13">would</dependent>
          </dep>
          <dep type="cop">
            <governor idx="17">problem</governor>
            <dependent idx="14">be</dependent>
          </dep>
          <dep type="det">
            <governor idx="17">problem</governor>
            <dependent idx="15">a</dependent>
          </dep>
          <dep type="amod">
            <governor idx="17">problem</governor>
            <dependent idx="16">solved</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="3">claimed</governor>
            <dependent idx="17">problem</dependent>
          </dep>
          <dep type="punct">
            <governor idx="3">claimed</governor>
            <dependent idx="18">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="3">claimed</dependent>
          </dep>
          <dep type="det">
            <governor idx="2">authors</governor>
            <dependent idx="1">The</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="3">claimed</governor>
            <dependent idx="2">authors</dependent>
          </dep>
          <dep type="mark">
            <governor idx="17">problem</governor>
            <dependent idx="4">that</dependent>
          </dep>
          <dep type="case">
            <governor idx="9">years</governor>
            <dependent idx="5">within</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="9">years</governor>
            <dependent idx="6">three</dependent>
          </dep>
          <dep type="cc">
            <governor idx="8">five</governor>
            <dependent idx="7">or</dependent>
          </dep>
          <dep type="conj:or">
            <governor idx="6">three</governor>
            <dependent idx="8">five</dependent>
          </dep>
          <dep type="nummod" extra="true">
            <governor idx="9">years</governor>
            <dependent idx="8">five</dependent>
          </dep>
          <dep type="obl:within">
            <governor idx="17">problem</governor>
            <dependent idx="9">years</dependent>
          </dep>
          <dep type="punct">
            <governor idx="17">problem</governor>
            <dependent idx="10">,</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">translation</governor>
            <dependent idx="11">machine</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="17">problem</governor>
            <dependent idx="12">translation</dependent>
          </dep>
          <dep type="aux">
            <governor idx="17">problem</governor>
            <dependent idx="13">would</dependent>
          </dep>
          <dep type="cop">
            <governor idx="17">problem</governor>
            <dependent idx="14">be</dependent>
          </dep>
          <dep type="det">
            <governor idx="17">problem</governor>
            <dependent idx="15">a</dependent>
          </dep>
          <dep type="amod">
            <governor idx="17">problem</governor>
            <dependent idx="16">solved</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="3">claimed</governor>
            <dependent idx="17">problem</dependent>
          </dep>
          <dep type="punct">
            <governor idx="3">claimed</governor>
            <dependent idx="18">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-plus-plus-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="3">claimed</dependent>
          </dep>
          <dep type="det">
            <governor idx="2">authors</governor>
            <dependent idx="1">The</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="3">claimed</governor>
            <dependent idx="2">authors</dependent>
          </dep>
          <dep type="mark">
            <governor idx="17">problem</governor>
            <dependent idx="4">that</dependent>
          </dep>
          <dep type="case">
            <governor idx="9">years</governor>
            <dependent idx="5">within</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="9">years</governor>
            <dependent idx="6">three</dependent>
          </dep>
          <dep type="cc">
            <governor idx="8">five</governor>
            <dependent idx="7">or</dependent>
          </dep>
          <dep type="conj:or">
            <governor idx="6">three</governor>
            <dependent idx="8">five</dependent>
          </dep>
          <dep type="nummod" extra="true">
            <governor idx="9">years</governor>
            <dependent idx="8">five</dependent>
          </dep>
          <dep type="obl:within">
            <governor idx="17">problem</governor>
            <dependent idx="9">years</dependent>
          </dep>
          <dep type="punct">
            <governor idx="17">problem</governor>
            <dependent idx="10">,</dependent>
          </dep>
          <dep type="compound">
            <governor idx="12">translation</governor>
            <dependent idx="11">machine</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="17">problem</governor>
            <dependent idx="12">translation</dependent>
          </dep>
          <dep type="aux">
            <governor idx="17">problem</governor>
            <dependent idx="13">would</dependent>
          </dep>
          <dep type="cop">
            <governor idx="17">problem</governor>
            <dependent idx="14">be</dependent>
          </dep>
          <dep type="det">
            <governor idx="17">problem</governor>
            <dependent idx="15">a</dependent>
          </dep>
          <dep type="amod">
            <governor idx="17">problem</governor>
            <dependent idx="16">solved</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="3">claimed</governor>
            <dependent idx="17">problem</dependent>
          </dep>
          <dep type="punct">
            <governor idx="3">claimed</governor>
            <dependent idx="18">.</dependent>
          </dep>
        </dependencies>
      </sentence>
      <sentence id="8">
        <tokens>
          <token id="1">
            <word>However</word>
            <lemma>however</lemma>
            <CharacterOffsetBegin>1020</CharacterOffsetBegin>
            <CharacterOffsetEnd>1027</CharacterOffsetEnd>
            <POS>RB</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="2">
            <word>,</word>
            <lemma>,</lemma>
            <CharacterOffsetBegin>1027</CharacterOffsetBegin>
            <CharacterOffsetEnd>1028</CharacterOffsetEnd>
            <POS>,</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="3">
            <word>real</word>
            <lemma>real</lemma>
            <CharacterOffsetBegin>1029</CharacterOffsetBegin>
            <CharacterOffsetEnd>1033</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="4">
            <word>progress</word>
            <lemma>progress</lemma>
            <CharacterOffsetBegin>1034</CharacterOffsetBegin>
            <CharacterOffsetEnd>1042</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="5">
            <word>was</word>
            <lemma>be</lemma>
            <CharacterOffsetBegin>1043</CharacterOffsetBegin>
            <CharacterOffsetEnd>1046</CharacterOffsetEnd>
            <POS>VBD</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="6">
            <word>much</word>
            <lemma>much</lemma>
            <CharacterOffsetBegin>1047</CharacterOffsetBegin>
            <CharacterOffsetEnd>1051</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="7">
            <word>slower</word>
            <lemma>slow</lemma>
            <CharacterOffsetBegin>1052</CharacterOffsetBegin>
            <CharacterOffsetEnd>1058</CharacterOffsetEnd>
            <POS>JJR</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="8">
            <word>,</word>
            <lemma>,</lemma>
            <CharacterOffsetBegin>1058</CharacterOffsetBegin>
            <CharacterOffsetEnd>1059</CharacterOffsetEnd>
            <POS>,</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="9">
            <word>and</word>
            <lemma>and</lemma>
            <CharacterOffsetBegin>1060</CharacterOffsetBegin>
            <CharacterOffsetEnd>1063</CharacterOffsetEnd>
            <POS>CC</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="10">
            <word>after</word>
            <lemma>after</lemma>
            <CharacterOffsetBegin>1064</CharacterOffsetBegin>
            <CharacterOffsetEnd>1069</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="11">
            <word>the</word>
            <lemma>the</lemma>
            <CharacterOffsetBegin>1070</CharacterOffsetBegin>
            <CharacterOffsetEnd>1073</CharacterOffsetEnd>
            <POS>DT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="12">
            <word>ALPAC</word>
            <lemma>ALPAC</lemma>
            <CharacterOffsetBegin>1074</CharacterOffsetBegin>
            <CharacterOffsetEnd>1079</CharacterOffsetEnd>
            <POS>NNP</POS>
            <NER>ORGANIZATION</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="13">
            <word>report</word>
            <lemma>report</lemma>
            <CharacterOffsetBegin>1080</CharacterOffsetBegin>
            <CharacterOffsetEnd>1086</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="14">
            <word>in</word>
            <lemma>in</lemma>
            <CharacterOffsetBegin>1087</CharacterOffsetBegin>
            <CharacterOffsetEnd>1089</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="15">
            <word>1966</word>
            <lemma>1966</lemma>
            <CharacterOffsetBegin>1090</CharacterOffsetBegin>
            <CharacterOffsetEnd>1094</CharacterOffsetEnd>
            <POS>CD</POS>
            <NER>DATE</NER>
            <NormalizedNER>1966</NormalizedNER>
            <Speaker>PER0</Speaker>
            <Timex tid="t6" type="DATE">1966</Timex>
          </token>
          <token id="16">
            <word>,</word>
            <lemma>,</lemma>
            <CharacterOffsetBegin>1094</CharacterOffsetBegin>
            <CharacterOffsetEnd>1095</CharacterOffsetEnd>
            <POS>,</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="17">
            <word>which</word>
            <lemma>which</lemma>
            <CharacterOffsetBegin>1096</CharacterOffsetBegin>
            <CharacterOffsetEnd>1101</CharacterOffsetEnd>
            <POS>WDT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="18">
            <word>found</word>
            <lemma>find</lemma>
            <CharacterOffsetBegin>1102</CharacterOffsetBegin>
            <CharacterOffsetEnd>1107</CharacterOffsetEnd>
            <POS>VBD</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="19">
            <word>that</word>
            <lemma>that</lemma>
            <CharacterOffsetBegin>1108</CharacterOffsetBegin>
            <CharacterOffsetEnd>1112</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="20">
            <word>ten</word>
            <lemma>ten</lemma>
            <CharacterOffsetBegin>1113</CharacterOffsetBegin>
            <CharacterOffsetEnd>1116</CharacterOffsetEnd>
            <POS>CD</POS>
            <NER>DURATION</NER>
            <NormalizedNER>P10Y</NormalizedNER>
            <Speaker>PER0</Speaker>
            <Timex tid="t7" type="DURATION">P10Y</Timex>
          </token>
          <token id="21">
            <word>year</word>
            <lemma>year</lemma>
            <CharacterOffsetBegin>1117</CharacterOffsetBegin>
            <CharacterOffsetEnd>1121</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>DURATION</NER>
            <NormalizedNER>P10Y</NormalizedNER>
            <Speaker>PER0</Speaker>
            <Timex tid="t7" type="DURATION">P10Y</Timex>
          </token>
          <token id="22">
            <word>long</word>
            <lemma>long</lemma>
            <CharacterOffsetBegin>1122</CharacterOffsetBegin>
            <CharacterOffsetEnd>1126</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="23">
            <word>research</word>
            <lemma>research</lemma>
            <CharacterOffsetBegin>1127</CharacterOffsetBegin>
            <CharacterOffsetEnd>1135</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="24">
            <word>had</word>
            <lemma>have</lemma>
            <CharacterOffsetBegin>1136</CharacterOffsetBegin>
            <CharacterOffsetEnd>1139</CharacterOffsetEnd>
            <POS>VBD</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="25">
            <word>failed</word>
            <lemma>fail</lemma>
            <CharacterOffsetBegin>1140</CharacterOffsetBegin>
            <CharacterOffsetEnd>1146</CharacterOffsetEnd>
            <POS>VBN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="26">
            <word>to</word>
            <lemma>to</lemma>
            <CharacterOffsetBegin>1147</CharacterOffsetBegin>
            <CharacterOffsetEnd>1149</CharacterOffsetEnd>
            <POS>TO</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="27">
            <word>fulfill</word>
            <lemma>fulfill</lemma>
            <CharacterOffsetBegin>1150</CharacterOffsetBegin>
            <CharacterOffsetEnd>1157</CharacterOffsetEnd>
            <POS>VB</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="28">
            <word>the</word>
            <lemma>the</lemma>
            <CharacterOffsetBegin>1158</CharacterOffsetBegin>
            <CharacterOffsetEnd>1161</CharacterOffsetEnd>
            <POS>DT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="29">
            <word>expectations</word>
            <lemma>expectation</lemma>
            <CharacterOffsetBegin>1162</CharacterOffsetBegin>
            <CharacterOffsetEnd>1174</CharacterOffsetEnd>
            <POS>NNS</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="30">
            <word>,</word>
            <lemma>,</lemma>
            <CharacterOffsetBegin>1174</CharacterOffsetBegin>
            <CharacterOffsetEnd>1175</CharacterOffsetEnd>
            <POS>,</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="31">
            <word>funding</word>
            <lemma>fund</lemma>
            <CharacterOffsetBegin>1176</CharacterOffsetBegin>
            <CharacterOffsetEnd>1183</CharacterOffsetEnd>
            <POS>VBG</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="32">
            <word>for</word>
            <lemma>for</lemma>
            <CharacterOffsetBegin>1184</CharacterOffsetBegin>
            <CharacterOffsetEnd>1187</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="33">
            <word>machine</word>
            <lemma>machine</lemma>
            <CharacterOffsetBegin>1188</CharacterOffsetBegin>
            <CharacterOffsetEnd>1195</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="34">
            <word>translation</word>
            <lemma>translation</lemma>
            <CharacterOffsetBegin>1196</CharacterOffsetBegin>
            <CharacterOffsetEnd>1207</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="35">
            <word>was</word>
            <lemma>be</lemma>
            <CharacterOffsetBegin>1208</CharacterOffsetBegin>
            <CharacterOffsetEnd>1211</CharacterOffsetEnd>
            <POS>VBD</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="36">
            <word>dramatically</word>
            <lemma>dramatically</lemma>
            <CharacterOffsetBegin>1212</CharacterOffsetBegin>
            <CharacterOffsetEnd>1224</CharacterOffsetEnd>
            <POS>RB</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="37">
            <word>reduced</word>
            <lemma>reduce</lemma>
            <CharacterOffsetBegin>1225</CharacterOffsetBegin>
            <CharacterOffsetEnd>1232</CharacterOffsetEnd>
            <POS>VBN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="38">
            <word>.</word>
            <lemma>.</lemma>
            <CharacterOffsetBegin>1232</CharacterOffsetBegin>
            <CharacterOffsetEnd>1233</CharacterOffsetEnd>
            <POS>.</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
        </tokens>
        <parse>(ROOT (S (ADVP (RB However)) (, ,) (S (NP (JJ real) (NN progress)) (VP (VBD was) (ADVP (JJ much)) (ADJP (JJR slower)))) (, ,) (CC and) (S (PP (IN after) (NP (NP (NP (DT the) (NNP ALPAC) (NN report)) (PP (IN in) (NP (CD 1966)))) (, ,) (SBAR (WHNP (WDT which)) (S (VP (VBD found) (SBAR (IN that) (S (NP (CD ten) (NN year) (JJ long) (NN research)) (VP (VBD had) (VP (VBN failed) (S (VP (TO to) (VP (VB fulfill) (NP (DT the) (NNS expectations)))))))))))))) (, ,) (NP (NP (VBG funding)) (PP (IN for) (NP (NN machine) (NN translation)))) (VP (VBD was) (ADVP (RB dramatically)) (VP (VBN reduced)))) (. .))) </parse>
        <dependencies type="basic-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="37">reduced</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="7">slower</governor>
            <dependent idx="1">However</dependent>
          </dep>
          <dep type="punct">
            <governor idx="7">slower</governor>
            <dependent idx="2">,</dependent>
          </dep>
          <dep type="amod">
            <governor idx="4">progress</governor>
            <dependent idx="3">real</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="7">slower</governor>
            <dependent idx="4">progress</dependent>
          </dep>
          <dep type="cop">
            <governor idx="7">slower</governor>
            <dependent idx="5">was</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="7">slower</governor>
            <dependent idx="6">much</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="37">reduced</governor>
            <dependent idx="7">slower</dependent>
          </dep>
          <dep type="punct">
            <governor idx="7">slower</governor>
            <dependent idx="8">,</dependent>
          </dep>
          <dep type="cc">
            <governor idx="18">found</governor>
            <dependent idx="9">and</dependent>
          </dep>
          <dep type="case">
            <governor idx="13">report</governor>
            <dependent idx="10">after</dependent>
          </dep>
          <dep type="det">
            <governor idx="13">report</governor>
            <dependent idx="11">the</dependent>
          </dep>
          <dep type="compound">
            <governor idx="13">report</governor>
            <dependent idx="12">ALPAC</dependent>
          </dep>
          <dep type="obl">
            <governor idx="18">found</governor>
            <dependent idx="13">report</dependent>
          </dep>
          <dep type="case">
            <governor idx="15">1966</governor>
            <dependent idx="14">in</dependent>
          </dep>
          <dep type="nmod">
            <governor idx="13">report</governor>
            <dependent idx="15">1966</dependent>
          </dep>
          <dep type="punct">
            <governor idx="18">found</governor>
            <dependent idx="16">,</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="18">found</governor>
            <dependent idx="17">which</dependent>
          </dep>
          <dep type="conj">
            <governor idx="7">slower</governor>
            <dependent idx="18">found</dependent>
          </dep>
          <dep type="mark">
            <governor idx="25">failed</governor>
            <dependent idx="19">that</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="21">year</governor>
            <dependent idx="20">ten</dependent>
          </dep>
          <dep type="obl:npmod">
            <governor idx="22">long</governor>
            <dependent idx="21">year</dependent>
          </dep>
          <dep type="amod">
            <governor idx="23">research</governor>
            <dependent idx="22">long</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="25">failed</governor>
            <dependent idx="23">research</dependent>
          </dep>
          <dep type="aux">
            <governor idx="25">failed</governor>
            <dependent idx="24">had</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="18">found</governor>
            <dependent idx="25">failed</dependent>
          </dep>
          <dep type="mark">
            <governor idx="27">fulfill</governor>
            <dependent idx="26">to</dependent>
          </dep>
          <dep type="xcomp">
            <governor idx="25">failed</governor>
            <dependent idx="27">fulfill</dependent>
          </dep>
          <dep type="det">
            <governor idx="29">expectations</governor>
            <dependent idx="28">the</dependent>
          </dep>
          <dep type="obj">
            <governor idx="27">fulfill</governor>
            <dependent idx="29">expectations</dependent>
          </dep>
          <dep type="punct">
            <governor idx="29">expectations</governor>
            <dependent idx="30">,</dependent>
          </dep>
          <dep type="acl">
            <governor idx="29">expectations</governor>
            <dependent idx="31">funding</dependent>
          </dep>
          <dep type="case">
            <governor idx="34">translation</governor>
            <dependent idx="32">for</dependent>
          </dep>
          <dep type="compound">
            <governor idx="34">translation</governor>
            <dependent idx="33">machine</dependent>
          </dep>
          <dep type="obl">
            <governor idx="31">funding</governor>
            <dependent idx="34">translation</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="37">reduced</governor>
            <dependent idx="35">was</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="37">reduced</governor>
            <dependent idx="36">dramatically</dependent>
          </dep>
          <dep type="punct">
            <governor idx="37">reduced</governor>
            <dependent idx="38">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="37">reduced</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="7">slower</governor>
            <dependent idx="1">However</dependent>
          </dep>
          <dep type="punct">
            <governor idx="7">slower</governor>
            <dependent idx="2">,</dependent>
          </dep>
          <dep type="amod">
            <governor idx="4">progress</governor>
            <dependent idx="3">real</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="7">slower</governor>
            <dependent idx="4">progress</dependent>
          </dep>
          <dep type="cop">
            <governor idx="7">slower</governor>
            <dependent idx="5">was</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="7">slower</governor>
            <dependent idx="6">much</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="37">reduced</governor>
            <dependent idx="7">slower</dependent>
          </dep>
          <dep type="punct">
            <governor idx="7">slower</governor>
            <dependent idx="8">,</dependent>
          </dep>
          <dep type="cc">
            <governor idx="18">found</governor>
            <dependent idx="9">and</dependent>
          </dep>
          <dep type="case">
            <governor idx="13">report</governor>
            <dependent idx="10">after</dependent>
          </dep>
          <dep type="det">
            <governor idx="13">report</governor>
            <dependent idx="11">the</dependent>
          </dep>
          <dep type="compound">
            <governor idx="13">report</governor>
            <dependent idx="12">ALPAC</dependent>
          </dep>
          <dep type="obl:after">
            <governor idx="18">found</governor>
            <dependent idx="13">report</dependent>
          </dep>
          <dep type="case">
            <governor idx="15">1966</governor>
            <dependent idx="14">in</dependent>
          </dep>
          <dep type="nmod:in">
            <governor idx="13">report</governor>
            <dependent idx="15">1966</dependent>
          </dep>
          <dep type="punct">
            <governor idx="18">found</governor>
            <dependent idx="16">,</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="18">found</governor>
            <dependent idx="17">which</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="7">slower</governor>
            <dependent idx="18">found</dependent>
          </dep>
          <dep type="mark">
            <governor idx="25">failed</governor>
            <dependent idx="19">that</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="21">year</governor>
            <dependent idx="20">ten</dependent>
          </dep>
          <dep type="obl:npmod">
            <governor idx="22">long</governor>
            <dependent idx="21">year</dependent>
          </dep>
          <dep type="amod">
            <governor idx="23">research</governor>
            <dependent idx="22">long</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="25">failed</governor>
            <dependent idx="23">research</dependent>
          </dep>
          <dep type="aux">
            <governor idx="25">failed</governor>
            <dependent idx="24">had</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="18">found</governor>
            <dependent idx="25">failed</dependent>
          </dep>
          <dep type="mark">
            <governor idx="27">fulfill</governor>
            <dependent idx="26">to</dependent>
          </dep>
          <dep type="xcomp">
            <governor idx="25">failed</governor>
            <dependent idx="27">fulfill</dependent>
          </dep>
          <dep type="det">
            <governor idx="29">expectations</governor>
            <dependent idx="28">the</dependent>
          </dep>
          <dep type="obj">
            <governor idx="27">fulfill</governor>
            <dependent idx="29">expectations</dependent>
          </dep>
          <dep type="punct">
            <governor idx="29">expectations</governor>
            <dependent idx="30">,</dependent>
          </dep>
          <dep type="acl">
            <governor idx="29">expectations</governor>
            <dependent idx="31">funding</dependent>
          </dep>
          <dep type="case">
            <governor idx="34">translation</governor>
            <dependent idx="32">for</dependent>
          </dep>
          <dep type="compound">
            <governor idx="34">translation</governor>
            <dependent idx="33">machine</dependent>
          </dep>
          <dep type="obl:for">
            <governor idx="31">funding</governor>
            <dependent idx="34">translation</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="37">reduced</governor>
            <dependent idx="35">was</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="37">reduced</governor>
            <dependent idx="36">dramatically</dependent>
          </dep>
          <dep type="punct">
            <governor idx="37">reduced</governor>
            <dependent idx="38">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-ccprocessed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="37">reduced</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="7">slower</governor>
            <dependent idx="1">However</dependent>
          </dep>
          <dep type="punct">
            <governor idx="7">slower</governor>
            <dependent idx="2">,</dependent>
          </dep>
          <dep type="amod">
            <governor idx="4">progress</governor>
            <dependent idx="3">real</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="7">slower</governor>
            <dependent idx="4">progress</dependent>
          </dep>
          <dep type="cop">
            <governor idx="7">slower</governor>
            <dependent idx="5">was</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="7">slower</governor>
            <dependent idx="6">much</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="37">reduced</governor>
            <dependent idx="7">slower</dependent>
          </dep>
          <dep type="punct">
            <governor idx="7">slower</governor>
            <dependent idx="8">,</dependent>
          </dep>
          <dep type="cc">
            <governor idx="18">found</governor>
            <dependent idx="9">and</dependent>
          </dep>
          <dep type="case">
            <governor idx="13">report</governor>
            <dependent idx="10">after</dependent>
          </dep>
          <dep type="det">
            <governor idx="13">report</governor>
            <dependent idx="11">the</dependent>
          </dep>
          <dep type="compound">
            <governor idx="13">report</governor>
            <dependent idx="12">ALPAC</dependent>
          </dep>
          <dep type="obl:after">
            <governor idx="18">found</governor>
            <dependent idx="13">report</dependent>
          </dep>
          <dep type="case">
            <governor idx="15">1966</governor>
            <dependent idx="14">in</dependent>
          </dep>
          <dep type="nmod:in">
            <governor idx="13">report</governor>
            <dependent idx="15">1966</dependent>
          </dep>
          <dep type="punct">
            <governor idx="18">found</governor>
            <dependent idx="16">,</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="18">found</governor>
            <dependent idx="17">which</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="7">slower</governor>
            <dependent idx="18">found</dependent>
          </dep>
          <dep type="nsubj:pass" extra="true">
            <governor idx="37">reduced</governor>
            <dependent idx="18">found</dependent>
          </dep>
          <dep type="mark">
            <governor idx="25">failed</governor>
            <dependent idx="19">that</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="21">year</governor>
            <dependent idx="20">ten</dependent>
          </dep>
          <dep type="obl:npmod">
            <governor idx="22">long</governor>
            <dependent idx="21">year</dependent>
          </dep>
          <dep type="amod">
            <governor idx="23">research</governor>
            <dependent idx="22">long</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="25">failed</governor>
            <dependent idx="23">research</dependent>
          </dep>
          <dep type="aux">
            <governor idx="25">failed</governor>
            <dependent idx="24">had</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="18">found</governor>
            <dependent idx="25">failed</dependent>
          </dep>
          <dep type="mark">
            <governor idx="27">fulfill</governor>
            <dependent idx="26">to</dependent>
          </dep>
          <dep type="xcomp">
            <governor idx="25">failed</governor>
            <dependent idx="27">fulfill</dependent>
          </dep>
          <dep type="det">
            <governor idx="29">expectations</governor>
            <dependent idx="28">the</dependent>
          </dep>
          <dep type="obj">
            <governor idx="27">fulfill</governor>
            <dependent idx="29">expectations</dependent>
          </dep>
          <dep type="punct">
            <governor idx="29">expectations</governor>
            <dependent idx="30">,</dependent>
          </dep>
          <dep type="acl">
            <governor idx="29">expectations</governor>
            <dependent idx="31">funding</dependent>
          </dep>
          <dep type="case">
            <governor idx="34">translation</governor>
            <dependent idx="32">for</dependent>
          </dep>
          <dep type="compound">
            <governor idx="34">translation</governor>
            <dependent idx="33">machine</dependent>
          </dep>
          <dep type="obl:for">
            <governor idx="31">funding</governor>
            <dependent idx="34">translation</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="37">reduced</governor>
            <dependent idx="35">was</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="37">reduced</governor>
            <dependent idx="36">dramatically</dependent>
          </dep>
          <dep type="punct">
            <governor idx="37">reduced</governor>
            <dependent idx="38">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="37">reduced</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="7">slower</governor>
            <dependent idx="1">However</dependent>
          </dep>
          <dep type="punct">
            <governor idx="7">slower</governor>
            <dependent idx="2">,</dependent>
          </dep>
          <dep type="amod">
            <governor idx="4">progress</governor>
            <dependent idx="3">real</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="7">slower</governor>
            <dependent idx="4">progress</dependent>
          </dep>
          <dep type="cop">
            <governor idx="7">slower</governor>
            <dependent idx="5">was</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="7">slower</governor>
            <dependent idx="6">much</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="37">reduced</governor>
            <dependent idx="7">slower</dependent>
          </dep>
          <dep type="punct">
            <governor idx="7">slower</governor>
            <dependent idx="8">,</dependent>
          </dep>
          <dep type="cc">
            <governor idx="18">found</governor>
            <dependent idx="9">and</dependent>
          </dep>
          <dep type="case">
            <governor idx="13">report</governor>
            <dependent idx="10">after</dependent>
          </dep>
          <dep type="det">
            <governor idx="13">report</governor>
            <dependent idx="11">the</dependent>
          </dep>
          <dep type="compound">
            <governor idx="13">report</governor>
            <dependent idx="12">ALPAC</dependent>
          </dep>
          <dep type="obl:after">
            <governor idx="18">found</governor>
            <dependent idx="13">report</dependent>
          </dep>
          <dep type="case">
            <governor idx="15">1966</governor>
            <dependent idx="14">in</dependent>
          </dep>
          <dep type="nmod:in">
            <governor idx="13">report</governor>
            <dependent idx="15">1966</dependent>
          </dep>
          <dep type="punct">
            <governor idx="18">found</governor>
            <dependent idx="16">,</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="18">found</governor>
            <dependent idx="17">which</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="7">slower</governor>
            <dependent idx="18">found</dependent>
          </dep>
          <dep type="nsubj:pass" extra="true">
            <governor idx="37">reduced</governor>
            <dependent idx="18">found</dependent>
          </dep>
          <dep type="mark">
            <governor idx="25">failed</governor>
            <dependent idx="19">that</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="21">year</governor>
            <dependent idx="20">ten</dependent>
          </dep>
          <dep type="obl:npmod">
            <governor idx="22">long</governor>
            <dependent idx="21">year</dependent>
          </dep>
          <dep type="amod">
            <governor idx="23">research</governor>
            <dependent idx="22">long</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="25">failed</governor>
            <dependent idx="23">research</dependent>
          </dep>
          <dep type="nsubj:xsubj" extra="true">
            <governor idx="27">fulfill</governor>
            <dependent idx="23">research</dependent>
          </dep>
          <dep type="aux">
            <governor idx="25">failed</governor>
            <dependent idx="24">had</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="18">found</governor>
            <dependent idx="25">failed</dependent>
          </dep>
          <dep type="mark">
            <governor idx="27">fulfill</governor>
            <dependent idx="26">to</dependent>
          </dep>
          <dep type="xcomp">
            <governor idx="25">failed</governor>
            <dependent idx="27">fulfill</dependent>
          </dep>
          <dep type="det">
            <governor idx="29">expectations</governor>
            <dependent idx="28">the</dependent>
          </dep>
          <dep type="obj">
            <governor idx="27">fulfill</governor>
            <dependent idx="29">expectations</dependent>
          </dep>
          <dep type="punct">
            <governor idx="29">expectations</governor>
            <dependent idx="30">,</dependent>
          </dep>
          <dep type="acl">
            <governor idx="29">expectations</governor>
            <dependent idx="31">funding</dependent>
          </dep>
          <dep type="case">
            <governor idx="34">translation</governor>
            <dependent idx="32">for</dependent>
          </dep>
          <dep type="compound">
            <governor idx="34">translation</governor>
            <dependent idx="33">machine</dependent>
          </dep>
          <dep type="obl:for">
            <governor idx="31">funding</governor>
            <dependent idx="34">translation</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="37">reduced</governor>
            <dependent idx="35">was</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="37">reduced</governor>
            <dependent idx="36">dramatically</dependent>
          </dep>
          <dep type="punct">
            <governor idx="37">reduced</governor>
            <dependent idx="38">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-plus-plus-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="37">reduced</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="7">slower</governor>
            <dependent idx="1">However</dependent>
          </dep>
          <dep type="punct">
            <governor idx="7">slower</governor>
            <dependent idx="2">,</dependent>
          </dep>
          <dep type="amod">
            <governor idx="4">progress</governor>
            <dependent idx="3">real</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="7">slower</governor>
            <dependent idx="4">progress</dependent>
          </dep>
          <dep type="cop">
            <governor idx="7">slower</governor>
            <dependent idx="5">was</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="7">slower</governor>
            <dependent idx="6">much</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="37">reduced</governor>
            <dependent idx="7">slower</dependent>
          </dep>
          <dep type="punct">
            <governor idx="7">slower</governor>
            <dependent idx="8">,</dependent>
          </dep>
          <dep type="cc">
            <governor idx="18">found</governor>
            <dependent idx="9">and</dependent>
          </dep>
          <dep type="case">
            <governor idx="13">report</governor>
            <dependent idx="10">after</dependent>
          </dep>
          <dep type="det">
            <governor idx="13">report</governor>
            <dependent idx="11">the</dependent>
          </dep>
          <dep type="compound">
            <governor idx="13">report</governor>
            <dependent idx="12">ALPAC</dependent>
          </dep>
          <dep type="obl:after">
            <governor idx="18">found</governor>
            <dependent idx="13">report</dependent>
          </dep>
          <dep type="case">
            <governor idx="15">1966</governor>
            <dependent idx="14">in</dependent>
          </dep>
          <dep type="nmod:in">
            <governor idx="13">report</governor>
            <dependent idx="15">1966</dependent>
          </dep>
          <dep type="punct">
            <governor idx="18">found</governor>
            <dependent idx="16">,</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="18">found</governor>
            <dependent idx="17">which</dependent>
          </dep>
          <dep type="conj:and">
            <governor idx="7">slower</governor>
            <dependent idx="18">found</dependent>
          </dep>
          <dep type="nsubj:pass" extra="true">
            <governor idx="37">reduced</governor>
            <dependent idx="18">found</dependent>
          </dep>
          <dep type="mark">
            <governor idx="25">failed</governor>
            <dependent idx="19">that</dependent>
          </dep>
          <dep type="nummod">
            <governor idx="21">year</governor>
            <dependent idx="20">ten</dependent>
          </dep>
          <dep type="obl:npmod">
            <governor idx="22">long</governor>
            <dependent idx="21">year</dependent>
          </dep>
          <dep type="amod">
            <governor idx="23">research</governor>
            <dependent idx="22">long</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="25">failed</governor>
            <dependent idx="23">research</dependent>
          </dep>
          <dep type="nsubj:xsubj" extra="true">
            <governor idx="27">fulfill</governor>
            <dependent idx="23">research</dependent>
          </dep>
          <dep type="aux">
            <governor idx="25">failed</governor>
            <dependent idx="24">had</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="18">found</governor>
            <dependent idx="25">failed</dependent>
          </dep>
          <dep type="mark">
            <governor idx="27">fulfill</governor>
            <dependent idx="26">to</dependent>
          </dep>
          <dep type="xcomp">
            <governor idx="25">failed</governor>
            <dependent idx="27">fulfill</dependent>
          </dep>
          <dep type="det">
            <governor idx="29">expectations</governor>
            <dependent idx="28">the</dependent>
          </dep>
          <dep type="obj">
            <governor idx="27">fulfill</governor>
            <dependent idx="29">expectations</dependent>
          </dep>
          <dep type="punct">
            <governor idx="29">expectations</governor>
            <dependent idx="30">,</dependent>
          </dep>
          <dep type="acl">
            <governor idx="29">expectations</governor>
            <dependent idx="31">funding</dependent>
          </dep>
          <dep type="case">
            <governor idx="34">translation</governor>
            <dependent idx="32">for</dependent>
          </dep>
          <dep type="compound">
            <governor idx="34">translation</governor>
            <dependent idx="33">machine</dependent>
          </dep>
          <dep type="obl:for">
            <governor idx="31">funding</governor>
            <dependent idx="34">translation</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="37">reduced</governor>
            <dependent idx="35">was</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="37">reduced</governor>
            <dependent idx="36">dramatically</dependent>
          </dep>
          <dep type="punct">
            <governor idx="37">reduced</governor>
            <dependent idx="38">.</dependent>
          </dep>
        </dependencies>
      </sentence>
      <sentence id="9">
        <tokens>
          <token id="1">
            <word>Little</word>
            <lemma>little</lemma>
            <CharacterOffsetBegin>1234</CharacterOffsetBegin>
            <CharacterOffsetEnd>1240</CharacterOffsetEnd>
            <POS>RB</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="2">
            <word>further</word>
            <lemma>further</lemma>
            <CharacterOffsetBegin>1241</CharacterOffsetBegin>
            <CharacterOffsetEnd>1248</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="3">
            <word>research</word>
            <lemma>research</lemma>
            <CharacterOffsetBegin>1249</CharacterOffsetBegin>
            <CharacterOffsetEnd>1257</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="4">
            <word>in</word>
            <lemma>in</lemma>
            <CharacterOffsetBegin>1258</CharacterOffsetBegin>
            <CharacterOffsetEnd>1260</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="5">
            <word>machine</word>
            <lemma>machine</lemma>
            <CharacterOffsetBegin>1261</CharacterOffsetBegin>
            <CharacterOffsetEnd>1268</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="6">
            <word>translation</word>
            <lemma>translation</lemma>
            <CharacterOffsetBegin>1269</CharacterOffsetBegin>
            <CharacterOffsetEnd>1280</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="7">
            <word>was</word>
            <lemma>be</lemma>
            <CharacterOffsetBegin>1281</CharacterOffsetBegin>
            <CharacterOffsetEnd>1284</CharacterOffsetEnd>
            <POS>VBD</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="8">
            <word>conducted</word>
            <lemma>conduct</lemma>
            <CharacterOffsetBegin>1285</CharacterOffsetBegin>
            <CharacterOffsetEnd>1294</CharacterOffsetEnd>
            <POS>VBN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="9">
            <word>until</word>
            <lemma>until</lemma>
            <CharacterOffsetBegin>1295</CharacterOffsetBegin>
            <CharacterOffsetEnd>1300</CharacterOffsetEnd>
            <POS>IN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="10">
            <word>the</word>
            <lemma>the</lemma>
            <CharacterOffsetBegin>1301</CharacterOffsetBegin>
            <CharacterOffsetEnd>1304</CharacterOffsetEnd>
            <POS>DT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="11">
            <word>late</word>
            <lemma>late</lemma>
            <CharacterOffsetBegin>1305</CharacterOffsetBegin>
            <CharacterOffsetEnd>1309</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="12">
            <word>1980s</word>
            <lemma>1980</lemma>
            <CharacterOffsetBegin>1310</CharacterOffsetBegin>
            <CharacterOffsetEnd>1315</CharacterOffsetEnd>
            <POS>NNS</POS>
            <NER>DATE</NER>
            <NormalizedNER>198X</NormalizedNER>
            <Speaker>PER0</Speaker>
            <Timex tid="t8" type="SET">198X</Timex>
          </token>
          <token id="13">
            <word>,</word>
            <lemma>,</lemma>
            <CharacterOffsetBegin>1315</CharacterOffsetBegin>
            <CharacterOffsetEnd>1316</CharacterOffsetEnd>
            <POS>,</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="14">
            <word>when</word>
            <lemma>when</lemma>
            <CharacterOffsetBegin>1317</CharacterOffsetBegin>
            <CharacterOffsetEnd>1321</CharacterOffsetEnd>
            <POS>WRB</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="15">
            <word>the</word>
            <lemma>the</lemma>
            <CharacterOffsetBegin>1322</CharacterOffsetBegin>
            <CharacterOffsetEnd>1325</CharacterOffsetEnd>
            <POS>DT</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="16">
            <word>first</word>
            <lemma>first</lemma>
            <CharacterOffsetBegin>1326</CharacterOffsetBegin>
            <CharacterOffsetEnd>1331</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>ORDINAL</NER>
            <NormalizedNER>1.0</NormalizedNER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="17">
            <word>statistical</word>
            <lemma>statistical</lemma>
            <CharacterOffsetBegin>1332</CharacterOffsetBegin>
            <CharacterOffsetEnd>1343</CharacterOffsetEnd>
            <POS>JJ</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="18">
            <word>machine</word>
            <lemma>machine</lemma>
            <CharacterOffsetBegin>1344</CharacterOffsetBegin>
            <CharacterOffsetEnd>1351</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="19">
            <word>translation</word>
            <lemma>translation</lemma>
            <CharacterOffsetBegin>1352</CharacterOffsetBegin>
            <CharacterOffsetEnd>1363</CharacterOffsetEnd>
            <POS>NN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="20">
            <word>systems</word>
            <lemma>system</lemma>
            <CharacterOffsetBegin>1364</CharacterOffsetBegin>
            <CharacterOffsetEnd>1371</CharacterOffsetEnd>
            <POS>NNS</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="21">
            <word>were</word>
            <lemma>be</lemma>
            <CharacterOffsetBegin>1372</CharacterOffsetBegin>
            <CharacterOffsetEnd>1376</CharacterOffsetEnd>
            <POS>VBD</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="22">
            <word>developed</word>
            <lemma>develop</lemma>
            <CharacterOffsetBegin>1377</CharacterOffsetBegin>
            <CharacterOffsetEnd>1386</CharacterOffsetEnd>
            <POS>VBN</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
          <token id="23">
            <word>.</word>
            <lemma>.</lemma>
            <CharacterOffsetBegin>1386</CharacterOffsetBegin>
            <CharacterOffsetEnd>1387</CharacterOffsetEnd>
            <POS>.</POS>
            <NER>O</NER>
            <Speaker>PER0</Speaker>
          </token>
        </tokens>
        <parse>(ROOT (S (ADVP (RB Little)) (NP (NP (JJ further) (NN research)) (PP (IN in) (NP (NN machine) (NN translation)))) (VP (VBD was) (VP (VBN conducted) (PP (IN until) (NP (NP (DT the) (JJ late) (NNS 1980s)) (, ,) (SBAR (WHADVP (WRB when)) (S (NP (DT the) (JJ first) (JJ statistical) (NML (NN machine) (NN translation)) (NNS systems)) (VP (VBD were) (VP (VBN developed))))))))) (. .))) </parse>
        <dependencies type="basic-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="8">conducted</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="3">research</governor>
            <dependent idx="1">Little</dependent>
          </dep>
          <dep type="amod">
            <governor idx="3">research</governor>
            <dependent idx="2">further</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="8">conducted</governor>
            <dependent idx="3">research</dependent>
          </dep>
          <dep type="case">
            <governor idx="6">translation</governor>
            <dependent idx="4">in</dependent>
          </dep>
          <dep type="compound">
            <governor idx="6">translation</governor>
            <dependent idx="5">machine</dependent>
          </dep>
          <dep type="nmod">
            <governor idx="3">research</governor>
            <dependent idx="6">translation</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="8">conducted</governor>
            <dependent idx="7">was</dependent>
          </dep>
          <dep type="case">
            <governor idx="12">1980s</governor>
            <dependent idx="9">until</dependent>
          </dep>
          <dep type="det">
            <governor idx="12">1980s</governor>
            <dependent idx="10">the</dependent>
          </dep>
          <dep type="amod">
            <governor idx="12">1980s</governor>
            <dependent idx="11">late</dependent>
          </dep>
          <dep type="obl">
            <governor idx="8">conducted</governor>
            <dependent idx="12">1980s</dependent>
          </dep>
          <dep type="punct">
            <governor idx="12">1980s</governor>
            <dependent idx="13">,</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="22">developed</governor>
            <dependent idx="14">when</dependent>
          </dep>
          <dep type="det">
            <governor idx="20">systems</governor>
            <dependent idx="15">the</dependent>
          </dep>
          <dep type="amod">
            <governor idx="20">systems</governor>
            <dependent idx="16">first</dependent>
          </dep>
          <dep type="amod">
            <governor idx="20">systems</governor>
            <dependent idx="17">statistical</dependent>
          </dep>
          <dep type="compound">
            <governor idx="19">translation</governor>
            <dependent idx="18">machine</dependent>
          </dep>
          <dep type="compound">
            <governor idx="20">systems</governor>
            <dependent idx="19">translation</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="22">developed</governor>
            <dependent idx="20">systems</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="22">developed</governor>
            <dependent idx="21">were</dependent>
          </dep>
          <dep type="acl:relcl">
            <governor idx="12">1980s</governor>
            <dependent idx="22">developed</dependent>
          </dep>
          <dep type="punct">
            <governor idx="8">conducted</governor>
            <dependent idx="23">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="8">conducted</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="3">research</governor>
            <dependent idx="1">Little</dependent>
          </dep>
          <dep type="amod">
            <governor idx="3">research</governor>
            <dependent idx="2">further</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="8">conducted</governor>
            <dependent idx="3">research</dependent>
          </dep>
          <dep type="case">
            <governor idx="6">translation</governor>
            <dependent idx="4">in</dependent>
          </dep>
          <dep type="compound">
            <governor idx="6">translation</governor>
            <dependent idx="5">machine</dependent>
          </dep>
          <dep type="nmod:in">
            <governor idx="3">research</governor>
            <dependent idx="6">translation</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="8">conducted</governor>
            <dependent idx="7">was</dependent>
          </dep>
          <dep type="case">
            <governor idx="12">1980s</governor>
            <dependent idx="9">until</dependent>
          </dep>
          <dep type="det">
            <governor idx="12">1980s</governor>
            <dependent idx="10">the</dependent>
          </dep>
          <dep type="amod">
            <governor idx="12">1980s</governor>
            <dependent idx="11">late</dependent>
          </dep>
          <dep type="obl:until">
            <governor idx="8">conducted</governor>
            <dependent idx="12">1980s</dependent>
          </dep>
          <dep type="punct">
            <governor idx="12">1980s</governor>
            <dependent idx="13">,</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="22">developed</governor>
            <dependent idx="14">when</dependent>
          </dep>
          <dep type="det">
            <governor idx="20">systems</governor>
            <dependent idx="15">the</dependent>
          </dep>
          <dep type="amod">
            <governor idx="20">systems</governor>
            <dependent idx="16">first</dependent>
          </dep>
          <dep type="amod">
            <governor idx="20">systems</governor>
            <dependent idx="17">statistical</dependent>
          </dep>
          <dep type="compound">
            <governor idx="19">translation</governor>
            <dependent idx="18">machine</dependent>
          </dep>
          <dep type="compound">
            <governor idx="20">systems</governor>
            <dependent idx="19">translation</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="22">developed</governor>
            <dependent idx="20">systems</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="22">developed</governor>
            <dependent idx="21">were</dependent>
          </dep>
          <dep type="acl:relcl">
            <governor idx="12">1980s</governor>
            <dependent idx="22">developed</dependent>
          </dep>
          <dep type="punct">
            <governor idx="8">conducted</governor>
            <dependent idx="23">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-ccprocessed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="8">conducted</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="3">research</governor>
            <dependent idx="1">Little</dependent>
          </dep>
          <dep type="amod">
            <governor idx="3">research</governor>
            <dependent idx="2">further</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="8">conducted</governor>
            <dependent idx="3">research</dependent>
          </dep>
          <dep type="case">
            <governor idx="6">translation</governor>
            <dependent idx="4">in</dependent>
          </dep>
          <dep type="compound">
            <governor idx="6">translation</governor>
            <dependent idx="5">machine</dependent>
          </dep>
          <dep type="nmod:in">
            <governor idx="3">research</governor>
            <dependent idx="6">translation</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="8">conducted</governor>
            <dependent idx="7">was</dependent>
          </dep>
          <dep type="case">
            <governor idx="12">1980s</governor>
            <dependent idx="9">until</dependent>
          </dep>
          <dep type="det">
            <governor idx="12">1980s</governor>
            <dependent idx="10">the</dependent>
          </dep>
          <dep type="amod">
            <governor idx="12">1980s</governor>
            <dependent idx="11">late</dependent>
          </dep>
          <dep type="obl:until">
            <governor idx="8">conducted</governor>
            <dependent idx="12">1980s</dependent>
          </dep>
          <dep type="punct">
            <governor idx="12">1980s</governor>
            <dependent idx="13">,</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="22">developed</governor>
            <dependent idx="14">when</dependent>
          </dep>
          <dep type="det">
            <governor idx="20">systems</governor>
            <dependent idx="15">the</dependent>
          </dep>
          <dep type="amod">
            <governor idx="20">systems</governor>
            <dependent idx="16">first</dependent>
          </dep>
          <dep type="amod">
            <governor idx="20">systems</governor>
            <dependent idx="17">statistical</dependent>
          </dep>
          <dep type="compound">
            <governor idx="19">translation</governor>
            <dependent idx="18">machine</dependent>
          </dep>
          <dep type="compound">
            <governor idx="20">systems</governor>
            <dependent idx="19">translation</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="22">developed</governor>
            <dependent idx="20">systems</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="22">developed</governor>
            <dependent idx="21">were</dependent>
          </dep>
          <dep type="acl:relcl">
            <governor idx="12">1980s</governor>
            <dependent idx="22">developed</dependent>
          </dep>
          <dep type="punct">
            <governor idx="8">conducted</governor>
            <dependent idx="23">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="8">conducted</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="3">research</governor>
            <dependent idx="1">Little</dependent>
          </dep>
          <dep type="amod">
            <governor idx="3">research</governor>
            <dependent idx="2">further</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="8">conducted</governor>
            <dependent idx="3">research</dependent>
          </dep>
          <dep type="case">
            <governor idx="6">translation</governor>
            <dependent idx="4">in</dependent>
          </dep>
          <dep type="compound">
            <governor idx="6">translation</governor>
            <dependent idx="5">machine</dependent>
          </dep>
          <dep type="nmod:in">
            <governor idx="3">research</governor>
            <dependent idx="6">translation</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="8">conducted</governor>
            <dependent idx="7">was</dependent>
          </dep>
          <dep type="case">
            <governor idx="12">1980s</governor>
            <dependent idx="9">until</dependent>
          </dep>
          <dep type="det">
            <governor idx="12">1980s</governor>
            <dependent idx="10">the</dependent>
          </dep>
          <dep type="amod">
            <governor idx="12">1980s</governor>
            <dependent idx="11">late</dependent>
          </dep>
          <dep type="obl:until">
            <governor idx="8">conducted</governor>
            <dependent idx="12">1980s</dependent>
          </dep>
          <dep type="punct">
            <governor idx="12">1980s</governor>
            <dependent idx="13">,</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="22">developed</governor>
            <dependent idx="14">when</dependent>
          </dep>
          <dep type="det">
            <governor idx="20">systems</governor>
            <dependent idx="15">the</dependent>
          </dep>
          <dep type="amod">
            <governor idx="20">systems</governor>
            <dependent idx="16">first</dependent>
          </dep>
          <dep type="amod">
            <governor idx="20">systems</governor>
            <dependent idx="17">statistical</dependent>
          </dep>
          <dep type="compound">
            <governor idx="19">translation</governor>
            <dependent idx="18">machine</dependent>
          </dep>
          <dep type="compound">
            <governor idx="20">systems</governor>
            <dependent idx="19">translation</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="22">developed</governor>
            <dependent idx="20">systems</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="22">developed</governor>
            <dependent idx="21">were</dependent>
          </dep>
          <dep type="acl:relcl">
            <governor idx="12">1980s</governor>
            <dependent idx="22">developed</dependent>
          </dep>
          <dep type="punct">
            <governor idx="8">conducted</governor>
            <dependent idx="23">.</dependent>
          </dep>
        </dependencies>
        <dependencies type="enhanced-plus-plus-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="8">conducted</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="3">research</governor>
            <dependent idx="1">Little</dependent>
          </dep>
          <dep type="amod">
            <governor idx="3">research</governor>
            <dependent idx="2">further</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="8">conducted</governor>
            <dependent idx="3">research</dependent>
          </dep>
          <dep type="case">
            <governor idx="6">translation</governor>
            <dependent idx="4">in</dependent>
          </dep>
          <dep type="compound">
            <governor idx="6">translation</governor>
            <dependent idx="5">machine</dependent>
          </dep>
          <dep type="nmod:in">
            <governor idx="3">research</governor>
            <dependent idx="6">translation</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="8">conducted</governor>
            <dependent idx="7">was</dependent>
          </dep>
          <dep type="case">
            <governor idx="12">1980s</governor>
            <dependent idx="9">until</dependent>
          </dep>
          <dep type="det">
            <governor idx="12">1980s</governor>
            <dependent idx="10">the</dependent>
          </dep>
          <dep type="amod">
            <governor idx="12">1980s</governor>
            <dependent idx="11">late</dependent>
          </dep>
          <dep type="obl:until">
            <governor idx="8">conducted</governor>
            <dependent idx="12">1980s</dependent>
          </dep>
          <dep type="punct">
            <governor idx="12">1980s</governor>
            <dependent idx="13">,</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="22">developed</governor>
            <dependent idx="14">when</dependent>
          </dep>
          <dep type="det">
            <governor idx="20">systems</governor>
            <dependent idx="15">the</dependent>
          </dep>
          <dep type="amod">
            <governor idx="20">systems</governor>
            <dependent idx="16">first</dependent>
          </dep>
          <dep type="amod">
            <governor idx="20">systems</governor>
            <dependent idx="17">statistical</dependent>
          </dep>
          <dep type="compound">
            <governor idx="19">translation</governor>
            <dependent idx="18">machine</dependent>
          </dep>
          <dep type="compound">
            <governor idx="20">systems</governor>
            <dependent idx="19">translation</dependent>
          </dep>
          <dep type="nsubj:pass">
            <governor idx="22">developed</governor>
            <dependent idx="20">systems</dependent>
          </dep>
          <dep type="aux:pass">
            <governor idx="22">developed</governor>
            <dependent idx="21">were</dependent>
          </dep>
          <dep type="acl:relcl">
            <governor idx="12">1980s</governor>
            <dependent idx="22">developed</dependent>
          </dep>
          <dep type="punct">
            <governor idx="8">conducted</governor>
            <dependent idx="23">.</dependent>
          </dep>
        </dependencies>
      </sentence>
    </sentences>
    <coreference>
      <coreference>
        <mention representative="true">
          <sentence>2</sentence>
          <start>4</start>
          <end>5</end>
          <head>4</head>
          <text>NLP</text>
        </mention>
        <mention>
          <sentence>3</sentence>
          <start>4</start>
          <end>5</end>
          <head>4</head>
          <text>NLP</text>
        </mention>
        <mention>
          <sentence>4</sentence>
          <start>5</start>
          <end>6</end>
          <head>5</head>
          <text>NLP</text>
        </mention>
      </coreference>
      <coreference>
        <mention representative="true">
          <sentence>7</sentence>
          <start>11</start>
          <end>13</end>
          <head>12</head>
          <text>machine translation</text>
        </mention>
        <mention>
          <sentence>9</sentence>
          <start>5</start>
          <end>7</end>
          <head>6</head>
          <text>machine translation</text>
        </mention>
      </coreference>
    </coreference>
  </document>
</root>

Natural
language
processing
From
Wikipedia
,
the
free
encyclopedia
Natural
language
processing
(
NLP
)
is
a
field
of
computer
science
,
artificial
intelligence
,
and
linguistics
concerned
with
the
interactions
between
computers
and
human
(
natural
)
languages
.

As
such
,
NLP
is
related
to
the
area
of
humani
-
computer
interaction
.

Many
challenges
in
NLP
involve
natural
language
understanding
,
that
is
,
enabling
computers
to
derive
meaning
from
human
or
natural
language
input
,
and
others
involve
natural
language
generation
.

History
The
history
of
NLP
generally
starts
in
the
1950s
,
although
work
can
be
found
from
earlier
periods
.

In
1950
,
Alan
Turing
published
an
article
titled
"
Computing
Machinery
and
Intelligence
"
which
proposed
what
is
now
called
the
Turing
test
as
a
criterion
of
intelligence
.

The
Georgetown
experiment
in
1954
involved
fully
automatic
translation
of
more
than
sixty
Russian
sentences
into
English
.

The
authors
claimed
that
within
three
or
five
years
,
machine
translation
would
be
a
solved
problem
.

However
,
real
progress
was
much
slower
,
and
after
the
ALPAC
report
in
1966
,
which
found
that
ten
year
long
research
had
failed
to
fulfill
the
expectations
,
funding
for
machine
translation
was
dramatically
reduced
.

Little
further
research
in
machine
translation
was
conducted
until
the
late
1980s
,
when
the
first
statistical
machine
translation
systems
were
developed
.







--- 54. POS Tagging ---
Natural natural JJ
language    language    NN
processing  processing  NN
From    from    IN
Wikipedia   Wikipedia   NNP
,   ,   ,
the the DT
free    free    JJ
encyclopedia    encyclopedia    NN
Natural natural JJ
language    language    NN
processing  processing  NN
(   (   -LRB-
NLP nlp NN
)   )   -RRB-
is  be  VBZ
a   a   DT
field   field   NN
of  of  IN
computer    computer    NN
science science NN
,   ,   ,
artificial  artificial  JJ
intelligence    intelligence    NN
,   ,   ,
and and CC
linguistics linguistics NNS
concerned   concern VBN
with    with    IN
the the DT
interactions    interaction NNS
between between IN
computers   computer    NNS
and and CC
human   human   JJ
(   (   -LRB-
natural natural JJ
)   )   -RRB-
languages   language    NNS
.   .   .
As  as  IN
such    such    JJ
,   ,   ,
NLP nlp NN
is  be  VBZ
related relate  VBN
to  to  IN
the the DT
area    area    NN
of  of  IN
humani  humani  JJ
-   -   HYPH
computer    computer    NN
interaction interaction NN
.   .   .
Many    many    JJ
challenges  challenge   NNS
in  in  IN
NLP nlp NN
involve involve VBP
natural natural JJ
language    language    NN
understanding   understanding   NN
,   ,   ,
that    that    DT
is  be  VBZ
,   ,   ,
enabling    enable  VBG
computers   computer    NNS
to  to  TO
derive  derive  VB
meaning mean    VBG
from    from    IN
human   human   JJ
or  or  CC
natural natural JJ
language    language    NN
input   input   NN
,   ,   ,
and and CC
others  other   NNS
involve involve VBP
natural natural JJ
language    language    NN
generation  generation  NN
.   .   .
History history NN
The the DT
history history NN
of  of  IN
NLP NLP NNP
generally   generally   RB
starts  start   VBZ
in  in  IN
the the DT
1950s   1950    NNS
,   ,   ,
although    although    IN
work    work    NN
can can MD
be  be  VB
found   find    VBN
from    from    IN
earlier early   JJR
periods period  NNS
.   .   .
In  in  IN
1950    1950    CD
,   ,   ,
Alan    Alan    NNP
Turing  Turing  NNP
published   publish VBD
an  a   DT
article article NN
titled  title   VBN
"   "   ``
Computing   Computing   NNP
Machinery   Machinery   NNP
and and CC
Intelligence    Intelligence    NNP
"   "   ''
which   which   WDT
proposed    propose VBD
what    what    WP
is  be  VBZ
now now RB
called  call    VBN
the the DT
Turing  Turing  NNP
test    test    NN
as  as  IN
a   a   DT
criterion   criterion   NN
of  of  IN
intelligence    intelligence    NN
.   .   .
The the DT
Georgetown  Georgetown  NNP
experiment  experiment  NN
in  in  IN
1954    1954    CD
involved    involved    JJ
fully   fully   RB
automatic   automatic   JJ
translation translation NN
of  of  IN
more    more    JJR
than    than    IN
sixty   sixty   CD
Russian Russian JJ
sentences   sentence    NNS
into    into    IN
English English NNP
.   .   .
The the DT
authors author  NNS
claimed claim   VBD
that    that    IN
within  within  IN
three   three   CD
or  or  CC
five    five    CD
years   year    NNS
,   ,   ,
machine machine NN
translation translation NN
would   would   MD
be  be  VB
a   a   DT
solved  solve   VBN
problem problem NN
.   .   .
However however RB
,   ,   ,
real    real    JJ
progress    progress    NN
was be  VBD
much    much    JJ
slower  slow    JJR
,   ,   ,
and and CC
after   after   IN
the the DT
ALPAC   ALPAC   NNP
report  report  NN
in  in  IN
1966    1966    CD
,   ,   ,
which   which   WDT
found   find    VBD
that    that    IN
ten ten CD
year    year    NN
long    long    JJ
research    research    NN
had have    VBD
failed  fail    VBN
to  to  TO
fulfill fulfill VB
the the DT
expectations    expectation NNS
,   ,   ,
funding fund    VBG
for for IN
machine machine NN
translation translation NN
was be  VBD
dramatically    dramatically    RB
reduced reduce  VBN
.   .   .
Little  little  RB
further further JJ
research    research    NN
in  in  IN
machine machine NN
translation translation NN
was be  VBD
conducted   conduct VBN
until   until   IN
the the DT
late    late    JJ
1980s   1980    NNS
,   ,   ,
when    when    WRB
the the DT
first   first   JJ
statistical statistical JJ
machine machine NN
translation translation NN
systems system  NNS
were    be  VBD
developed   develop VBN
.   .   .

--- 55. NER (Person Names) ---
Alan Turing

--- 56. Coreference Resolution ---
Natural language processing
From Wikipedia, the free encyclopedia

Natural language processing (NLP) is a field of computer science, artificial intelligence, and linguistics concerned with the interactions between computers and human (natural) languages. As such, NLP is related to the area of humani-computer interaction. Many challenges in NLP involve natural language understanding, that is, enabling computers to derive meaning from human or natural language input, and others involve natural language generation.

History

The history of NLP generally starts in the 1950s, although work can be found from earlier periods. In 1950, Alan Turing published an article titled "Computing Machinery and Intelligence" which proposed what is now called the Turing test as a criterion of intelligence.

The Georgetown experiment in 1954 involved fully automatic translation of more than sixty Russian sentences into English. The authors claimed that within three or five years, machine translation would be a solved problem. However, real progress was much slower, and after the ALPAC report in 1966, which found that ten year long research had failed to fulfill the expectations, funding for machine translation was dramatically reduced. Little further research in machine translation was conducted until the late 1980s, when the first statistical machine translation systems were developed.


--- 57. Dependency Visualization ---
Saved dependency_graph.png

--- 58. Triplets (Subj-Pred-Obj) ---
challenges  involve understanding
Turing  published   article

--- 59. NP Extraction (from S-expression) ---
(NP (JJ Natural) (NN language) (NN processing))
(NP (NNP Wikipedia))
(NP (NP (DT the) (JJ free) (NN encyclopedia)) (NP (JJ Natural) (NN language) (NN processing)) (PRN (-LRB- -LRB-) (NP (NN NLP)) (-RRB- -RRB-)))
(NP (NP (DT a) (NN field)) (PP (IN of) (NP (NP (NN computer) (NN science)) (, ,) (NP (JJ artificial) (NN intelligence)) (, ,) (CC and) (NP (NP (NNS linguistics)) (VP (VBN concerned) (PP (IN with) (NP (NP (DT the) (NNS interactions)) (PP (IN between) (NP (NP (NNS computers)) (CC and) (NP (JJ human) (-LRB- -LRB-) (JJ natural) (-RRB- -RRB-) (NNS languages)))))))))))
(NP (NN NLP))
(NP (NP (DT the) (NN area)) (PP (IN of) (NP (ADJP (JJ humani) (HYPH -) (NN computer)) (NN interaction))))
(NP (NP (JJ Many) (NNS challenges)) (PP (IN in) (NP (NN NLP))))
(NP (NML (JJ natural) (NN language)) (NN understanding))
(NP (DT that))
(NP (VBG enabling) (NNS computers))
(NP (UCP (JJ human) (CC or) (NML (JJ natural) (NN language))) (NN input))
(NP (NNS others))
(NP (NML (JJ natural) (NN language)) (NN generation))
(NP (NP (NN History)) (NP (NP (DT The) (NN history)) (PP (IN of) (NP (NNP NLP)))))
(NP (DT the) (NNS 1950s))
(NP (NN work))
(NP (JJR earlier) (NNS periods))
(NP (CD 1950))
(NP (NNP Alan) (NNP Turing))
(NP (NP (DT an) (NN article)) (VP (VBN titled) (NP (`` ") (NP (NP (NNP Computing) (NNP Machinery)) (CC and) (NP (NNP Intelligence))) ('' ") (SBAR (WHNP (WDT which)) (S (VP (VBD proposed) (SBAR (WHNP (WP what)) (S (VP (VBZ is) (ADVP (RB now)) (VP (VBN called) (NP (DT the) (NNP Turing) (NN test)) (PP (IN as) (NP (NP (DT a) (NN criterion)) (PP (IN of) (NP (NN intelligence)))))))))))))))
(NP (NP (DT The) (NNP Georgetown) (NN experiment)) (PP (IN in) (NP (CD 1954))))
(NP (NP (ADJP (RB fully) (JJ automatic)) (NN translation)) (PP (IN of) (NP (NP (QP (JJR more) (IN than) (CD sixty)) (JJ Russian) (NNS sentences)) (PP (IN into) (NP (NNP English))))))
(NP (DT The) (NNS authors))
(NP (QP (CD three) (CC or) (CD five)) (NNS years))
(NP (NN machine) (NN translation))
(NP (DT a) (ADJP (VBN solved)) (NN problem))
(NP (JJ real) (NN progress))
(NP (NP (NP (DT the) (NNP ALPAC) (NN report)) (PP (IN in) (NP (CD 1966)))) (, ,) (SBAR (WHNP (WDT which)) (S (VP (VBD found) (SBAR (IN that) (S (NP (CD ten) (NN year) (JJ long) (NN research)) (VP (VBD had) (VP (VBN failed) (S (VP (TO to) (VP (VB fulfill) (NP (DT the) (NNS expectations)))))))))))))
(NP (NP (VBG funding)) (PP (IN for) (NP (NN machine) (NN translation))))
(NP (NP (JJ further) (NN research)) (PP (IN in) (NP (NN machine) (NN translation))))
(NP (NP (DT the) (JJ late) (NNS 1980s)) (, ,) (SBAR (WHADVP (WRB when)) (S (NP (DT the) (JJ first) (JJ statistical) (NML (NN machine) (NN translation)) (NNS systems)) (VP (VBD were) (VP (VBN developed))))))

課題57の有向グラフの結果は以下の通り。たった6行のデータでもでかいグラフとなった。

一部を拡大するとこんな感じである。

解説

gemma-4は全ての課題を一度に解いた訳ではない。課題によってはかなりの回数の私とのやり取りがあった。

必要となるツールも基本的に私が導入した。以下のツール群である。

  • Stanford Core NLP
  • Gaphviz
  • pydot

ツールの導入に私が介入したのは、sandboxなどの専用の動作環境をAIに与えておらず、通常の私の動作環境でテストしているため動作環境を勝手に汚されたくないという事情からである。sandboxなどによるAIエージェント専用の動作環境の導入は今後の課題である。

Stanford Core NLPはstanford-corenlp-4.5.10.zipをダウンロードしてdataフォルダに展開して導入した。zipファイルでサイズが508MBあった。

Graphvizはsudo apt installで、pydotはpip installで導入した。

solution.pyを実行する前に以下のコマンドでStanford Core NLPをサーバーとして立ち上げる必要がある。

java -mx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer -port 9000 -timeout 15000

nlp.txtが6行程度であればtimeoutは15000ミリ秒(15秒)でよいが、全文を処理する場合には60000ミリ秒(60秒)程度を指定する必要があった。

評価

今回の課題はgemma-4にとって難易度の高い課題だったようで完成するまでにこれまで以上に時間がかかった。

トラブルの多くはツール導入に関連するもので、ツールが正常に動作し始めた後は自分で課題を解決してくれた。この課題もgemma-4の解決能力の範囲内だったと思われる。

ただし全ての結果を検証できているわけではないので間違いが含まれている可能性はある。