algorithms Archivi - Paola Elefante

An Advent Calendar for Developers: day 19 to 24

Paola Elefante — Wed, 17 Jan 2018 07:23:08 +0000

I spent the past year or so accumulating nice resources for data scientists and developers, and I've decided to collect them for everyone to enjoy. If you want to get one in your feed every day during the Christmas period, make sure to follow my Twitter or my LinkedIn profile. In any case, I'll be collecting them in four batches here on my blog. Find the first here, the second here, the third here, and enjoy here the last. I hope you all had a wonderful Christmas!

L'articolo An Advent Calendar for Developers: day 19 to 24 sembra essere il primo su Paola Elefante.

An Advent Calendar for Developers: day 13 to 18

Paola Elefante — Tue, 19 Dec 2017 18:04:30 +0000

L'articolo An Advent Calendar for Developers: day 13 to 18 sembra essere il primo su Paola Elefante.

A small guide to Random Forest - part 2

Paola Elefante — Thu, 17 Mar 2016 13:04:51 +0000

This is the second part of a simple and brief guide to the Random Forest algorithm and its implementation in R. If you missed Part I, you can find it here.

randomForest in R

R has a package called randomForest which contains a randomForest function. If you want to explore in depth this implementation, I suggest to read the support webpage. Here I'd like to show the use of few parameters in the R function. I will here use the Titanic dataset from Kaggle to explore some functions and parameters in randomForest. The problem consists in predicting the survival of passengers, based on some data about them.

library(randomForest)
my_formula <- factor(Survived) ~ Sex + Pclass + Parch + SibSp + Embarked
my_forest <- randomForest(my_formula, data = train, ntree = 400, mtry = 3 )

Here I tuned the number of tree to grow with ntree (standard value is 500). The variable mtry specifies how many random features will be selected to grow a single tree. Here I chose mtry = 3, meaning that three features in the set {Sex, Pclass, Parch, SibSp, Embarked} will be randomly chosen every time a tree is grown. If I type:

my_forest

I get a briefing of the variables and the trained model:

Call:
 randomForest(formula = my_formula, data = train, ntree = 400, mtry = 3) 
 Type of random forest: classification
 Number of trees: 400
No. of variables tried at each split: 3

OOB estimate of error rate: 19.85%
Confusion matrix:
 0 1 class.error
0 442 47 0.09611452
1 110 192 0.36423841

The OOB (out-of-bag) error is complementary to the accuracy, and it's here calculated as the ratio: . Look at the confusion matrix, which summarise how many cases were guessed right from our model. On the principal diagonal we can see the cases which are predicted well from my_forest. Indeed, we get: which corresponds to the OOB error of . This is equivalent to saying that the accuracy of our model is . OOB error is calculated for each tree and you can access to such values by typing:

my_forest$err.rate

Nerdy note: notice that the OOB error of the model is not the mean of my_forest$err.rate. They are calculated differently!
Another nice parameter is sampsize, meaning controlling how many rows of the dataframe will get selected to build a single tree:

my_forest <- randomForest(my_formula, data = train, ntree = 1000, mtry = 2, sampsize = (0.9*nrow(train)), replace=TRUE )

Here I asked that of data is used for each tree. In addition, I set replace = TRUE, meaning that one row may be chosen more than once.

One nice aspect of randomForest is the variable importance, which can turn out very useful in feature engineering. If you type, for instance:

my_forest <- randomForest(my_formula, data = train, ntree = 400, importance = TRUE) 
varImpPlot(my_forest)

you'll get a plot as follows.

The importance of each feature is measured in two ways, as described by documentation:

Here are the definitions of the variable importance measures. The first measure is computed from permuting OOB data: For each tree, the prediction error on the out-of-bag portion of the data is recorded (error rate for classification, MSE for regression). Then the same is done after permuting each predictor variable. The difference between the two are then averaged over all trees, and nor- malized by the standard deviation of the differences. If the standard deviation of the differences is equal to 0 for a variable, the division is not done (but the average is almost always equal to 0 in that case).

The second measure is the total decrease in node impurities from splitting on the variable, averaged over all trees. For classification, the node impurity is measured by the Gini index. For regression, it is measured by residual sum of squares.

Another possible choice is to set localImp = TRUE, and see how much each feature influenced the output of each single row. For example, here is the importance of Sex in our model:

Things to keep in mind

The R package randomForest allows to evaluate variable importance (in randomForest, set the parameter importance = TRUE, save the function output and pass it to varImpPlot()). However, keep in mind the following:

For data including categorical variables with different number of levels, random forests are biased in favor of those attributes with more levels. Methods such as partial permutations and growing unbiased trees can be used to solve the problem. (source: Wikipedia)

How many trees should one grow? In principle, the more the merrier. However, the information gain after a certain number is not worth the additional computational cost. The computational complexity of Random Forest is , where is ntree, is mtry and is sampsize.

I ran randomForest, changing ntree from 100 to 20 000, with a step of 100. After ntree = 5000 the OOB error has a 0.5% oscillation, showing that computational cost is too big compared to a gain in accuracy.

Another question is: how deep should I grow a tree? This is an interesting issue. Growing a superficial tree may lead to underfitting, while a too deep tree may cause overfitting. One idea to test the optimal value is to experiment with some very deep trees and observe how the accuracy behaves on its subsets.

Here I experimented with nodesize = 1, 2, ..., 30 and checked the corresponding OOB error. The minimum is attained at nodesize = 25. Given the oscillations, this is a less trivial choice than the number of trees, but experimenting takes less computational time.

The featured image was found on this webpage.

L'articolo A small guide to Random Forest - part 2 sembra essere il primo su Paola Elefante.

A small guide to Random Forest - part 1

Paola Elefante — Fri, 11 Mar 2016 10:23:22 +0000

I've recently started playing with Kaggle and got curious about one of the most famous classification/regression framework, Random Forest. In a problem of classification or regression, several random decision trees (a "forest") are built and at the end the outputs are combined ("bagging"). The intuition is that randomness and a meaningful quantity of trees will avoid over- and underfitting. One possible bagging technique is the majority vote. Take the case of predicting a binary outcome, say a random variable Y which can assume only values in , with respect to some features (occurred events). We assume there exist a correct answer - the "right model" - which we have to predict. The intuition of the majority vote is that if such "divine truth" exists and we build several "quite reasonable" models, most of them will give the right prediction. If the right value is and we make "reasonable" predictions , most of them will be equal to 1 and only a minority will be equal to -1. In mathematical terms, we'll choose the following prediction:

(1)

Bagging is done in other ways, but to me the majority vote example is an easy way to understand the fundamental concept.
The Random Forest framework was introduced by statistician Leo Breiman in 2001 in his seminal paper. Even though implementations have been released in many languages (R, MatLab, Python, Java...), it's important to learn the basics, to be able to tune the parameters well.

Decision trees

The elements of a Random Forest are usually decision trees (there are variants of the framework, though). Assume we have the following database:
training data =
Each column is a sample, each row corresponds to a feature. We consider a binary output: . We now will choose random features (to be able to represent the problem in the plane) and will start building a decision tree. Assume our random sample is:
random sample =
meaning that we randomly selected the features 1 and 3. Let's represent these points on a plane, assigning a different color on the base of the associate output.

Notice the distribution of points in this universal region:

Frequency of output value in the universal region: red corresponds to value 0, blue to 1.

Now an hyperplane is selected (randomly or with some criteria, for instance maximising information gain) and the points are separated into two regions:

Our decision tree starts and we have the following split and new frequency distributions in the two new regions:

START

Now the idea is to iterate this procedure separately on each branch. For instance, we consider only Region 1 () and draw another hyperplane, say :

On the other branch, we draw another hyperplane :

Summing up, we built the following tree.

At this point clearly we can stop. We divided the plane in regions which completely classify our training data.
To summarise, here are the steps of Random Forest:

For k = 1, 2, ..., Ntrees:
--> select a bootstrap sample S from training data
--> grow a decision tree (with a stopping criterion for the depth)
Bagging on

Next, I plan to show the use of some variables and features of the randomForest R package and to make some observations on the algorithm. For instance, how to choose Ntrees? How to determine a reasonable stopping criterion for the tree depth?

The featured image is an excuse to introduce a great visualisation resource for Random Forests: check it out.

L'articolo A small guide to Random Forest - part 1 sembra essere il primo su Paola Elefante.

Open Data: CT datasets and prototypes

Paola Elefante — Mon, 22 Feb 2016 18:41:22 +0000

In my research work, I often find it difficult to get datasets for X-ray CT for method validation, neither simulated and real data. Of course, there's the classic Shepp-Logan phantom, but in many cases it would save a lot of work to download datasets to test one's methods. As for my knowledge, there is no broad known repository. In the image processing community there are the classical Lena, Barbara pictures, but I am not aware of similar common testing grounds in the X-ray CT one. In many cases the final goal is to apply the developed methods to a particular application case, so datasets are available from a company or a hospital repository. However, I think it would be useful to have a "middle step" and test on simpler phantoms before getting to the real deal. Many applied mathematicians often stop at this middle step, since going further would be out of scope for them. I hope this collection will be useful to others.

Since 3D printing is quite easy and inexpensive nowadays (can be done even in public libraries often), I used a the free software Autodesk 123D to design some 3D printable prototypes for static and dynamic CT. I am here sharing both the ready-made STL file (ready to be printed) and the 123D-project file, in case someone wants to do some personal edits. Anything can be freely use, just please quote the author and the source.

If you are aware of other open data repositories for CT or would like to share suggestions, feel free to comment below. I will update this post and the shared repositories in the future (last update: Feb 22nd, 2016).

Static CT open data

[real data] Tomographic data of a walnut: open dataset from FIPS, authors are indicated at the webpage.

[real data] 3D printable simple phantom prototype: to test contrast agents, geometry preservation of reconstruction method, how different attenuation values are reconstructed. Please quote the author (Paola Elefante) and the link to this post as a source.

[real data] 3D printable blood vessels prototype: to test a realistic static geometry of blood vessels splitting in capillaries. Please quote the author (Paola Elefante) and the link to this post as a source.

The static CT blood vessels prototype.

Dynamic CT open data

[real data] DirLab repository: a open data repository, mostly for image registration researchers.

[real data] 3D printable dynamic blood vessels prototype: to test a realistic dynamic simulation of blood or fluid flowing. In the featured picture you can spot an old version of this prototype. I made some major edits in the design, but I still did not test it. Please quote the author (Paola Elefante) and the link to this post as a source.

Design of the prototype for 2D dynamic CT.

[simulated data] 2D dynamic "Y-phantom": a binary phantom where meaningful topological changes happen, good for interface detection methods (level-set, etc.).

L'articolo Open Data: CT datasets and prototypes sembra essere il primo su Paola Elefante.

Mathematicians Go Hollywood

Paola Elefante — Fri, 27 Nov 2015 07:31:57 +0000

Did you know that in 2008 a mathematician won an Academy Award? Do you know how to model realistic hair for animation movies or a bomb deflagrating for an action movie? Or you simply need some effective active contour segmentation method? All these questions have in common an effective, yet intuitive, mathematical framework: level set methods. I came to know them through my own X-ray tomography research project, which gives you a hint of how wide and inclusive such methods are. Yesterday I gave an introductory and informal talk at the Students' Seminar about them. This post comes as an integration to the slides that you may download from this page.

Let's start from defining what an interface is. I could not find a rigorous definition, but the concept is very intuitive. It is a "boundary" which clearly splits the space in two subsets ("inside" and "outside"). You can imagine a closed (even self-intersecting) curve on the plane, for instance. Or the surface of a ball or a torus in . From now on, let's work with planar interfaces, for better visual intuition. However, everything I will discuss here can be extended to any . Now, imagine we are working with a dynamic interface, meaning that our closed curve, for instance, changes in time.

Representation of our dynamic interface: the red arrows represent the velocity field, which gives information of how the curve will change.

Rigorously speaking, we are given an initial curve, and a velocity field which we assume is normal to the curve at any instant . We would like to determine and parametrise the evolution of the curve, that is . One intuitive idea is the following: let's choose some ordered points on our curve (Fig. A), let's follow their evolution ( will tell us where they are going) and let's complete the curve between any subsequent points and by interpolation. However, it may happen that our curve will split under the action of and Fig. B shows how our method would fail, because we told our algorithm to connect with and with .

How could we explain to our algorithms when the curve splits or merges? It's hard, especially since we are searching for a general method. This is where level set methods come to the rescue.

The idea is very intuitive: what if we would add one extra-dimension (time) and "record" the evolution with a surface? For instance, if our curve is a disc expanding, one candidate surface could be a truncated cone. If our disc would evolve in a "8-shape" and then split, one candidate surface would be some sort of 3-dimensional "Y". In other words, we are looking for a function such that:

Here I denote the "inside" region at the time by . At any time, the zero level set of will detect the interface. In addition, its sign will detect the inside and outside regions. Now, observe that from the previous equation:

By applying the chain rule, we get . We assumed that our velocity field was orthogonal to the interface at any instant. In other words,

Hence, we can write the following evolution equation:

This, in addition to the given initial condition , will define and consequently the interface at any time. Suddenly we are in front of a PDE problem, for which there are many well-developed theoretical and numerical tools. Also, this approach handles perfectly topological changes, such as splitting and merging. Plus, it makes it really easy to compute geometric quantities as the curvature of the interface (simply differentiate ).

This new framework was introduced in 1987 by Stanley Osher and James Sethian. Since then, it has been a thriving topic of research: just know that their seminal paper to date has been cited more than 11 500 times! Level set methods have been applied to an incredible variety of problems and settings: medical imaging, computer vision, image denoising, active contour segmentation, scattering, obstacle detection, and more. It has been widely explored both theoretically and numerically. One its richest areas of application is computer graphics. One of Osher's students, Ron Fedkiw, now full professor at Stanford, won an Academy Scientific and Technical Award in 2008. Fedkiw is a consultant for Industrial Light and Magic, a big name in the special effects industry. He worked on blockbusters as Terminator III, Star Wars Episode III, the Pirates of the Caribbean's saga and some Harry Potter movies. Level set methods are widely used in fluid, fire, hair simulations in animation movies. Think of water, with all his splashes (=topological changes): this framework works very well. One drawback is that this approach does not conserve some physical quantities as the volume. However, there are nowadays many tricks to work around this. For instance, there are hybrid methods that mix level set and volume tracking methods or sometime rendering techniques that fill up for the missing physical properties. You can see many animations at the PhysBAM project page.

If you got curios, I include a selection of references:

Osher – Paragios, “Geometric Level Set Methods in Imaging, Vision and Graphics”, Springer 2003.

Osher – Fedkiw, “Level Set Methods and Dynamic Implicit Surfaces”, Springer 2003.

Links:

http://step.polymtl.ca /~rv101/levelset / explanations

http://www.ams.org/notices/201005/rtx100500614p.pdf

http://physbam.stanford.edu/~fedkiw/papers/stanford2003-04.pdf

L'articolo Mathematicians Go Hollywood sembra essere il primo su Paola Elefante.

Coding coding coding

Paola Elefante — Thu, 08 Oct 2015 06:54:22 +0000

Despite the confusing title, in the past days I have been coding. A lot. Even though I am dying to leak information about what exactly I am working on, I still need to wait few weeks to reveal.

I thought anyway to write something about programming from the perspective of an applied mathematician. Research forces you to be humble, since failures - ideas that will not work, rejected papers, etc. - are definitely more frequent than achievements, especially for a junior researcher as myself. Coding has the special power - called debugging - to finish crushing your self-esteem.

However, programming is a skill that most mathematicians should have. A lot of current job positions - academic and not - require some programming skills and they can be useful also in teaching. The most popular coding tool among mathematicians - also in many industries - is MatLab. Its name comes from "Matrix Laboratory" since all its variables are considered arrays. It is a fourth-generation programming language, that means it is very user-friendly. MatLab is currently the tool from numerical computing. The fact that it is so popular, make it easier for the n00b user to learn it, since many online resources are available. For instance, every time I get an error I cannot understand, I google it and it never occurred that someone did not ask the same question before on the MathWorks forum.

Let me open a small parenthesis of life coaching right here. For "softcore programmers" like myself and most mathematicians, it is very important to adopt the most mainstream programming tools. Do not take any advice from computer scientists regarding this choice (*). This article showing booming languages that miserably died can explain. You need to choose a language that:

it's easy to learn, user-friendly and not bond to die soon,
it's widely used, that means there's plenty of debugging and learning resources online,
other mathematicians use or can easily understand.

Going back to MatLab,... When I think of it, I remember of one inscription carved in my home university elevator, "I hate MatLab" (true story). We all do, mate. It's a love-hate relationship. Anyway, MatLab can be a powerful tool for learning, teaching and researching.

License is expensive but education institutions get great discounts. If you plan to self-learn it, I suggest to start from the official tutorials. Your best tools will then be Google, the MathWorks forum and the function "help" (to know what that is, type "help help" in the command window). Many universities offer MatLab basic courses (sometime embedded in Numerical Analysis courses). You can find also some online courses, for instance one by MIT or one in Coursera.

MatLab can be frustrating, but luckily software engineers included some funny easter eggs. Try typing "why" in the command window. I got the following answers so far:

>> why
Because Nausheen obeyed some terrified young not excessively terrified engineer.
>> why
Because the hamster obeyed a bald mathematician.
>> why
Because he told me to.
>> why
Because he insisted on it.
>> why
They suggested it.
>> why
You wanted it that way.
>> why
The devil made me do it.
>> why
Some good and good and young and rich system manager wanted it that way.
>> why
Joe wanted it that way.
>> why
Cleve wanted it.

If you type "life", a simulation of Conway's Game of Life appears in a new window.

As far as I know, the most popular programming languages for mathematicians nowadays are: MatLab, R, C, C++, Mathematica (**). I warmly suggest to any mathematics student (postgrad included) to attend at least one course of general programme design and a course on one of those languages. In programming, motivation is essential, so I suggest to the same students to pick a problem in your favourite area and learn to programme with the final purpose to code a solver for that problem (general or for particular cases). I had a lot of fun when I learned C because the final project was making a Sudoku universal solver.

Now back to work. Hopefully I'll have some interesting contents to share about my codes soon. I wish you no bugs this week!

(*) To be politically correct, let me stress that this would be equally fool as to ask a mathematician for a trick to multiply numbers in your head. They would prove the most general case: "Here, now you can easily multiply numbers, regardless of how you define your product operation or the ring you are in. You're welcome!".

(**) Wolfram made available a light online free version of Mathematica called Wolfram Alpha. It works perfectly if you have basic needs, like plotting something or checking an integral.

L'articolo Coding coding coding sembra essere il primo su Paola Elefante.

4D tomography: walkthrough of my project - part 3

Paola Elefante — Tue, 11 Aug 2015 14:03:15 +0000

Here comes the final part of the walkthrough of my current project on dynamic sparse tomography (see also part 1 and part 2). In the previous post I left the question of the choice of the cut-off function hanging. In a classical level set method, would be the Heaviside step function. The Heaviside function is defined as:

When the first tests on the static case were ran, Kolehmainen, Lassas and Siltanen noticed that the reconstruction was not good, but the level set function itself resembled the infinite precision data. Hence, they decided to use a new cut-off function:

that is the identity function, with a non-negativity constraint. In my own simulations, I approximated the latter by a map:

Numerical results were slightly better and the corresponding objective functional was Frechet differentiable (not only Gateaux differentiable, as before).

Recently Niemi et al. proved that is equivalent to the non-negativity constraint Tikhonov functional. Hence, they generalized it to higher orders. For instance, the functional of order 2 to minimize is:

In this case, existence of a global minimizer was proved.

The first simulation Esa Niemi ran, was on the (2+1)D phantom shown in part 2. The intensity value of the medium is constantly 1, while outside it we have a background constant at value 0. At each time frame, measurements were collected around a full-angle, from only 7 equally distant directions. In the following chosen time frames (“sections” of the 3D surface) you can see the outcome.

The first column depict the infinite precision data, that is the simulated body. In the second column the same sections are reconstructed through Filtered Back Projection, that is the method currently used by industrial machineries. FBP does not work with undersampled data, as you can see. In the third and fourth column you can compare the reconstructions by the level set method I explained, respectively by the order 1 and the order 2 functionals. In the last column, I show how a classical regularization method works in this case, namely Tikhonov regularization. Our new method, with the order 2 functional, works much better, as you can see by the approximation errors shown in each frame.

The second step Esa faced was testing on real data. To reproduce the same measurement setting of the simulation, he created a stop-motion animation. He put some sugar cubes and measured around a full-angle. Then he added one or a couple of sugar cubes and measured again, and so on. The new sugar cubes represented the dynamic change (sudden, in this case) in the data. Sugar cubes are also a good choice because they have corners, which the simulated data was missing. The results can be seen in the following pictures (I selected only three time frames).

The first column shows a fine reconstruction, done by FBP, using many projection angles. From the second column on, only 10 projections were used. Our method is compared with another classical reconstruction method, as Total Variation is. Again, the outcome is very promising: of course in this case you cannot compute an approximation error but you can compare visually with ground truth.

There is still an extensive investigation to carry on. Personally, one of my next goals is to make the codes work in a more realistic measurement setting, namely helicoidal acquisition. I would like to sample the data while the dynamic change happens. To this purpose, I designed the following prototype, inspired by the potential application of angiography.

The top part of the model has the practical purpose of collecting the viscous contrast agent and buy some time for it while we start the measurement procedure. The relevant part of the model are the “veins” that would be (slowly) filled up while we rotate the sample and acquire the data. This will be the next (2+1)D real data I will test on. Currently I am experimenting to find the right contrast agent together with my colleague Alexander Meaney. In the meantime I am experimenting with simulated data with promising results.

This is the current state of my project. Personally, I find it to be a perfect mix of theoretical aspects, computer simulations and great potential for applications. I also hope this will make me get in touch with professionals of other areas. For instance, it would be nice to get suggestions for testing data, or measurement settings. So… feel free to comment and share your view.

L'articolo 4D tomography: walkthrough of my project - part 3 sembra essere il primo su Paola Elefante.

4D tomography: walkthrough of my project - part 2

Paola Elefante — Tue, 23 Jun 2015 09:45:56 +0000

After talking about motivation (see the first part and then part 3), I will now go into details with the mathematics foundations of the project. The novel tomography reconstruction algorithm I am contributing developing is based on a level set method approach.

Level set methods

A level set method is an elaborate, yet geometrically intuitive, framework to deal with a dynamic front. Imagine the problem of a 2D object changing in time. For instance, let's say we have a disk that stays still for a while, then expands in a "eigth shape" and then splits into disks that keep moving. After a while, a smaller disk originates from one of the previous two. In a situation like this, we would witness a topological change that is quite hard to parametrize (*). The intuitive idea behind level set methods is to model such situation in 3D, including time as a spatial dimension. The dynamic 2D object will then "build" a continuous surface. You can observe the case I depicted in the following video (**).

https://youtu.be/VtOpVH7pwrI

On the left, you can observe the 2D dynamic object changing in time. On the right, the level set surface is built accordingly.

Level set methods were originally developed in the 1980s by mathematicians Stanley Osher and James Sethian. The motivating application was (still is) computer graphics, where problems like the one I described above are frequent, for instance, in reproducing animation of fluids, where topological changes are routine.

Video from Dongsoo Han Youtube channel. See also this video about Disney animation.

As Osher put it, "when a catastrophe in the movies should look realistic, Hollywood calls for the mathematicians".

Our model

Level set methods were applied to several inverse problems and you can learn more about it from this nice survey (2004). In this case, we model the X-ray attenuation (that is the unknown we want to recover) as , where is a cut-off function we choose (I will explain how in the next post) and is the minimizer of the following Tikhonov-like functional:

(1)

For someone who works in iterative reconstruction algorithms, this looks familiar (***). The main difference is the presence of the function . Here is the regularization parameter, that has the task to balance the two norms. Now, through Gateaux differentiation (§), one can see that solving this minimization problem is equivalent to finding the limit solution of the evolution equation:

(2)

In this sense, this is a level set method, since equation (2) recalls an evolution equation of a level set method. Anyway, I approach the numerical solution of the problem by the formulation (1) and apply gradient descent methods.

In the next post I will explain who is and how we choose it. Also, I will show some published results to present a comparison with well-known methods in the case of undersampled data.

(*) If you had the instinct of running away at "topological change", don't panic. In simpler words, the trouble is at the instant when the disk splits in two. Such geometric change is tricky.

(**) The phantom was created by postgrad student Esa Niemi, the video was assembled by master student Topias Rusanen. Please mention the authors if you embed the video somewhere.

(***) For those who do not, this is a classical regularization problem formulation.

(§) For details, see Niemi et al. and Kolehmainen et al..

L'articolo 4D tomography: walkthrough of my project - part 2 sembra essere il primo su Paola Elefante.

4D tomography: walkthrough of my project - part 1

Paola Elefante — Fri, 12 Jun 2015 18:10:21 +0000

Last month the greatest event in Inverse Problems ever took place in Helsinki: the Applied Inverse Problems 2015 conference. In addition, I gave my first technical presentation at the 4D tomography minisymposium (find the slides here). I take the chance to write a series of posts as a walkthrough of my project and its current state.

The project

When I started, I basically took up the good work of soon-to-be-doctor Esa Niemi. Esa studied a novel tomography algorithm based on a level set method in the case of a dynamic 2D object. Such approach had been already investigated in the paper by Kolehmainen, Lassas and Siltanen in the static 2D case. My aim is to expand the algorithm to the dynamic 3D cases and to include non-trivial acquisition geometries.

Why dynamic tomography?

The motivation behind this project is strong and our team is definitely not the only one working on these issues. In our case, we are mostly - but not limited to - interested in biomedical applications. One powerful example of potential applications is angiography. In the featured image of this post, you can see a 2D radiography of a hand where a contrast agent has been injected. Angiography represents a fundamental non-invasive diagnostic and treatment tool in medicine.

https://youtu.be/jEfHnwEi2n4

In the video above you can observe a contrast agent injected into some heart's blood vessels, while dynamic CT allows to monitor what happens. Coronary angiography can be useful to detect obstructions or ruptures. During the treatment procedure known as angioplasty, it is fundamental for the physician to monitor the evolution of the operation. To date, coronary angiography is available only in the dynamic 2D case, meaning that it is possible to observe only a section of the heart. It would be extremely useful for a doctor to have a sense of the missing spatial dimension.

Another interesting biomedical application of dynamic CT is radiation therapy. During radiation therapy, cancerous cells are hit by ionizing radiation. If a tumour is placed along moving organs (i.e. lungs, etc.), the radiation flow would miss it for a portion of time and irradiate healthy tissue. As I mentioned in a previous post, radiation can contribute to cancer, so you want to tune the radiation dose down.

Radiation therapy setting.Pic from www.intelligentdental.com.

Dynamic tomography could allow to synchronise a radiation therapy machinery with the real movement of the tumour, thus reducing useless and potentially damaging radiation.

Then we come to the other attribute: sparse. Sparse measurement is synonym of undersampling, meaning that one tries to get the best he can with few data. Few measured data means lower X-ray dose in tomography. To date, industrial machineries mostly reconstruct measured data through the Filtered Back Projection algorithm (FBP). FBP usually guarantees good image quality but asks for a lot of sampled data (*). Iterative methods - that is what we use and research - reconstruct images with less quality (anyway good enough) but with definitely fewer data (even one tenth!). This idea motivates our testing of a novel algorithm, in the hope of massively reduce a patient irradiation.

If the radiation is minimised, CT can be safely prescribed as a prevention examination to monitor some cases. Also, this would mean less sensors and detectors (= less money) and less time (if we succeed to beat FBP computationally speaking).

Here is my/our motivation so far. Next I'll explain what level set method and how we apply it in the dynamic tomography case. To next time!

(*) I here promise I'll take the time to develop in a post what FBP is and show some comparisons with other reconstruction methods, with fewer projections.

Featured image comes from Wikipedia.

L'articolo 4D tomography: walkthrough of my project - part 1 sembra essere il primo su Paola Elefante.