| Name: | Cheng-Hao Fu |
|---|---|
| Email: | chf(at)umich(dot)edu |
| Home Institution: | University of Michigan-Ann Arbor |
| Project: | Tensor Deconstruction Algorithms |
| Mentor: | Professor Anand Sarwate |
Research Log
Week 1 (and a little bit before):
I met Professor Sarwate, who was kind enough to let me meet everyone in his lab, on the week before the program formally began. He also gave me a paper to parse through that went over the basic notation and measurments that would be relevant in the coming weeks. He and I also decided to focus my attention on a project that a graduate student he is mentoring is working on. This will hopefully give me some more direction and allow me to more effectively chip in, serving as a more gentle introduction into my first real research project. Beyond that, we worked out a schedule for the rest of the semester, and I imagine that the first meeting with the graduate students will give a lot more purpose to the things that I am doing.
On a more broad note for the REU, we had a workshop that I attended on working on this website. As you can probably tell, I learned enough to make basic updates to this site, but hopefully as the summer progresses, there can be more aesthetic updates. There was also an interesting talk on the OEIS that was given by Neil Sloane. I am also working on the presentation that I will deliver on Tuesday this coming week. Fingers crossed it goes well.
Week 2:
This week gave me a lot more direction on where my project was supposed to go. Previously, the focus of what I am doing was just the general problem of "how can we reconstruct a tensor given some measurements that may or may not be linear?" Now, there is more direction. Specifically, we are looking at measurements of tensors of the form $y_k=|\langle a_k, x\rangle|^2$. Because of the fact that we do not retain the sign information of the tensor, this is not family of linear measurements. For the most part, the way that is most popular at the moment is to convert all tensors to a 1-D counterpart through vectorization and use a known way of doing a retrieval from that, but it's easy to see that doing that completely disregards information we may have about the structure of the original tensor, especially if the original tensor is low rank. This means that the complexity of the problem grows with respect to the dimension when converted to its 1-D form, when there may be room for optimization if we handle the tensor directly. My research will be seeing if this is achieveable.
In general for the REU, there was a talk by Saray Shai that was interesting to listen to, and I also look forward to doing more things with my fellow REU participants.
Week 3:
This week was a week of learning experiences, if not necessarily in terms of reportable results, then in personal growth in problem solving and working on something truly independently. While the act of doing research isn't new, this is the first research project that I've done that is so focused on computer science, and that means that there is a learning curve to reading code that was written for academia, and structured very differently to anything I myself had made. Even my previous experience in CS is heavily based in algorithm theory as opposed to coding. I really cannot oversell the degree to which Professor Sarwate has been patient and understanding of my shortcomings, and I want to yet again use this opportunity to thank him for his support. With that being said, the goal for this week/thiis coming week is to understand existing repositories of code for phase retrieval, and port them to python, both to get it into a format I'm more familiar with, and to master the algorithm as it is known right now. I imagine that the future of this project will be on improving the phase retrieval in this non-linear case, but expect updates next week for a more specific goal.
On a more general note, I went to a social event on Friday, and got to meet some more of my peers, Lazaros, and Parker, which was fun.
Week 4:
This week, I came up with some adjustments to the existing literature on phase retrieval to allow for working with the original tensor directly, instead of vectorization. In short, we will attempt to use the structure that can be used to describe the original tensor in as little information as possible. We achieve this by storing the "factors" of the tensor, and individually minimize our error function over those. Hypothetically, this leads to better performance, because the number of parameters that vary are not as large. Next week will be spent coding it, and seeing if the theoretical solution is robust to noise, and is efficient.
Week 5:
This week, I realized that some more work was needed to take care of both initialization and the update. Professor Sarwate also corrected some of my misunderstandings that I had about the project, and really framed where this project lies in context of the existing literature. Another graduate student also came onto the project, so I talked with him about some of the ideas that we had come up with so far, and we tried to make our understanding of the theory a little more watertight.
Week 6:
This week, we set about coming up with a way to simulate the data effectively. The application of our project is centered around the reconstruction of a video. The low rank focus that we have put on the tensor comes from the fact that in a video, the difference between frames is not very large, and so we will end up with a low rank tensor in the digital representation of it. However, it is difficult to randomly generate a tensor that is low rank because of this property exactly (similarity of slices across one specific dimension). However, there does not seem to be a specific reason why this type of low rank-ness would be easier to solve than the general low rank case, and so we will simply construct random low rank tensors, as we originally planned.
Week 7:
This week, we confronted the “descent” part of the problem. While there are ways to simply give the code a function and ask it to minimize over all inputs, it would be computationally much more efficient if we are able to give the code the Jacobian in order for it to perform descent much faster and in a way that is provably correct. However, this is still a work in progress, as the whole thing is much more complex than initially anticipated.