## Saturday, January 19, 2019

### Microsoft Q# Day 1: Qubit Collapsed

After going through the quantum linear algebra, I am going to see some quantum concept by using Q#.

The first one I want to prove is measurement will collapse the qubit. I will use the AssertProb to verify the value with probability. The pseudo code is listed below:

1. use H gate to set the qubit to superposition
2. check the probability to 1 equals 0.5 (50%)
3. measure the qubit
4. check the qubit equals the measured value equals to 1 (100%). The qubit collapsed.
the code listed below:

 ```1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28``` ```namespace Quantum.QSharpApplication2 { open Microsoft.Quantum.Primitive; open Microsoft.Quantum.Canon; open Microsoft.Quantum.Extensions.Convert; operation Operation1 () : Unit { body(...) { using (ancilla = Qubit()) { H(ancilla); AssertProb([PauliZ], [ancilla], Zero, 0.5, "error", 1e-5); AssertProb([PauliZ], [ancilla], One, 0.5, "error", 1e-5); mutable gate = PauliZ; let mX = Measure([gate], [ancilla]); AssertProb([gate], [ancilla], mX, 1.0, "error", 1e-5); Message(ToStringD(mX == Zero ? 0. | 1.)); Reset(ancilla); } } } } ```

## Wednesday, December 26, 2018

### Microsoft Q# is my choice

Today I am thinking to dig into the real quantum programming after learning the foundation part. There are three big players I was looking at on quantum programming framework/language. I hate to waste my time learning the framework or language itself. I want to focus on so I can focus on solving the problem. I have three choices:
• IBM, IBM Q
• Microsoft Q#
It seems IBM Q and Cirq are reusing the Python to provide a framework while Q# is a brand new language. It makes sense IBM and Google use Python as base as it has a good math library. However, I doubt this choice is the best choice. Like the GPU, quantum is special hardware. Cuda is a like C language but it has its own features. For quantum computing, it has a totally different way to compute. Therefore, I think the best way to use a new language, maybe it is just a DSL. C++ can be used to write a functional program, but the best way is still to use a functional programming language.

Also, the examples from those three companies show a huge difference. Q# provides the best sample pack so far. It has a quantum foundation, matrix computation, and programming language. It will help me a lot to adopt this new stuff.

The setup and debugging is the last thought. I had tried to step away from Microsoft stack; however, the debugging and the setup needs more time I expected. I was spoiled by double click and just working.

Anyway, the current Q# shows good progress and the watch, star, and pull request number is bigger than other players. I will continue to focus on the quantum basics, like matrix and math part, anyway.

## Sunday, December 23, 2018

### SelfNotes: Quantum Algorithms

I believe the quantum computing is the key to enable real AI. No matter how complicated the AI algorithm can be, the fundamental computing power will make a real difference.

The huge difference between a classical computer and a quantum computer is so intriguing! It is the first time that math can come back to computer science and guide its evolution. Also, the quantum algorithm is the first time it introduces the internal parallelism. Those existing algorithms barely considered parallelism when it is designed. Now the quantum can change this situation!

The following are some notes about quantum algorithms. They are not related to any language implementation, it is just pure math. The only tool I want to use is "that piece of meat between my ears". :)

## Saturday, December 8, 2018

### Automation with NodeJS-Puppeteer & Visual Studio Code

I saw many attempts to automate the processing using commercial software. However, I do not see this is necessary if this task is not that huge. When more and more application is moving to the web-based. Automation of the Chrome browser will automate most of the scenarios. Therefore, I feel 90% of those cases won't need to pay and still get the job done.

First, we need to set up IDE. There are three files needs to be updated and placed in the place. Please make sure you put launch.json and tasks.json are under .vscode folder.

• launch.json: it is used to launch the application with predefined tasks such as Typescript build.
• tsconfig.json is to used to build the application using Puppeteer
• tasks.json is to define the Typescript build process

The content of these three files
• launch.json

 ```1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19``` ```{ // Use IntelliSense to learn about possible attributes. // Hover to view descriptions of existing attributes. // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 "version": "0.2.0", "configurations": [ { "type": "node", "request": "launch", "name": "Launch Program", "sourceMaps": true, "preLaunchTask": "TSC", "program": "\${workspaceFolder}/app.ts", "outFiles": [ "\${workspaceFolder}/**/*.js" ] } ] }' ```

 ```1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19``` ```{ // See https://go.microsoft.com/fwlink/?LinkId=733558 // for the documentation about the tasks.json format "version": "2.0.0", "tasks": [ { "label": "TSC", "type": "typescript", "tsconfig": "tsconfig.json", "problemMatcher": [ "\$tsc" ], "group": { "kind": "build", "isDefault": true } } ] } ```

• tsconfig.json

 ```1 2 3 4 5 6 7 8 9 10 11 12``` ```{ "compilerOptions": { "target": "es5", "module": "commonjs", "lib": ["es2015", "dom"], "sourceMap": true }, "include": [ "src", "node_modules/@types/puppeteer/index.d.ts" ] } ```

The node_modules folder is created from the npm command provided by the NodeJS framework. The command to run is listed the following. The first line is to install TypeScript compiler which is not installed by default with VS Code. The second line is to install Puppeteer. The last line is to install the library for Typescript to work with Puppeteer.

 ```1 2 3``` ```npm i -g typescript npm i --save puppeteer npm i --save-dev @types/puppeteer ```

The last file is the Puppeteer file:

 ```1 2 3 4 5 6 7 8 9 10``` ```import * as puppeteer from 'puppeteer' (async () => { const browser = await puppeteer.launch(); const page = await browser.newPage(); await page.goto('http://www.google.com'); await page.screenshot({path: 'example.png'}); await browser.close(); })(); ```

## Sunday, November 11, 2018

### Move NLP IKVM to F# .NET-Friendly

Since the last post, I read Sergey's code. Then I decided to work on refactoring the code to store the data into the .NET and F# format. Stanford NLP does provide a server. I still want to make it .Net friendly and also get myself familiar with the NLP core.

I prefer the project-based solution than the interactive solution is because it can have Visual Studio's watch, immediate windows, and debug visualizer. Once I got the information into a comfortable environment, it will be easy to move forward.

The 200-line code is to build up a structure like the following:

I call multiple sentences a story. A story contains (1) sentences and (2) cross-references. The sentence structure shows NLP info about a sentence. The sentence includes a token list, tree, and dependency graph. The cross-references maintain the relationship among elements from different sentences. The first file is the main file. It shows how to invoke the underlying functions and show the structures.

 ```1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62``` ```// Learn more about F# at http://fsharp.org // See the 'F# Tutorial' project for more help. open System open System.IO open java.util open java.io open edu.stanford.nlp.pipeline open edu.stanford.nlp.ling open Utils.NLPUtils open Utils.NLPExtensions open edu.stanford.nlp.util open edu.stanford.nlp.trees open edu.stanford.nlp.semgraph open Utils.NLPStructures open edu.stanford.nlp.coref [] let main argv = let text = "Kosgi Santosh sent an email to Stanford University. He didn't get a reply email."; // Annotation pipeline configuration let props = Properties() props.setProperty("annotators","tokenize, ssplit, pos, lemma, ner, parse, dcoref") |> ignore props.setProperty("ner.useSUTime","0") |> ignore let pipeline = StanfordCoreNLP(props) // Annotation let annotation = Annotation(text) pipeline.annotate(annotation) //get annotation info let keys = annotation.GetToken(typeof) let mentions = keys |> Seq.exactlyOne |> getMentions let sentences = [ let sentences = annotation.GetToken(typeof) for s in sentences do let tokens = s.GetToken(typeof) let words = getWords tokens let t = s.GetToken(typeof) let tree = t |> Seq.exactlyOne |> buildTree words let deps = s.GetToken(typeof) let relationships = deps |> Seq.exactlyOne |> getDependencyGraph words let sentence = { Words = words; Dependency = relationships; Tree = tree; } yield sentence ] let story = { CrossLinks = mentions; Sentences = sentences; } printfn "%O" story 0 // return an integer exit code ```

The second file is the library file. I do not think the structure will stay same after two weeks. I might decide to add more fields. But currently the foundation is there.

 ```1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166``` ```namespace Utils module NLPStructures = type Word = string type Ner = string type POS = string type Index = int type Relationship = string type Span = int * int type Head = int * string type SentenceIndex = int type WordType = { Word : Word Ner: Ner POS: POS Index: Index } member this.IsSame word = match this with | { Word = w; } -> w = word member this.IsSame index = match this with | { Index = i } -> i = index type MentionEntity = { Index: Index Relationship: Relationship Span : Span Head : Head SentenceIndex : SentenceIndex } type RepresentiveMention = MentionEntity type CrossLinkType = { Index: Index RepresentiveMention : RepresentiveMention Mentions : MentionEntity list } type DependencyGraph = | Link of Relationship * WordType * WordType | CrossLink of CrossLinkType type TreeNode = | Node of string * WordType | SubNodes of POS * TreeNode list type SentenceType = { Words: WordType list Dependency: DependencyGraph list Tree: TreeNode } type StoryType = { CrossLinks : CrossLinkType list Sentences : SentenceType list } module NLPUtils = open edu.stanford.nlp.trees open edu.stanford.nlp.ling open edu.stanford.nlp.semgraph open NLPStructures let toEnumerable<'T> (obj:obj) = let l = obj :?> java.util.ArrayList l |> Seq.cast<'T> let toJavaClass (t:System.Type) = java.lang.Class.op_Implicit(t) let findWord (words:WordType list) (word:Word) = words |> Seq.find (fun n -> n.IsSame(word)) let findIndex (words:WordType list) (i:Index) = words |> Seq.find (fun n -> n.IsSame(i)) let inline getObjFromMap (x:^T) t = let key = t |> toJavaClass (^T : (member get : java.lang.Class -> obj) (x, key) ) let getWords (tokens:seq) = [ for token in tokens do let word = typeof |> getObjFromMap token :?> Word let pos = typeof |> getObjFromMap token :?> POS let ner = typeof |> getObjFromMap token :?> Ner let index = token.index() let word = { Word = word; Ner = ner; POS = pos; Index = index } yield word ] let getDependencyGraph words (deps:SemanticGraph) = [ for edge in deps.edgeListSorted().toArray() |> Seq.cast do let gov = edge.getGovernor() let dep = edge.getDependent() let govEntity = findIndex words (gov.index()) let depEntity = findIndex words (dep.index()) let e = Link(edge.getRelation().getLongName(), govEntity, depEntity) yield e ] let rec buildTree words (tree:Tree) = let label = tree.value() let children = tree.children() if children.Length = 0 then let x = tree.label() :?> CoreLabel let i = x.index() let entity = findIndex words i Node(label, entity) else let nodes = children |> Seq.map (fun tree -> buildTree words tree) |> Seq.toList SubNodes(label, nodes) let getMention (mention:edu.stanford.nlp.coref.data.CorefChain.CorefMention) = let mentionId = mention.mentionID let span = (mention.startIndex, mention.endIndex) let relation = mention.animacy.name() let head = (mention.headIndex, mention.mentionSpan) let sentenceIndex = mention.sentNum let m = { Index = mentionId; Relationship = relation; Span = span; Head = head; SentenceIndex = sentenceIndex; } m let getMentions (keys:java.util.HashMap) = [ for key in keys.keySet().toArray() do let v = keys.get(key) :?> edu.stanford.nlp.coref.data.CorefChain let representiveMention = v.getRepresentativeMention() let m = getMention(representiveMention) let index = v.getChainID() let mentions = v.getMentionsInTextualOrder().toArray() let ms = mentions |> Seq.cast |> Seq.map getMention |> Seq.toList let r = { Index = index; RepresentiveMention = m; Mentions = ms; } yield r ] let returnSeq<'T> (x:obj) = if x :? java.util.ArrayList then toEnumerable<'T> x else Seq.singleton (x :?> 'T) module NLPExtensions = open NLPUtils open edu.stanford.nlp.util type CoreMap with member this.GetToken<'T> (t:System.Type) = t |> getObjFromMap this |> returnSeq<'T> ```

The execution result shows below:

## Saturday, November 3, 2018

### SelfNote: Stanford NLP

I create this page as the master page for using F# on Stanford NLP.

## Monday, October 29, 2018

### F# Stanford NLP is running

After some configuration, I can successfully run the first NLP project with F#. Special thanks to Sergey's post! The post is very informative. His solution is based on the F# interactive while I prefer to use the project-based solution.

Sergey points out that one of the common problems to setup is the path problem. His claim is so true. I had stuck in this problem for days. Here is the process I followed.

• Open Visual Studio 2017 and create an F# console application.
• I tried .net core app; it does not work as the IKVM has the dependency on the .NET framework
• compile the F# console application and remember the debug folder location
• Open NuGet and retrieve Stanford NLP CoreNLP. The current version is 3.9.1
• Current Stanford NLP is 3.9.2. I suggest you download 3.9.1 version
 ```1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32``` ```// Learn more about F# at http://fsharp.org // See the 'F# Tutorial' project for more help. open System open System.IO open java.util open java.io open edu.stanford.nlp.pipeline [] let main argv = let text = "Kosgi Santosh sent an email to Stanford University. He didn't get a reply."; // Annotation pipeline configuration let props = Properties() props.setProperty("annotators","tokenize, ssplit, pos, lemma, ner, parse, dcoref") |> ignore props.setProperty("ner.useSUTime","0") |> ignore let pipeline = StanfordCoreNLP(props) // Annotation let annotation = Annotation(text) pipeline.annotate(annotation) // Result - Pretty Print let stream = new ByteArrayOutputStream() pipeline.prettyPrint(annotation, new PrintWriter(stream)) printfn "%O" <| stream.toString() stream.close() printfn "%A" argv 0 // return an integer exit code ```