Rohit Gandikota: So you'd have to turn your volume up so that if… if people… you're gonna… we're gonna use your audio. Yes. And
Rohit Gandikota: Great.
Rohit Gandikota: And let me turn this off here. You can see my screen here. I could use this to get the audience, yeah, the rest of the…
Rohit Gandikota: people here. How do you… how does your camera do that? Where it's, like, zooming into people? I don't know. Zoom added some features, some AI thing. Oh, okay. Right.
Rohit Gandikota: It's terrible, right? It's always, like, looking over my shoulder.
Rohit Gandikota: I'm, like, trying to talk to people over Zoom, and he's like, what's going on right now?
Rohit Gandikota: And so… But, okay.
Rohit Gandikota: So today… so… Rohit.
Rohit Gandikota: Has been working on a bunch of stuff.
Rohit Gandikota: And, as you know, over the years, that's the boundary between you know, vision…
Rohit Gandikota: And generative modeling… And human understandability and control.
Rohit Gandikota: And,
Rohit Gandikota: And… You've not seen this talk. And, well, I don't know what this talk is going to be about, right? But, so, but he's an interesting juncture, I think.
Rohit Gandikota: As we all are in the field, right? And it's been an interesting experience, advising him.
Rohit Gandikota: Because I think that the field has advanced faster than we anticipated.
Rohit Gandikota: when he started his PhD.
Rohit Gandikota: I think Ro has been very good at being at the forefront.
Rohit Gandikota: Of a number of interesting things, but despite… this velocity?
Rohit Gandikota: The field keeps on… Moving in the forefront?
Rohit Gandikota: Ahead?
Rohit Gandikota: Right? And so, you know, I've been having this conversation with Rohed over
Rohit Gandikota: the last few months of, like, alright, he still has some time left in the PhD, like, what's… in light of this, what's the strategy? What's… what's to do? And so I don't know if this talk is gonna touch on any of this at all, but I think it's… I think it's a very interesting case. Most of you don't…
Rohit Gandikota: most of you are in the language space, and not doing computer vision, but I think that computer vision
Rohit Gandikota: you know.
Rohit Gandikota: I have to be careful, because I'm being recorded, right? But, like, it sometimes gives the feeling of being a field that's getting very close to being solved.
Rohit Gandikota: Right? There's a lot of, like, really hard problems that have been standing out there for many years, and… and…
Rohit Gandikota: And,
Rohit Gandikota: And they're, like, you know, they're just so soft now. They're, like, they're just products you can just go and buy for $20 a month.
Rohit Gandikota: And so, the question is, like, what's… what's…
Rohit Gandikota: What's… what's vision? What's the vision?
Rohit Gandikota: down, right?
Rohit Gandikota: Okay, so what is it, Rohit? So, so welcome, Rohit. Thank you very much. Okay.
Rohit Gandikota: Welcome, everyone. Thank you for being here. I know a lot of you traveled all the way across from the river to be here. So, it's… it's a very good introduction, and
Rohit Gandikota: I originally had a totally different set of 48 slides.
Rohit Gandikota: Last week, when I showed the talk to David.
Rohit Gandikota: And then, the pearls of wisdom I got from him, get this, he says, I see a very good value in all your projects.
Rohit Gandikota: But I don't see the purpose being reflected in your talk.
Rohit Gandikota: And then he… he also sort of nudged me to think about… and we've talked about this a lot of times, like, I think I spoke to Tamar, and a lot of you here about the same thing, which his vision seemed to have been solved, right? There are a lot of new models that come… came out.
Rohit Gandikota: Which…
Rohit Gandikota: I think tackle most of it. I think maybe we should wrap it up and, like, go home and start thinking about language models, or maybe world models, right?
Rohit Gandikota: But the more I thought about this, the more I thought about the advice David gave me, it… I came to this conclusion.
Rohit Gandikota: that… I don't think vision is solved at all. We're not even close.
Rohit Gandikota: And I'm going to, like, take you through 35 minutes or 40, hopefully.
Rohit Gandikota: minutes of my talk, trying to convince you that vision just started.
Rohit Gandikota: It just started as to, like, how we can change the way vision works, and how if we don't do it, it would come to a dead end, thinking that it is solved.
Rohit Gandikota: Can I add something to it? Yes.
Rohit Gandikota: I gave a talk a few months ago at a place I won't mention.
Rohit Gandikota: But I was making similar statements over lunch of, well, vision problems are solved.
Rohit Gandikota: And some of the vision people got very… I think as an NLP person, you cannot say that. No, exactly, so, so…
Rohit Gandikota: I was thinking, well, it used to be that at NeurIPS, everyone worked on vision.
Rohit Gandikota: And then now everyone works on an LP and on all language models, and you can think, well, maybe that's because vision is solved, and that was my naive perception.
Rohit Gandikota: But what they told me is that the hard problems are completely not solved, and there are, like, old, very old benchmarks where models are very far from humans, even in things like object localization and detection, like, the basic stuff.
Rohit Gandikota: And that the reason… that's the most interesting thing. The reason that everyone is working on LLMs is because it's easier.
Rohit Gandikota: That's just an tick.
Rohit Gandikota: I don't know if you feel this way.
Rohit Gandikota: No comments. But I do have a lot of similar thoughts, but, yes, I'll talk more about them. And I think I'll draw some parallels to text, too.
Rohit Gandikota: So, okay, this talk is,
Rohit Gandikota: I know I usually like to do a lot of interactive talk, where I let you stop me in between, but for the first time, with my heart, I'm going to tell you, I want to practice like a
Rohit Gandikota: Like, a one-shot talk.
Rohit Gandikota: So please, if you have any, like, if there are urgent questions which
Rohit Gandikota: like, went right over your head, please stop me, and say, hey, this is not clear, so that I can be more clear about it.
Rohit Gandikota: If not, we can do, like, a Q&A in the end.
Rohit Gandikota: So, also, I'd like to keep it slightly…
Rohit Gandikota: formal, while also being informal and, like, trying to make you go through this journey together, right? So…
Rohit Gandikota: So yeah, I start by telling you that I had totally different set of slides, and to get to this purpose slide, I had to sit 3 days on an empty, blank.
Rohit Gandikota: slide, and I could not get to anything. And I thought, is David tricking me?
Rohit Gandikota: You know, what does it mean to have a purpose? Like, is it altruism? What is it? Like, So…
Rohit Gandikota: And…
Rohit Gandikota: At the end of third day, I realized that I usually like to give my talks with a big load of motivation for my audience in the beginning, to talk about why it is I care about the project.
Rohit Gandikota: And the problem in the first place?
Rohit Gandikota: And then I go into, like, 2-3 slides of my results, and then I end the talk.
Rohit Gandikota: So… Turns out, all it takes is for me to bring all of them together.
Rohit Gandikota: And then bring some of the heated conversations I had with most of you here about AI, about why I'm doing my research.
Rohit Gandikota: And sort of sit on them for a good 8 hours, and then it comes out.
Rohit Gandikota: So… I started by asking this question.
Rohit Gandikota: Wait, why is it not?
Rohit Gandikota: Yeah, so… Why now? Now especially, that vision models need to be more readable.
Rohit Gandikota: And I'm going to go into more depth about what Readable is, why today.
Rohit Gandikota: And why am I even caring about this problem in the first place?
Rohit Gandikota: But, I think for this audience.
Rohit Gandikota: And I'm going to give a really controversial title.
Rohit Gandikota: Which is why interpretability is far more important in vision.
Rohit Gandikota: than text.
Rohit Gandikota: And, again, today. Today is the word which is very important. Why it's today that it's more important than yesterday? Yesterday, I mean, like, a few years ago.
Rohit Gandikota: So…
Rohit Gandikota: I keep coming back to this question whenever I talk about AI with any of you here, is… it's a tool, right? Like, built by humans, for humans.
Rohit Gandikota: To sort of do something for us.
Rohit Gandikota: And…
Rohit Gandikota: Over the millions of years in the history of humans, we have built so many widely used tools, right? Like, starting from a million years ago, we had stone access.
Rohit Gandikota: Which really, I think, is the reason why we survived as human race.
Rohit Gandikota: And then we had printing presses that helped us communicate en masse.
Rohit Gandikota: amounts, I think, also a good milestone for us as humanity to improve our intelligence. Then came calculators.
Rohit Gandikota: If you recognize that, I don't think you would, that's a mechanical calculator. Even I didn't.
Rohit Gandikota: And then, of course, smartphones, right? All of them have, in some way, been
Rohit Gandikota: Mostly wide-used tools, like, sorry, widely used tools in our human history.
Rohit Gandikota: I… should I keep it there?
Rohit Gandikota: I don't know, maybe?
Rohit Gandikota: I think it deserves a place, at least.
Rohit Gandikota: But funnily, these models, AI models, have been there for decades now, right? Like, if you know that, it's called ELISA. It's the first ChatGPT to ever be
Rohit Gandikota: on Earth, it's from 1967, and you can talk to your computer, it talks back.
Rohit Gandikota: If it's good or not, I can't vouch for it, but yeah, it used to talk back.
Rohit Gandikota: And then, sure, over the years, we have built so many tools that sort of increase this…
Rohit Gandikota: Our ability to talk to, machines, right?
Rohit Gandikota: And up until 2019, we had GPT-2, which I think was a part of discussion here.
Rohit Gandikota: That did the same thing that we are doing today, which it can talk to you.
Rohit Gandikota: Like, but why is it that
Rohit Gandikota: Over the 20 or 40 years in the history that this…
Rohit Gandikota: Models did not deserve a place there, and why today?
Rohit Gandikota: Right? And I thought, well, because tools are supposed to be to automate our human labor, make us more efficient, make our life easier, and that's the reason, right, that tools have become so important in our lives.
Rohit Gandikota: Sure, I think that could be a good definition of tool in a Wikipedia page.
Rohit Gandikota: But the reason that something becomes really widely used is because
Rohit Gandikota: They are the tools that help us extend human intention.
Rohit Gandikota: Humans, in general, have a need.
Rohit Gandikota: of showing their intention, or, like, to make something happen in reality. And the tools that really make that
Rohit Gandikota: Happen are the ones that happen to be used widely in the history.
Rohit Gandikota: So, with language models, All this intention came at free cost.
Rohit Gandikota: like, free cost, right? What that means is when you ask a model to do something for you.
Rohit Gandikota: It's going to give a very nice description of, oh, sure, I'm gonna, like, write a warm email, which is super funny, and you can see its intention right in the live, that it's trying to… what it's trying to write, and you can see its output and sort of understand every word that it wrote.
Rohit Gandikota: Right?
Rohit Gandikota: And this intention of the model can be easily manipulated, either by token forcing, which a lot of people here know about already. You can go and change its reasoning.
Rohit Gandikota: Or you can literally ask it to say, no, no, no, I want to, like, do something else, make… make… make it more funny.
Rohit Gandikota: And another thing is you can literally go copy, paste it, and change every word there is, and still be confident that it's still text, eligible text. All of this comes at free cost, because text in itself, as a modality, is very easy to understand and reason…
Rohit Gandikota: And also easy to edit the intentions behind text.
Rohit Gandikota: So, yeah, you can do all of this, and then the model can do the job for you.
Rohit Gandikota: Vision, on the other hand, Does not have this.
Rohit Gandikota: So what I mean by that, in the recent history of vision, the problems that we all mostly cared about had a very
Rohit Gandikota: Universal ground truth, right?
Rohit Gandikota: So they all have these accuracy metrics that, if the model can get it right, then you don't really worry about what the intention of you as a user is. As long as its accuracy is 100% or 99, you're good.
Rohit Gandikota: And what does it even mean to have an intention and accuracy model, right? As a user, you don't have a need to show intention. It's a universal truth.
Rohit Gandikota: But for the first time, again, in a loose way, I'm talking about this. For the first time, we have a problem in vision which doesn't have a ground truth.
Rohit Gandikota: Right? We don't know what the true image should look like. It can be anything, and this is the first time we had a bandwidth as a user to show our intention.
Rohit Gandikota: So, what's the problem now?
Rohit Gandikota: What is it that we are trying to optimize here?
Rohit Gandikota: And for a long time, it's been about, let's try to improve the reality or realism of these models. And sure, that's been the problem.
Rohit Gandikota: So, over the years, we have definitely improved.
Rohit Gandikota: the way the realism works, and today, I don't know if… can you tell if that's a generated image? I couldn't.
Rohit Gandikota: And that's… I just generated it last night from Imagine 4.
Rohit Gandikota: So, I think we did. We did solve the realism problem.
Rohit Gandikota: And… And I think that's where most of the conversations end, in terms of Yeah, we've solved it.
Rohit Gandikota: We've trained models that can sort of
Rohit Gandikota: take an image, give any sort of output. Very realistically, it can take any text, generate any text, realistically.
Rohit Gandikota: And… Most of the problems are solved.
Rohit Gandikota: Type?
Rohit Gandikota: So, if we come back to the actual usability of it, as a user.
Rohit Gandikota: When you type in a prompt, there's a bunch of neural activations happening, and you generate this image.
Rohit Gandikota: What if you want to change one small thing?
Rohit Gandikota: Like in your text. Change a word.
Rohit Gandikota: Right? I just… I don't like bass, I want a guitar or an electric guitar there.
Rohit Gandikota: How do I do it?
Rohit Gandikota: I have no idea. It's… nothing is in a legible text. I cannot read whatever is happening inside the model.
Rohit Gandikota: The output is a continuous space. You can't go in and change a pixel and let it… it's not an image anymore. So, it's almost as opaque.
Rohit Gandikota: Starting from scratch.
Rohit Gandikota: So… I think now the real problem becomes that there are
Rohit Gandikota: Millions, or at least billions of invisible decisions that the model takes internally.
Rohit Gandikota: For the one short prompt that you gave, And it outputs
Rohit Gandikota: an image that's literally uneditable by human hand. Like, not just… you can't just go and type a pixel number in there.
Rohit Gandikota: So, what I really hope is happening inside is, given a particular prompt, the model is taking multiple plannings and decisions internally.
Rohit Gandikota: Right? First, it plans the layout as to what it should draw where, and then for each of the small concepts it is decided to draw, it has to expand how that particular concept should look like, and then eventually generates the image.
Rohit Gandikota: I really hope this is what it does, right? If it's doing this, then your… the question of intention becomes such an easier problem.
Rohit Gandikota: Right? You want to replace a bass guitar, you know exactly where the model took a decision, you change that guitar, right? If you want to move the moon to the right, you know where it is that it took the decision, just go change that.
Rohit Gandikota: It would have been nice if this is possible, but it's not, because I don't know if that's what the model is doing. It's supposed to be doing all of this internally, maybe it is, maybe it's not.
Rohit Gandikota: Right? So… I think… That's the current problem, which sort of opens up vision now.
Rohit Gandikota: Back to being at square… square one.
Rohit Gandikota: We don't know what the model is doing inside. There's no way for you to touch the model and edit it.
Rohit Gandikota: Especially in vision, because language gives you an illusion of knowing what the intention is, and if my mother is using it and I'm using it at the same time, then I know for sure that it's a widely used tool, right?
Rohit Gandikota: And I don't think none of you in this room have ever touched how, like, Luma AI works, or how Nano Banana can be edited using different text prompts.
Rohit Gandikota: And…
Rohit Gandikota: For that to happen in the first place, we need to open up the model and try to understand how it works in the first place.
Rohit Gandikota: So… So what does it take for us to…
Rohit Gandikota: make this possible is first, I think, foremost.
Rohit Gandikota: Does it even have a structure? Does it have these decisions that the model is taking internally?
Rohit Gandikota: First, we should expose this.
Rohit Gandikota: And then…
Rohit Gandikota: Hopefully, that can be controllable, so that users can control the structure and decisions that the model is taking.
Rohit Gandikota: And then, unlike language, where you can just say, what else can I learn about this? You can't ask a visual model, because it's very hard to
Rohit Gandikota: talk to a vision model in that way. So, hopefully, discover the concepts that the model has learned and the underlying structure underneath.
Rohit Gandikota: And finally, after you get all of this together, find a means of communication between the model and you as a user, so that you make this happen.
Rohit Gandikota: In the first place.
Rohit Gandikota: So… Let's talk about exposing the structure first.
Rohit Gandikota: Earlier, in the very beginning days of diffusion models.
Rohit Gandikota: When realism started to become a reality, we're like, oh yeah, we can, like, over a few years of research, we know we'll get to a reality point.
Rohit Gandikota: People were really concerned about some of the concepts that the model are generating, which is not ideal for anyone, not the lawmakers, nor the people who are hosting the models, nor the users who are using it.
Rohit Gandikota: So we needed a way to sort of fix this.
Rohit Gandikota: And the best available solutions we had back in the day were, let's just sensor the outputs that we don't like.
Rohit Gandikota: Right?
Rohit Gandikota: the way that this happens, I think even today, most of the models do it, which is you generate an image.
Rohit Gandikota: Post-generation, there is a checker that checks, oh, does it have nudity? If yes, I'll not show it to the user.
Rohit Gandikota: Right? And there's a lot of research, including, like, white hat… white hat researchers, who try to overcome the census,
Rohit Gandikota: In the, in the, in the… in the backend pipeline.
Rohit Gandikota: And another solution is to completely retrain from scratch, remove all the training data that you have, which you don't want in the first place, but it's super costly, right? Like, if you want to train a new model, it'll take millions of dollars and lots of GPUs to train this.
Rohit Gandikota: So, a neat way to put this is, imagine that you are in a beach, and you sort… you hide a gold coin somewhere.
Rohit Gandikota: And now that becomes a whole beach where there's a possibility that a coin exists.
Rohit Gandikota: And what we are trying to do is let's rebuild the entire beach from scratch where we don't have a coin. I think that's…
Rohit Gandikota: almost silly to sort of think about it in the first place. But another thing you can do is just take a coin detector or a metal detector, check around, and keep digging till that detector stops beeping.
Rohit Gandikota: Right? I think this detector is what is called
Rohit Gandikota: the structural… the structure finding method, right? If there is a structure like that underneath.
Rohit Gandikota: We should be able to detect it and remove it precisely from the model's knowledge.
Rohit Gandikota: So that's exactly what we tried to propose, which is, if that was a training data and pre-training model.
Rohit Gandikota: We want a model that unlearns this knowledge without having to retrain.
Rohit Gandikota: So the better solution is first expose that there is an underlying knowledge, and then we remove it precisely from the model's internals.
Rohit Gandikota: So, coming back to our original prop, like, original,
Rohit Gandikota: generation here, what's happening is this model is taking a text prompt C as an input.
Rohit Gandikota: And it's giving an image X as an output. This is what a generator looks like.
Rohit Gandikota: And the classifier which we are really looking for, the structure-finding tool, is actually…
Rohit Gandikota: Something that should take an image as an import and predict if it has the class in it or not.
Rohit Gandikota: Right? And specifically, it needs to detect the underlying data structure, which you don't know, so you don't have this classifier in the first place.
Rohit Gandikota: Right? You're trying to find a classification model from a model you never understand in the first place.
Rohit Gandikota: Turns out, a lot of years ago, there's someone called Bass, I think, who came up with this nice equation.
Rohit Gandikota: Which essentially turns this classification problem back to your generation paradigm, where you can just, condition your model with the prompt that you don't want, and just an unconditional empty prompt, and you can bring the classifier proxy out of your own network.
Rohit Gandikota: And to really get that unlearned model, all you need to do is to keep your original
Rohit Gandikota: Original structure intact, except just ablate or remove the probability.
Rohit Gandikota: that your model generates the image that belongs to the class you don't want in the first place. So, let's say you want to remove the concept of moon.
Rohit Gandikota: So, all you have to do… oh yeah, you can replace the classifier.
Rohit Gandikota: And then all you have to do is run two prompts through your model. One is a prompt that you want to be removed, the concept, which is moon.
Rohit Gandikota: And 2 is just an empty prompt. And you can… you can do this neat equation here, which we can go into the detail later.
Rohit Gandikota: And then, if your original model was generating Moon, even though it doesn't have it in the first place, you can train your network using this equation.
Rohit Gandikota: And then… Yeah, it just stops generating more.
Rohit Gandikota: So, what this is, is that There is an underlying structure.
Rohit Gandikota: Which you can easily detect using the model itself as a beacon, look for where the knowledge is, and precisely edit it out.
Rohit Gandikota: So, there were… This… this is, like, a rough diagram taken from David's slide.
Rohit Gandikota: Where, the model
Rohit Gandikota: has multiple different, modalities that it takes as an input. First, you have a text input through which you are prompting your model.
Rohit Gandikota: So it goes through something called a cross-attention.
Rohit Gandikota: And then you have your original unit, which is what is actually generating the image in the first place.
Rohit Gandikota: So, you can remove or detect for this knowledge from any of these locations, and each of them have their own impact.
Rohit Gandikota: For instance, If you want to remove the knowledge.
Rohit Gandikota: completely the visual knowledge of the model. You have to look for this, for this structure inside the vision aspect of the model.
Rohit Gandikota: which is what we call ESDU, which is everything except the text side of things.
Rohit Gandikota: And if you precisely want to remove the knowledge only when it is being asked for, queried for, for example, some artist
Rohit Gandikota: style painting. It's usually queried through their own name.
Rohit Gandikota: So, if you want to be more precise, you can go and just ablate that structure from the tech side of things.
Rohit Gandikota: And turns out, it also matters where it is that you are looking for in this… for the structure in the model, and it has an… its own impact as to how deep of a knowledge that you are removing or tapping into.
Rohit Gandikota: So, yeah, so that method definitely erases the things that we don't want, but I don't think that's the whole picture when it comes to editing a model.
Rohit Gandikota: I can randomize the entire network and still say, yeah, it removed everything, it removed the entire knowledge of vision.
Rohit Gandikota: But then, the thing that is really important is that the model is still intact for the rest of the concepts around it.
Rohit Gandikota: Right? You need to be more precise about what it is that you are removing. Only then will I be able to call it that, yeah, I found structure.
Rohit Gandikota: So…
Rohit Gandikota: Turns out, if you ablate your knowledge from the cross-attentions, you have much more precise representations of your structure compared to removing it from the visual side of things.
Rohit Gandikota: And this was a very nice observation that we had.
Rohit Gandikota: And which led to a follow-up with Hadas and Janetan.
Rohit Gandikota: Where we directly just attack the cross-attention layers.
Rohit Gandikota: And then find the structure within using Flowsform solutions.
Rohit Gandikota: So, this… once we found that, sure, there is a structure in it.
Rohit Gandikota: Can we really control this structure, is the next question, right? We surely removed it. I would call that some form of control.
Rohit Gandikota: But can I precisely more have a continuous control over this layer?
Rohit Gandikota: Turns out, yes, you can very simply take the exact structure-finding method from the previous work.
Rohit Gandikota: And linearly control it in a way that it has a continuous effect on your model.
Rohit Gandikota: For example, if I were to bring all of the fine-tuning that I did for unlearning the model into a small set of parameters as a module.
Rohit Gandikota: It does remove the beard, like, so that unlearn's beard.
Rohit Gandikota: But you can also control the intensity of it, and it controls how much beard is removed from the model's knowledge.
Rohit Gandikota: Which is great. So, it sort of tells that, inherently, the parameters that capture structure also has, like, a smooth, controlling definition for them.
Rohit Gandikota: And the nice part about it is when you can erase something, you can do the total opposite and add something. So you can add a smile, you can add glasses, and sort of get a very nice dimension of control over your outputs.
Rohit Gandikota: Just by finding structure inside there.
Rohit Gandikota: And this is not doing anything completely new.
Rohit Gandikota: What we did is we took
Rohit Gandikota: The erasing formulation, and also added an enhancing formulation to it.
Rohit Gandikota: And found ways to control this knowledge linearly in the parameter space, or in the weight space.
Rohit Gandikota: So, what I do is I take the person vector and try to move towards the old direction and away from the young direction.
Rohit Gandikota: And that's exactly what this erasing Parameter module is doing.
Rohit Gandikota: So, now what happens is that you can, just using text.
Rohit Gandikota: As methods to find your structure.
Rohit Gandikota: You can simply control the model's internal knowledge.
Rohit Gandikota: Right? So, all I use is curly hair.
Rohit Gandikota: As a prompt to find the structure, and we can control it inside the model.
Rohit Gandikota: So, yeah, there are multiple dimensions you can control, and these are also composable on top of each other, so I can keep composing more and more structure on top, so I can make them have glasses, plus old, plus smiling, and you can keep adding.
Rohit Gandikota: Up to 200 sliders is what we've tested.
Rohit Gandikota: And now we can test more.
Rohit Gandikota: But more specifically, this enables you to have a multidimensional control over your images. This is, like, imagine being in a…
Rohit Gandikota: like, 1990s, maybe, when you have a game engine where you can create your own character. You had multiple sliders you can work with, sort of create a character which you really like.
Rohit Gandikota: This sort of, composable sliding techniques will allow you to do this now.
Rohit Gandikota: So… And funnily, we also found
Rohit Gandikota: Structure inside the models that will self-repair its own outputs.
Rohit Gandikota: All we did was ask the model to be more realistic.
Rohit Gandikota: And just made the model's structure move towards being more realistic. And it automatically started fixing its own outputs whenever it was breaking the physics.
Rohit Gandikota: or just drawing very bad bicycles. It just corrects itself and creates much better-looking images.
Rohit Gandikota: And originally, we thought that this was a problem of additional training or adding more guidance.
Rohit Gandikota: Turns out this was just a structural issue, you can just fix the structure if you can find it.
Rohit Gandikota: And this is another nice throwback to, I think, 2023, when your images were not able to generate nice hands.
Rohit Gandikota: Yeah, you can fix them. And it was… it was,
Rohit Gandikota: It was mind-blowing for everyone who looked at this at that time. Now it's…
Rohit Gandikota: Every model can do this now.
Rohit Gandikota: So, okay. So, coming back to this, if you can find a structure and control it, I think this in itself will open up a lot of possibility for you to do explorations of this model and show your intent.
Rohit Gandikota: And turns out, this did catch a lot of attention in the community.
Rohit Gandikota: So when we open source this method, we've immediately seen a burst of open source artists, like, training their own sliders with their own creative imaginations, and releasing it for the public to use.
Rohit Gandikota: And this enabled, I think, a good amount of research within the stable diffusion community to work more on these controllable methods.
Rohit Gandikota: For… for enhancing the user's intention.
Rohit Gandikota: And I think this was… I don't want to talk too much about it, but this was kind of the chat GPT movement, I guess, I hope.
Rohit Gandikota: Where, like, users were finally able to see that, sure, I can use
Rohit Gandikota: these models to do something which I want.
Rohit Gandikota: So…
Rohit Gandikota: We've talked about this, where as long as your models can't talk to you, it becomes really hard for you to use the models beyond what your own imagination is.
Rohit Gandikota: Right? For instance, let's say I've trained a model which is super realistic and does a lot of things, and my knowledge is that small circle over there. That's all I can explore using the concept sliders that I just showed you, because that's the extent at which I can prompt the model with.
Rohit Gandikota: Right? And hoping that I can bring a lot of humans into this crowdsourcing work.
Rohit Gandikota: And allowing their creativity to be open source.
Rohit Gandikota: maybe I can extend the concept slider limitations to that area of its knowledge.
Rohit Gandikota: But what about this area, where
Rohit Gandikota: Where the model learns a lot of things during pre-training, but it can't say what it has learned, because that's not the way it was trained in the first place. Unlike language, I think language can…
Rohit Gandikota: It gives an illusion of saying, yeah, yeah, sure, you should learn more about this.
Rohit Gandikota: There's more to learn beyond this.
Rohit Gandikota: So, how is it to explore that, and why not just ask the model to talk about its
Rohit Gandikota: Own internals, so that you don't have to be limited by your own potential.
Rohit Gandikota: So, what we do as a first step is we try to ask the model to generate a lot of images using the prompt that I want to explore.
Rohit Gandikota: And then simply just decompose its outputs, And find a slider direction.
Rohit Gandikota: Inside its weights, that would sort of pledge to one of these
Rohit Gandikota: decompose directions. What it says is, basically, I'm trying to look For the models.
Rohit Gandikota: internal, principal components about this particular concept that I'm very interested in.
Rohit Gandikota: And this is completely unsupervised, so when I say Van Gogh art, I would get how many of our PCR directions I do, like, let's say 300… 300 directions that might be relevant to Van Gogh.
Rohit Gandikota: Which I personally would not be able to bring up in the first place. So let me show you some examples.
Rohit Gandikota: So this is the best I could prompt for monsters. It looks pretty generic, it's the same, probably, monster coming up again and again.
Rohit Gandikota: But once you open up these models, internals, and look for directions that the model can draw, you start getting all these different weird-looking monsters, which I… I don't have an answer for. I don't know what… this… this,
Rohit Gandikota: The captions that you see here are…
Rohit Gandikota: are generated, like, post-discovery using Claude.
Rohit Gandikota: So, most of them don't even match. I don't think this is Blue Bestion, that's the best Claude could do.
Rohit Gandikota: To make sense out of that direction.
Rohit Gandikota: But essentially, what my point is, is that you can start exploring features that you originally would not have
Rohit Gandikota: Thought of in the first place to prompt.
Rohit Gandikota: And again, since we got them out as form of sliders, you can smoothly control, and this, again, opens up multiple dimensions of control, except
Rohit Gandikota: This is creative, territory where you don't know that they existed in the first place, and you're just exploring the module.
Rohit Gandikota: I'm… the example that I… I'm really interested and excited about is us exploring art styles inside the model.
Rohit Gandikota: So, art is a very studied concept.
Rohit Gandikota: In the world, of course, and especially in generative AI.
Rohit Gandikota: So when we…
Rohit Gandikota: decompose the artistic styles inside… like, inside the diffusion models. We found directions which are not human… which are not one-to-one human corresponding, but these are sort of principal directions.
Rohit Gandikota: That the model has learned to encode every human artist that it knows of.
Rohit Gandikota: And what, essentially, like, originally, the human studies were done in the past to understand what artistic styles that the model could
Rohit Gandikota: Replicate.
Rohit Gandikota: And then it took almost 8,000…
Rohit Gandikota: 250 artists, 7 months of their time, to come up with a list of 8,000 artists that the model can mimic.
Rohit Gandikota: Right? So…
Rohit Gandikota: Now, you can literally explore this space using a single prompt, and maybe 2 hours on a GPU.
Rohit Gandikota: And get most of the relevant slider or, like, artistic directions out of these models.
Rohit Gandikota: So… Those are all the realistic artists, like, the real artists and their art.
Rohit Gandikota: And you can always argue that, why do I need this exploration in the first place, right? You can simply use generic prompts, like, create an artist, artistic-style image.
Rohit Gandikota: And then the model generates these bunch of images, which all look pretty generic.
Rohit Gandikota: And the distance between the original distribution and the model-generated distribution is quite high.
Rohit Gandikota: Right? And you can also say, hey, I'm in the era of language models, I'll ask the language model to prompt diverse artistic styles.
Rohit Gandikota: And that should do the trick. Why should I explore… why should I ask the model itself to talk about it? You can, and it definitely covers a lot of distance. It's almost, like, half the distance now. You're much closer.
Rohit Gandikota: And using these LLM prompts, we also do concept sliders.
Rohit Gandikota: And then, sure, they are very close to each other, but when you really ask the model to explore and provide its own knowledge, then you see that it covers a lot of knowledge gap between the true distribution and what we have in our hands in the first place.
Rohit Gandikota: So… -Oh.
Rohit Gandikota: Yes.
Rohit Gandikota: And this is, a response to what a… so slider space essentially is restricting you again.
Rohit Gandikota: Where you have to be the first person to seed what it is that you're looking for.
Rohit Gandikota: What we did with this visualization is we took a concept of art.
Rohit Gandikota: And then started exploring within slider space again and again through an iteration.
Rohit Gandikota: Right? So what that means is you can click on any art, and it'll show you every nearby sliders around it, and you can control this space and explore it in a much interactive way.
Rohit Gandikota: This takes a lot of time, so I… I pre-generated a lot of styles, and I'm showing you as a…
Rohit Gandikota: As a demo here.
Rohit Gandikota: But yeah, it got to a place which I would never have imagined in the first place, at least with my creative brain.
Rohit Gandikota: So, okay. We have found a way to discover it. Finally.
Rohit Gandikota: Coming back to this communication part.
Rohit Gandikota: Where, when you ask something, the model is doing a lot of planning and generating an image.
Rohit Gandikota: So, as a…
Rohit Gandikota: As a user, I would want to understand what is the decision that the model made, and I want to communicate with that decision.
Rohit Gandikota: For instance, I want to look at that particular, this particular person that it drew there, and I think that is the decision that is more relevant for this particular generation.
Rohit Gandikota: So how is it, can I tap into this decision-making boundary, and how can I communicate with it, so that I can draw the same person chilling in a beach?
Rohit Gandikota: Right? It becomes a really hard problem when… when you want to now go into the model's decisions and internal decision space.
Rohit Gandikota: So, a quick intro to how the model that I'm working on looks like. So, it's… it's called Flux. It has two streams, an image and text.
Rohit Gandikota: So both of them are processed together. You start from a noise, and then you do multiple layers.
Rohit Gandikota: Of the same block. You also have, like, some fancy, conditioning called time step and guidance. They all go into this flux block.
Rohit Gandikota: Finally, it generates an image.
Rohit Gandikota: From the image stream, but then you discard the text stream, because you don't need text when you're talking about image generation.
Rohit Gandikota: Right? This is how the model is trained, where it takes a noise, does a dual stream,
Rohit Gandikota: processing, and then you only take the image stream of things, decode it, and just discard that final. There's no optimization done on this text stream.
Rohit Gandikota: So, what we found is that, what if we can use this rich information that the model has learned.
Rohit Gandikota: And discard the image side of things.
Rohit Gandikota: And look what the text has learned. And what can we do with that text.
Rohit Gandikota: So…
Rohit Gandikota: That's exactly what we do. We give the reference image that the model has generated to the same model again.
Rohit Gandikota: And then…
Rohit Gandikota: Instead of touching the concept that you want as a haptic, you can literally just say a layperson on the left playing bass.
Rohit Gandikota: So now, we know that the leaf person belongs to that
Rohit Gandikota: person on the left, through captioning. I'm sort of capturing what it is that I'm really interested in.
Rohit Gandikota: And when I use the same prompt, a leaf person chilling on a beach, the regular diffusion model draws this.
Rohit Gandikota: And it's not that person, of course. Why would it?
Rohit Gandikota: Except, I can take these… the vectors that come out of this magic network, which I'll talk about
Rohit Gandikota: In a few seconds, and take the information that it has learned and plug it into my generative model.
Rohit Gandikota: And then agenda instead.
Rohit Gandikota: Right? You can… you can… You can bring…
Rohit Gandikota: You can tap into the internal decisions that the model makes.
Rohit Gandikota: And bring it into your own generations, and play around with it.
Rohit Gandikota: So…
Rohit Gandikota: The way it was trained is that the feedforward network, we show the image and the caption that it takes.
Rohit Gandikota: And it generates this, what I call, like, decision vectors, or customization vectors, for each of the text prompt there is, so that if you're interested in the dog, you can take the vector of the dog token.
Rohit Gandikota: If you're interested in the background, you can take that token. At least it gives you a range of communication bandwidth.
Rohit Gandikota: Of how… what it is that you want to customize, or bring, or what decision it is you want to capture.
Rohit Gandikota: I use the same reference prompt as my generation.
Rohit Gandikota: So if the original diffusion model is generating some other image, I just ask it to generate the same image when all the tokens are employed. So essentially, I'm training this model.
Rohit Gandikota: to say, whatever it is that you're generating from your vectors, word to word, they have to represent some delta towards the concept that I'm really interested in.
Rohit Gandikota: Right? There'll be questions, I'm sure. I'm happy to answer them. If this… if you're absolutely lost, please let me know.
Rohit Gandikota: So yeah, it's a simple MSC that we do, and then there is no other additional,
Rohit Gandikota: captioning or annotations that we are doing, it's a simple text-image captions.
Rohit Gandikota: And using this.
Rohit Gandikota: a single paradigm. We basically learn the true language of whatever is happening inside and the decisions that the models are making.
Rohit Gandikota: So, yeah, we collected 2 million images and trained this general-purpose network that does this.
Rohit Gandikota: So now, what you can do is you can have a bunch of reference images that you want your concept to come from.
Rohit Gandikota: and have a reference prompt to show what it is that you want to pick the concept from, right? So, I'll explain
Rohit Gandikota: these things.
Rohit Gandikota: So these… this is the inference prompt. I said, a dog sitting on a sofa.
Rohit Gandikota: And the original model generates diverse Not so diverse, but…
Rohit Gandikota: very different looking dogs, right? Except, now I can…
Rohit Gandikota: Give this to my feed-forward model.
Rohit Gandikota: And bring in the delta vectors from the dog token, and
Rohit Gandikota: And plug it into this original seeds.
Rohit Gandikota: And then, immediately, the model starts drawing the dog.
Rohit Gandikota: That's in the reference image. So it's essentially, I'm picking the concept and dropping it into my
Rohit Gandikota: Diffusion model.
Rohit Gandikota: And, yeah, it… you can see that for different dogs, it brings all the different dogs.
Rohit Gandikota: From the reference image and puts it into your generations.
Rohit Gandikota: Oh, I had animation.
Rohit Gandikota: Yes.
Rohit Gandikota: Okay.
Rohit Gandikota: So, till here, this is mostly about what I've done so far.
Rohit Gandikota: And I think I could… oh.
Rohit Gandikota: 30 minutes, that's nice.
Rohit Gandikota: So… In summary, what I've taken you through is that
Rohit Gandikota: We never had a way to… Verify their structure.
Rohit Gandikota: We did. Now, we find that there is structure inside these models. You can control the structure. It's also discoverable. There are… it's just the first step, and there are many follow-ups that sort of worked on top of this to make it more discoverable.
Rohit Gandikota: And you can now communicate with the internal decisions that the model do.
Rohit Gandikota: With this in hand, I'll show you what you can do now in the current
Rohit Gandikota: today, with vision models, right? So…
Rohit Gandikota: You ask for a photo of a woman.
Rohit Gandikota: Seated on a couch at a cafe, and it draws this image.
Rohit Gandikota: Think she's too serious, so I can add a smile.
Rohit Gandikota: And then that makes the women smile now.
Rohit Gandikota: Right? You can say, no, no, no, I want that couch from my favorite TV show.
Rohit Gandikota: and say, I want the woman to be sitting on that, It brings the couch.
Rohit Gandikota: Right? You can also say, yeah, I think I want, like, some funky new hairstyle, but I don't know what it is. Let me ask the model what all hairstyles it has in its…
Rohit Gandikota: directory, and then I can choose style number 23 that the model gave me.
Rohit Gandikota: And then it draws this. So, now you…
Rohit Gandikota: It opens up to a new form of exploring the model and working with them, and finally, it, like, gives you some room to show your intention as a user and what you can do in the first place.
Rohit Gandikota: Okay, this slide took me… 3 weeks to do it.
Rohit Gandikota: Fair.
Rohit Gandikota: I can show intent in 3 weeks.
Rohit Gandikota: But is this the real fix? I think now comes… the main,
Rohit Gandikota: Good, solid 10 minutes portion of the talk.
Rohit Gandikota: I don't think this is a real fix, especially because these are all post hoc methods.
Rohit Gandikota: We are training the models. It's very similar to what you in the lab are doing with language models. There's one stream of researchers who are really pushing to go towards
Rohit Gandikota: the top 1% AI model that can solve RKGI3, 3.5, 5, whatever. And then there are us who's trying to be, oh, let me understand this, I don't know what's happening here. By the time I understood GPT-2,
Rohit Gandikota: there's now GPT-10, right? So we… we are playing this cat and mouse game.
Rohit Gandikota: And… I… I don't want to be, way too optimistic with language, but with vision at least.
Rohit Gandikota: It's absolutely necessary that we understand the models for them to be even workable in the first place.
Rohit Gandikota: Right? I showed you a lot of slides earlier, which took 4 years of research to get it to a phase where I can show you one slide.
Rohit Gandikota: Where I have to work for 3 weeks, myself, who built these methods.
Rohit Gandikota: Right? And I don't think that's no way close to being a tool that'll help you show your intention.
Rohit Gandikota: So, I think… The real fix has to be in, like, multiple ways.
Rohit Gandikota: Which always comes back to the same question as to what will make vision the tool that will be widely used in the future. And it's the same thing, which is, I think we'll have to focus on the intention of humans, and…
Rohit Gandikota: How do we enable that to happen in the first place? And it's not an input-output game. I think we should, like, start moving away from it.
Rohit Gandikota: Where we are not trying to optimize towards what's the image arena number one model.
Rohit Gandikota: so, okay, so the first thing is, I think.
Rohit Gandikota: Visual generation and interpretability needs to go hand in hand.
Rohit Gandikota: Right? What I mean by that is…
Rohit Gandikota: when I started thinking about this, it's an upcoming work-in-progress project.
Rohit Gandikota: me and David were talking about, oh, how do we bring this into reality? What is it? And then the first question I wanted to ask was, what format should I choose?
Rohit Gandikota: To start this problem.
Rohit Gandikota: Right? I think, obviously, the answer is video, right?
Rohit Gandikota: Because it has image, it has time, but then 3D is also nice, because you can
Rohit Gandikota: Look at multiple views.
Rohit Gandikota: I think world modeling is also nice. You can, like, explore the space.
Rohit Gandikota: And the more I thought about this, not for a project perspective, but from a,
Rohit Gandikota: From a visual… vision perspective, is that I think every format enables a new kind of
Rohit Gandikota: intention in users. And I think that's why all of them are, in their own ways, very popular.
Rohit Gandikota: Right? World modeling is really popular because you get to explore it, you can play with it, you can say, go forward, go back, turn left, turn right. 3D modeling can show you different perspectives of the same image.
Rohit Gandikota: SVGs, on the other hand, are very human-readable. You can read the code that SVGs are built on top of.
Rohit Gandikota: images are really realistic. So there's signal processing, you can control sliders in Adobe Premium Photoshop.
Rohit Gandikota: And all of them, in their own ways, bring some sort of signal into your intention. And it… that… I think that's why they're…
Rohit Gandikota: Popular in their own way.
Rohit Gandikota: So… Ideally, this is the work in progress, where what we want to do is
Rohit Gandikota: Every time a user types a prompt to generate an image, it's always heavily underspecified. Nobody is going to sit there and write a book
Rohit Gandikota: Of a prompt.
Rohit Gandikota: to generate exactly what they want in their image, right? That's…
Rohit Gandikota: I think unreasonable to us from a user.
Rohit Gandikota: Which is why the model internally is expanding so many different things, having to do all this planning in the first place. So, what if we bring that outside the generation process?
Rohit Gandikota: Right? And let the generative model just be a renderer, which has always been how vision was working.
Rohit Gandikota: From a long time ago, right? So, if I were to have this planner that would plan everything out.
Rohit Gandikota: Ideally in human-legible text, or code, or anything, any other format.
Rohit Gandikota: That would let us, as users, understand what the model is deciding to draw.
Rohit Gandikota: And then have this renderer, whose job is literally just to render the image.
Rohit Gandikota: Right? That way, you can edit your planning that the model has planned, and see that edited in real time, or
Rohit Gandikota: Or at least in the right way, where you can have 3D control over your objects, and, like, have your objects rotated in any way you want.
Rohit Gandikota: And…
Rohit Gandikota: To actually make this more useful, you would also want something in a cyclic way, where it'll look at your image and will be able to give the plan that requires to be, to render that image back.
Rohit Gandikota: Right?
Rohit Gandikota: So, every aspect of this brings some sort of intention from every modality that we have seen earlier, right? Your planner needs to know about 3D and world modeling so that it can exactly look
Rohit Gandikota: at different angles, plan for different angles. Your renderer is almost like an SVG that takes a code and generates a realistic output, other than, like.
Rohit Gandikota: That looks like SVG.
Rohit Gandikota: And your parser needs to know a lot of signal processing to understand what image it's looking at, what contrast and composure that it has to do to generate the image back.
Rohit Gandikota: And…
Rohit Gandikota: I think a good news is that it enables wipe coding too, right? This is a big chunk of new language, and you can literally seek a lot of
Rohit Gandikota: Agents on top of it, and talk to your image, and enable the editing.
Rohit Gandikota: Through vibe coding, or maybe vibe image, right? I'm the first to claim it.
Rohit Gandikota: And current modern-day vision models are doing all of this packed into one single model.
Rohit Gandikota: And all that we have been trying to do as,
Rohit Gandikota: interp researchers, or controllability researchers, have been trying to guess that this is what is happening, and going and trying to control them internally. And I don't know if that's what I'm capturing. I just gave you a story that that is what is happening. I still can't…
Rohit Gandikota: Guarantee that that's what is happening.
Rohit Gandikota: But I think it's time to break that.
Rohit Gandikota: and have…
Rohit Gandikota: Interp to come out of the model that there is, and make this more usable for… and also, like, give the user an illusion
Rohit Gandikota: that they understand exactly what's happening inside the model, right? I… there… this opens up a lot of other avenues. What is this planner internally doing? We don't know. What is the renderer doing? We don't know. But at least this sort of opens up a way for users to show their intention.
Rohit Gandikota: Right? Pushing these models to be more widely used tools.
Rohit Gandikota: And the more… I started making that slide, the second thing came out.
Rohit Gandikota: every time I show how reasoning works inside language model, it's always language. Sorry, inside vision model, it's always language.
Rohit Gandikota: But how would a visual… Reasoning medium look like?
Rohit Gandikota: This is slightly half-baked. I'm still not sure what it should look like. I think this can be a…
Rohit Gandikota: big, research area on its own, but I feel like every vision person I can talk to will definitely vouch for this.
Rohit Gandikota: That image medium on its own brings a lot more information that text can't bring.
Rohit Gandikota: Right?
Rohit Gandikota: Or can bring, but it would take
Rohit Gandikota: Like, unreasonably large amount of text to bring it.
Rohit Gandikota: So, I feel like having some sort of visual reasoning… visual medium reasoning inside the model would obviously be, much more efficient for us to have this sort of… and also, like.
Rohit Gandikota: human usability.
Rohit Gandikota: When it comes to generating these images. Like, for instance, if I want… like, the model might be planning inside that, oh, should I place the dot behind a layer 1 of the tree, or layer 2 of the tree? All of these things are hard to teach to the model
Rohit Gandikota: Via text, and I think there has to be some form of visual reasoning happening inside.
Rohit Gandikota: And finally, okay, so I have brought you into this room by promising that
Rohit Gandikota: Oh, vision is going towards a dead end, and I have the solution to fix it.
Rohit Gandikota: But I have silently been holding back some information. I do hope that generation on its own, visual generation on its own, comes to some natural endpoint.
Rohit Gandikota: Right? Where visual generation is not a standing research area where people are working on it for a long time.
Rohit Gandikota: What I mean by that is, I think vision on its own
Rohit Gandikota: Has to be changed into something which is readable, or which is easily explorable by us humans.
Rohit Gandikota: every time we look at an image, it's… it becomes, like, such a novelty thing that I look at this nebula, and I'm like, wow, this is so nice. But that's pretty much it. I can't explore what's happening inside that image, I don't know what the image is made of, what's the reasoning happening behind it. For that to…
Rohit Gandikota: For me to understand that, I need to go to internet, search, read the text behind it.
Rohit Gandikota: Maybe make sense out of what that nebula is.
Rohit Gandikota: Right? And…
Rohit Gandikota: what I'm really hoping for is vision generation becomes a very small part of us understanding how the visual world works in the first place.
Rohit Gandikota: Right? Where you can finally look at this nebula and say, hey, I want to look at it from a different angle. And then your agent goes to internet, brings multiple images, and forms a 3D rendering on its own internally.
Rohit Gandikota: And you can go explore that space. You can click into that image.
Rohit Gandikota: go beyond what you look in the first place. And I think for this to happen, if this all sounds like a sci-fi, well, of course, language modeling sounded like sci-fi.
Rohit Gandikota: 5, 10 years ago. But I think this…
Rohit Gandikota: like, this is what I really care about. I think…
Rohit Gandikota: I love images, I love visual world, but it always holds you back that you can't explore them, and you can't understand them the way we understand and explore text.
Rohit Gandikota: So I think, eventually, I think that that has to be…
Rohit Gandikota: That is where I would retire, I think.
Rohit Gandikota: So, okay, thank you very much.
Rohit Gandikota: Did you have any questions in the beginning? Yes. Oh, yes. Oh, actually, I have a question for the end. Yes, so I guess, when you talk about, like, I like your last slide, very fascinating, like, for example, like, vision, like, or yeah, I wouldn't say vision, but I would say image generation is not all.
Rohit Gandikota: Because, for example, you can ask questions, they want to see a 3D rendering of stuff.
Rohit Gandikota: I actually feel like for vision… visual exploration or, like, interaction, like.
Rohit Gandikota: what do you think will be a good interface? I feel like that's actually the biggest question, or one of the biggest questions. For language, you know, interface is text. But for images, you can sketch.
Rohit Gandikota: can compose things in layers, we can have sliders, we can have, like, text, you know, there's so many different things you can play with images. Yeah. So I feel like that's actually one of the things that's really hard for the image generation space to converge to. Yep.
Rohit Gandikota: And…
Rohit Gandikota: I'm thinking about, do you think whether we can just have just one model that tackles everything, or it can have, like, different…
Rohit Gandikota: seem to explore things in two different angles? What's your thoughts on that? Yeah, I… So…
Rohit Gandikota: Following the talk that I gave.
Rohit Gandikota: I think definitely it has to be multiple different models coming up and doing the same task as an orchestra, so that at least you have good, resolution to look into what it is each model and, like, is doing.
Rohit Gandikota: But I… I very strongly agree that,
Rohit Gandikota: looking at the technology side of things is one aspect, but the real aspect would eventually become what is the UI?
Rohit Gandikota: That a user is interacting with, right?
Rohit Gandikota: And, with the very narrow view that I have with the slides that I made, I think it
Rohit Gandikota: it becomes something of a hybrid UI.
Rohit Gandikota: Where, given an image, you, as a user, you talk or you type, and then the UI should eventually give you the controls
Rohit Gandikota: dynamically, saying, hey, I want to explore this. Then it gives you, like, arrow keys for you to explore.
Rohit Gandikota: And you say, no, no, no, I actually want to see a 3D view of it, then it gives you a 3D slider to…
Rohit Gandikota: do a 3D rendering of it.
Rohit Gandikota: Essentially where… You feel,
Rohit Gandikota: less friction when it comes to wanting to choose the right tool to do the right thing. I think it should be somehow an intelligent way to
Rohit Gandikota: Feed these, controls.
Rohit Gandikota: Based on your intention, if that makes sense. I see.
Rohit Gandikota: But, yeah, it definitely requires a lot of,
Rohit Gandikota: pretty such, I guess, almost as if, like, for example, one…
Rohit Gandikota: like, recent way I can think about it is just, like, an LM can call, like, a tool use, for example, make its own tool, and then maybe create its own, like, widget. Oh, that'll be nice. Yeah, yeah, why not? Yeah.
Rohit Gandikota: But doesn't it go back to the fact that your intention is more expressable?
Rohit Gandikota: What does that mean?
Rohit Gandikota: So you said, like, that the tool that you're gonna use, or the interface, is based on your intention.
Rohit Gandikota: And then you can prompt.
Rohit Gandikota: something, like, I want to get, like, a 3D view of these, like.
Rohit Gandikota: But you will use text to represent your intention, and then an agent or someone will convert that to, like, the writing. Yeah, yeah, that's a… that's a good point. So I, I,
Rohit Gandikota: I'm not saying text is the only medium to show intent. I'm saying it's a good medium to express your intent.
Rohit Gandikota: But then, when it actually comes to editing or exploring it, it becomes, like, all these multiple dimensions of control, where you're touching the image, like, you're…
Rohit Gandikota: Like, doing some sort of a model walk, or medium walk.
Rohit Gandikota: There are, like, sliders which will give you control as to how much the person is smiling. But for, like, there should be some medium where you say, oh, I think this person needs to smile more, right? But then, it's not just by text, you're saying, no, no, smile more, no, no, no, even more. That's not what you're doing, right? When you say, I want to control the smile.
Rohit Gandikota: And then the model should give you some sort of a new medium to
Rohit Gandikota: Control the intent that you have.
Rohit Gandikota: But it's a good question. I think…
Rohit Gandikota: to start an intention, you need a way to communicate, and right now, I see text as a way to start it. Yeah, I think text is very similar, like, very…
Rohit Gandikota: progressed, and very semantic. Yes, yes. It's like you've got, like, a semantic segmentation map of your image, almost. Yeah. Or something like that. Right.
Rohit Gandikota: But the eventual… Intention needs to go through multiple mediums, not just text.
Rohit Gandikota: And also, like, say, if… The user interface is text, then, like.
Rohit Gandikota: Well, I guess you're proposing something else. Let's say if the user interface is X, then I can easily argue it a little bit. Let's try to be the bad guy.
Rohit Gandikota: I think nowadays people do, like, prompt expansions, all these things, but… Yeah.
Rohit Gandikota: shout out to my friend Red. Yes, yeah, yeah. Yeah, they have all these… after you specify, like, a text prompt, which is, like, not really specified, they'll have the OM call, like, to generate, like, various, like, very detailed text prompts. Yes. They have, like, different types of, like, text, where the users can then edit the text prompt they choose. Absolutely, yeah. But I feel like…
Rohit Gandikota: That's not satisfying enough. Of course, like, text can describe the image so well, but I feel like it's not intuitive enough for humans to say, hey, like, I really want to look into these text prompt and select the very conversive process. Yes. I feel like interface is still, like, a big issue.
Rohit Gandikota: Yeah. I agree. And I also want to clarify, I don't want to remove text from…
Rohit Gandikota: Whatever is happening right now.
Rohit Gandikota: I think it has to be there, like, it can do multiple good things, but it restricts us from doing a lot more beautiful things with images.
Rohit Gandikota: And I'm just saying it might require new ways to interact with them, new mediums of reasoning.
Rohit Gandikota: But yeah, eventually.
Rohit Gandikota: think text will be a way to… hey, like, hey Siri, and then… And we'll get…
Rohit Gandikota: Do you think that understanding model internals is…
Rohit Gandikota: Necessary for providing the user with the control and ability to express and Exercise doing tent.
Rohit Gandikota: or…
Rohit Gandikota: Or maybe scale will solve everything, once… once the big labs collect enough examples of… it doesn't have to be text, but whatever
Rohit Gandikota: whatever representation you use for expressing user intent, they collect enough of these examples, they match them with images, they train one model to do this, and do they still… do you think you're… sort of… your techniques are kind of…
Rohit Gandikota: not all the way back and terp, but they are, you know, looking internally and cleverly selecting where to do interventions. Do you think this is needed, or maybe scale will solve everything? So, that's a very good question.
Rohit Gandikota: And I was asked this question when I gave a similar talk, and…
Rohit Gandikota: So, my response is, we already have a lot of models, like Stable Diffusion Excel, that spent a lot of money to collect different forms of input-output
Rohit Gandikota: data and train those models, like, including Nano Banana now.
Rohit Gandikota: Where you can talk to your images in text.
Rohit Gandikota: And with these models, by understanding
Rohit Gandikota: these, the ways to interact with them more, unlocks
Rohit Gandikota: A slight bit more delta than you would use them when you don't have.
Rohit Gandikota: Right? I'm saying you can use billion dollars to create this one single model that would do most of the things.
Rohit Gandikota: But I think there's always a way to unlock more out of it, if you understand how vision works.
Rohit Gandikota: Like, you can get… you can get more use for your user.
Rohit Gandikota: When you understand what it does, and enable new controls from it. But… I, I, I think…
Rohit Gandikota: Coming to the… the… The next steps.
Rohit Gandikota: that I was suggesting.
Rohit Gandikota: I do want big companies to spend a lot of money and build those kind of methods.
Rohit Gandikota: which would… Which would eventually allow users to see what the model is thinking through.
Rohit Gandikota: And then… have a sense of intention, and that I can change something that the model is thinking of.
Rohit Gandikota: If it is single model, multiple models, I don't think I have a strong opinion yet.
Rohit Gandikota: Because I haven't tested it myself.
Rohit Gandikota: But… It is eventually really, really important that humans feel that they're
Rohit Gandikota: That their intentions are heard, to be cheesy.
Rohit Gandikota: if that… I don't think that happens with vision models, and there has to be some way for you to show what the model is doing, so that
Rohit Gandikota: they have this sense of control over the generations. But do I need to have a way to show what the model is doing internally, or is it enough that…
Rohit Gandikota: I have a way for the user to…
Rohit Gandikota: specify what they want to get. Maybe it's underspecified, and then it's being expanded, whatever. But I have this plan, structured plan, or whatever it is. The model is generating an image.
Rohit Gandikota: It's working, what do I care how it's doing that internally? Yeah, there are models already that do most of the things that, I described. Yeah.
Rohit Gandikota: There's always, like… I think…
Rohit Gandikota: So, from stable diff… I can give you, like, a quick timeline. Stable Diffusion can just do text-to-image.
Rohit Gandikota: And for you to change the image, you have to re-prompt.
Rohit Gandikota: And then Flux came out saying, oh, you can also give an image as an input, so now you can give an image and a text and sort of change it. Nano Barana now said, no, no, you can keep on talking to your image again and again, and based on this context, I'll generate better images.
Rohit Gandikota: With each one of them, I think few problems are solved.
Rohit Gandikota: But it's always this, like, there's always researchers that
Rohit Gandikota: that find that, oh, even in Nano Banana, if you work with them.
Rohit Gandikota: I think it's a good novelty. You can definitely get Something out of it.
Rohit Gandikota: But if you really want to use it in, in your homeworks.
Rohit Gandikota: It becomes really hard for you to specify in text what it is you want to do.
Rohit Gandikota: So if there is… yeah. Let's forget about the restriction to text. Maybe the specification is a mix of text and some structured formats, such as the one you showed, this plan… Yes. …that you've generated. Yeah, that's fine. What I'm specifically curious to hear, thought on…
Rohit Gandikota: Do you need to understand internally how the model is working to provide a user with the ability to express direct intent effectively?
Rohit Gandikota: Or maybe if we collect enough examples of what users want, specified in whatever structured format you want, or of semi-structured format, enough examples of that with matched images or videos, train a big model on that, would be enough.
Rohit Gandikota: So, everything that humans want into…
Rohit Gandikota: Well, like… You don't need to cover everything, right? I mean, in… No, I mean, like, most of the things that…
Rohit Gandikota: like I touched upon, like, 3D controls and all the other things. Yeah, I think that's the vision that I'm going towards, too. So I would love if people would build it. I mean, in other words, you don't need to necessarily understand how the neurons work, as long as people can control it, it's fine. So that's what you're… that's your answer, is that right? Yeah.
Rohit Gandikota: Yeah, that's my question.
Rohit Gandikota: Oh, yeah, I think that's my answer, too. So I didn't… so in the last… in the end, when I was showing things, I didn't really allude to, I need to understand what the renderer and, like, the planners are doing. I don't really care about it.
Rohit Gandikota: in that depth. And then I think it still becomes a research interest as to what these models are doing. But to solve the problem that I think we both are talking about, I think you don't need to understand what the model is doing internally. At least there needs to be a way for
Rohit Gandikota: Users to specify what they want, and get the desired output in the right way.
Rohit Gandikota: Yeah.
Rohit Gandikota: Maybe something to consider is that
Rohit Gandikota: Different people might have different medium to express their intention, so some people, like.
Rohit Gandikota: For them, text is, like, the easiest way. Other people will be growing is the easiest way. And as long as you can
Rohit Gandikota: train your, like, pre-train your model with all these committees as, like, the way to express intention, then great, I think you can just do pre-training.
Rohit Gandikota: But if you don't, you might want to understand internalists to enable new
Rohit Gandikota: mediums of communications, or something like that. Like, maybe understanding internals will help you communicate with the model through
Rohit Gandikota: A new, rather than free training.
Rohit Gandikota: With that anymore, Cynthia.
Rohit Gandikota: I can see another reason why you might want it, and that has to do with your discovery.
Rohit Gandikota: Because… The discovery allows you to perhaps find new things.
Rohit Gandikota: that people have not conceived at all, right? And I'm also curious about your take, if you think that we can, like, in the…
Rohit Gandikota: In the space of concepts, sliders or whatever, can you find completely… extrapolate to completely new regions, or are you mostly interpolating between known things?
Rohit Gandikota: Can we discover completely novel knowledge or skills from examining models internally, or are we restricted to what we already do?
Rohit Gandikota: Good question. Yeah, this reminds me of Lisa Schutz's work on AlphaZero.
Rohit Gandikota: Yeah, I… I'm not sure how to go about looking for novel visual Structured.
Rohit Gandikota: I understand that in chess, maybe a little bit, on how you can think about it, it's much more structured.
Rohit Gandikota: structured problem, but with vision, I don't know how to do this,
Rohit Gandikota: Is it novel or not yet?
Rohit Gandikota: I'll think more about it.
Rohit Gandikota: I thought that's what you were talking about when you were talking about the styles.
Rohit Gandikota: Like, there are… people have found out this many slides, but maybe you can go beyond that, and…
Rohit Gandikota: If you do that slider, if you… Look at the slider space.
Rohit Gandikota: Multiple times, maybe you can get a style which is not really Style that people have.
Rohit Gandikota: explode in the real world. Yeah, no, absolutely. No, the point is the same. I'm not saying the discovery methods will give you new… will not give you new. I'm sure they will. I don't know the way to test it.
Rohit Gandikota: Yeah, I think artists, like, a case where it's, like.
Rohit Gandikota: better defined, right? Like, you can define, or not really, it's not really, but it's more defined at, like, general, visually. Yeah, like, yeah.
Rohit Gandikota: You're saying the art is more subjective, that's why maybe we don't get normal.
Rohit Gandikota: No, I'm actually saying the opposite. I'm saying that, like, with art.
Rohit Gandikota: Maybe there is a way to measure
Rohit Gandikota: Like, new, this, like, new concepts, because you can measure the similarity to known concepts, or known textbooks.
Rohit Gandikota: But with the general vision, Yeah…
Rohit Gandikota: But maybe if you go to, like, a scientific regime.
Rohit Gandikota: maybe then it's easier to define some… like, I don't… maybe there is a way to do that in a specific domain.
Rohit Gandikota: Yep.
Rohit Gandikota: a dumb idea, but I want to do sliders for gang warping, like, weird creatures, weird-looking cats.
Rohit Gandikota: Yeah, I think that's… that's what the UI was trying to do.
Rohit Gandikota: Actually, I thought of something else. Yes, it just reminded me of the… it just reminded me of that,
Rohit Gandikota: discovery, I think, 2020 or 2019, somebody at MIT got a picture of black hole.
Rohit Gandikota: But maybe you can create images of…
Rohit Gandikota: some celestial bodies that people have not taken. Very nice, yes. Why not? Yes.
Rohit Gandikota: But yeah, I think it would be nice if that's possible, yeah. Maybe people can check it.
Rohit Gandikota: Something different. Yeah. Yeah, yeah.
Rohit Gandikota: So, any question about, So your plan… your vision is to,
Rohit Gandikota: Decompose the image into some kind of, like.
Rohit Gandikota: some text form, maybe an SVG form, that you can…
Rohit Gandikota: We can really specify and create a message.
Rohit Gandikota: Which is sort of like a new programming language, apparently.
Rohit Gandikota: In my near… the near future vision, yes, yes.
Rohit Gandikota: So, in that programming language.
Rohit Gandikota: Do you imagine that every concept you have discovered, or every concept in human knowledge.
Rohit Gandikota: It becomes some kind of, like, an operation in the programming language?
Rohit Gandikota: Like, how do you, let's say, smile?
Rohit Gandikota: Does it, like, become some kind of, like, a keyword in that program language?
Rohit Gandikota: And also, like… Okay, so for…
Rohit Gandikota: Like, it's currently underway, project.
Rohit Gandikota: And the… what the current version is doing is, it has…
Rohit Gandikota: something we call, like, concept vectors, where on top of the language that it's generating, it also has identity as a JSON key, and the value is just a vector.
Rohit Gandikota: And then for that vector, the model has to always generate the same identity of the person again and again.
Rohit Gandikota: So, like, similarly, like, smile can be also, like, a slider kind of an input, where you can keep sliding in your, the language, and then the output should just change the smile and keep the rest of the other things intact.
Rohit Gandikota: But yeah, we are currently doing it, where…
Rohit Gandikota: Yeah, I should give a talk about this, when it's in a much more baked form, but yeah, like, that's the goal, where we try to change
Rohit Gandikota: Expand everything the model is planning internally.
Rohit Gandikota: Into as much as possible.
Rohit Gandikota: And then generate a note for the composed. They become their… Keywords, so all operational.
Rohit Gandikota: Video… Yeah.
Rohit Gandikota: like, a layered tree structure. Like, a person can be…
Rohit Gandikota: so many things. Eyes, eye distances.
Rohit Gandikota: What apparel, like, shirt they're wearing, and everything should have
Rohit Gandikota: something of its own. So that's the thing. This language doesn't have to be…
Rohit Gandikota: Compact enough for humans to read.
Rohit Gandikota: But…
Rohit Gandikota: structured enough that if they want to read, that they can go in, or an agent can go in and do that. That's the goal for now. It might evolve as we go.
Rohit Gandikota: These models, these image models are so good, because they can compose between different concepts.
Rohit Gandikota: And there, they have some flexibility. You want them to have that flexibility. Yeah, the renderer still has that flexibility. I don't impose anything in terms of decomposition on it.
Rohit Gandikota: He's pretty, pretty individual.
Rohit Gandikota: So how a Python program gets compiled to assembly language. Yeah, I agree, yeah. So you kind of want that underscatification in the language as well.
Rohit Gandikota: Because if you can exactly specify everything.
Rohit Gandikota: I don't know how you'll do that, but it would be like a… Too rigid. Yeah, 1 million line,
Rohit Gandikota: Program to generate something.
Rohit Gandikota: Simple.
Rohit Gandikota: We want to have that.
Rohit Gandikota: Capability, which makes it a little bit…
Rohit Gandikota: uncertainty, not… not kind of, like, if you want to navigate an appropriate language through one of the certain language.
Rohit Gandikota: I'll… I'll push back a little on that. I don't… I… I don't think it's the…
Rohit Gandikota: I don't think I'm going towards making the language as…
Rohit Gandikota: descriptive as possible, that's not what I'm going towards. I'm going in… I'm going towards… I want the language to be,
Rohit Gandikota: Fine enough that users can control the things that they care about.
Rohit Gandikota: And, like, if they want to describe the identity, they don't have to take millions of lines of code to describe the identity. It can be a single vector.
Rohit Gandikota: Right?
Rohit Gandikota: And then there can be another model that looks at this identity vector and, like, can edit it, can change it.
Rohit Gandikota: But the… The goal of this code, is not to be exactly as Python.
Rohit Gandikota: And also not exactly as prior models that can do everything in one single model. Like, it's somewhere in between, where I want the renderer to be something which
Rohit Gandikota: is not… like, quotable. I want that to do all these weird composition things and create realistic images.
Rohit Gandikota: At the same time, I want to have a format
Rohit Gandikota: What the model is planning for, and have some ways for me to change what it's planning without affecting a lot of things internally.
Rohit Gandikota: But it's a good question. I… I don't know how to draw that line between verbose versus…
Rohit Gandikota: controllable.
Rohit Gandikota: I'm happy to talk more about it, I have multiple versions.
Rohit Gandikota: Like, what do you think about, like, the target audience stuff of, like, these tools?
Rohit Gandikota: Because, like, this reminds me of, like.
Rohit Gandikota: when I was a kid trying to learn to use Photoshop.
Rohit Gandikota: It's like, Photoshop can do so much with it, but it's so hard
Rohit Gandikota: to learn, because it's, it's like, it's like the really verbose thing. You could literally do anything. Yep.
Rohit Gandikota: But, like, you need to have a lot of expertise. Yeah. But also, like, you… so, like, it depends on who's using it, right? Like, if it's, like, you know… It's a good… that's a good thing. I think that's why the now is very important in this life.
Rohit Gandikota: We finally have tools that can automate these things. You can wipe… wipe code things, you can,
Rohit Gandikota: Solve most of these problems, if it's code.
Rohit Gandikota: You can solve most of it by just putting an agent to work and talking to the code.
Rohit Gandikota: Instead of actually changing something.
Rohit Gandikota: I think, eventually, if this were to work, there'll be definitely two sets of users, one that are, like, published users that would want to look at the code, change something, and work with them, and then ones that would just want to vibe image.
Rohit Gandikota: talk to it and say, oh, no, move it to the left, and then the code agent would go inside and change just the XY coordinates.
Rohit Gandikota: And then re-render the image.
Rohit Gandikota: It is possible now. It wasn't… like, it would have been another Adobe Premium.
Rohit Gandikota: Photoshop, if it was 5 years ago.
Rohit Gandikota: Maybe now it's not that.
Rohit Gandikota: Do you have any… Suggestions for, like, people that don't feel creative, And, like…
Rohit Gandikota: How would you build a system that, like.
Rohit Gandikota: Helps them be more creative for, like, development.
Rohit Gandikota: Yes, so… That… I think that was the intention behind my slider space.
Rohit Gandikota: slide, where I was showing that I have such small intent.
Rohit Gandikota: So, for example, when we came up with concept sliders, we…
Rohit Gandikota: The maximum number of creative sliders we could do were 10, or 20, so 20.
Rohit Gandikota: As soon as we open sourced it, we had, like, 10K, 20K sliders online that are all super creative.
Rohit Gandikota: So one is through crowdsourcing and open sourcing, which I always have a very strong stance on.
Rohit Gandikota: And another is the discovery aspect of things, where you can allow users
Rohit Gandikota: Oh, this was another thing which…
Rohit Gandikota: was about to be on the slides, but was not, which is, having a paradigm which will allow users to enhance their intent, like social media, except instead of
Rohit Gandikota: Optimizing on the engagement, you optimize on intent.
Rohit Gandikota: and sort of show them, like, when they're working with the system, the UI,
Rohit Gandikota: You show them, oh, things you might like to explore but haven't ever, or similar users have explored before, or something where
Rohit Gandikota: the signal is not engagement, right? It's… It's, like,
Rohit Gandikota: Not explored before, sort of. A small nudge.
Rohit Gandikota: But again, it's a dangerous territory, I don't…
Rohit Gandikota: I haven't thought more about it beyond that thought.
Rohit Gandikota: But yes, I think discovery and some sort of a… Sensible nudge.
Rohit Gandikota: Might help users to explore more inside the models.
Rohit Gandikota: I guess, like, another thought is, like, I actually had the software for 2 years, but I haven't really done it. I'm always confused why people never
Rohit Gandikota: use a gaming engine with your graphics engine to boost traffic controllability. Yeah.
Rohit Gandikota: So we… Oh yeah, that's what we're doing now. We have computer graphics, like code, where you can have actions, move cameras, we can even have OMs to sort of, like, interfere with the computer graphics code to do editing in that code. After you render an image, then it's probably a much easier problem to bridge between the realism gap.
Rohit Gandikota: of, like, what your text image model or text-to-video model can do, versus, like, the graphics-generated stuff. Yes. I mean, NVIDIA already has some stuff that's, like, using AI to turn, like, a graphics thing into something that's more realistic. Yes.
Rohit Gandikota: Then…
Rohit Gandikota: I mean, there's free data over there, I just know I really want to play around with it, that just feels such a pity.
Rohit Gandikota: I know, I think that's exactly what we're doing with this project now. Oh, I see. Yeah, it's a good catch, yes. Very cool. Yes,
Rohit Gandikota: Yeah, I… another motivation actually does come from the game engines that you were talking about, the ability to control your characters and…
Rohit Gandikota: The camera angles, motions… And…
Rohit Gandikota: Yeah, we want to do that, except…
Rohit Gandikota: have an engine where you don't have to learn it, like Photoshop.
Rohit Gandikota: Where the model would do it for you. And the real… realism can also be in the same power that we have with Imagine GPT right now.
Rohit Gandikota: To get to that level with game engines is really hard.
Rohit Gandikota: It requires a lot of…
Rohit Gandikota: Like, dedicated years of experience to get to that point.
Rohit Gandikota: But yes, it's rich of all the things that we want to do with vision models. Games are, like, the perfect example of
Rohit Gandikota: having… an explorable medium of vision.
Rohit Gandikota: So yeah, I think it can be a good data source.
Rohit Gandikota: Nope.
Rohit Gandikota: I am not sure that this architecture you're proposing Does actually, like.
Rohit Gandikota: serve as a medium to, like, translate the intent of the user, who's, like, the person who understands the blog.
Rohit Gandikota: And the example you showed earlier, which was very good, about somebody prompting a model to write, like, an email or, like, a thank you letter for the data or something, the model did understand this would be really sweet, and so you would have, like, real positive consequences on it.
Rohit Gandikota: Now, imagine, this example where I'm trying to develop a, like, drawing for a campaign against, like, speeding on the road, like, a school zone available.
Rohit Gandikota: And my prompt to the model is.
Rohit Gandikota: Draw a spool, and, like, a no-speed sign, and kids crossing the road, and a car coming.
Rohit Gandikota: And the model will probably just, like, try to do it exactly as it is, without trying maybe to add elements that would communicate my message.
Rohit Gandikota: Or the purpose behind this. I think language models do, because maybe language is… I don't know.
Rohit Gandikota: There's something human about it, that, like, emotions…
Rohit Gandikota: Transpare more easily through it, and is easily… more easily, you know, interpretable than, like, images. Of course, you can also do that with our images and other things.
Rohit Gandikota: And so I'm not sure that this architecture does actually, like, capture the human intent, and it's that this is just, like, translating the instruction better, and planning, and it's controllable, seems also explainable. Yeah. No, no, I think,
Rohit Gandikota: With the amount of… thing that I've shown here, I think that's a very good intuition.
Rohit Gandikota: I have two points. I think we can very easily solve it with the techniques we have today.
Rohit Gandikota: One is… You can use a pre-trained language model to start your
Rohit Gandikota: DSL generation from, where you exactly get all the intentions that you are hoping to get, at free cost.
Rohit Gandikota: Another thing is the… the point that I did for my second roadmap, which is visual reasoning, medium.
Rohit Gandikota: I feel like that will capture a lot of things that… what you're talking about in a visual sense.
Rohit Gandikota: But… The… I stopped sharing, sorry.
Rohit Gandikota: Yeah, you'll have to go through this, sorry.
Rohit Gandikota: Yeah, I think this parser can also be a good way to keep interacting with your images as you draw.
Rohit Gandikota: Right? You can… if the model ends up generating something which you don't intend to, and you want to generate, hey, I feel like it's not showing the safety that I want to teach my kids, you can talk to the parser to do it, and it would
Rohit Gandikota: ideally, like, plan better in terms of, oh, given this image, the user is intending something else, let me sort of put this into the play here, right? You can talk your intention through.
Rohit Gandikota: Or, I don't know how the visual medium works yet. I wish I had a…
Rohit Gandikota: more better understanding as to how visual medium reasoning works. But I feel like there has to be some sense of, oh, no, no, no, I'm looking for
Rohit Gandikota: Like, some, you know, Some frightening emotion that looks similar to this image.
Rohit Gandikota: And then, somehow the model needs to make sense out of it in the visual sense.
Rohit Gandikota: But… I think it's definitely possible.
Rohit Gandikota: It's just a… Needs to be…
Rohit Gandikota: captured in the right place, and using the right medium, I think.
Rohit Gandikota: If you can already say that, hey, my language model does it, I think this can do it too. You just replace one of these parts, or fine-tune one of these parts on top of the model you're talking about.
Rohit Gandikota: Maybe they're moving along.
Rohit Gandikota: language models, like, me doing it. Yep. Like, the…
Rohit Gandikota: Medium that the training data is presented in contains very rich contextual information, whereas maybe images may be, like, isolated from, like, their role in the world.
Rohit Gandikota: That's what that's why it's not able to watch.
Rohit Gandikota: capture this intent that was left over. Good point, yeah. I think pre-training might still be necessary eventually as we go down this path.
Rohit Gandikota: You might still want individual vision models, language models, like Dino, and you might still want all these things that can capture the modality information from everything that you want.
Rohit Gandikota: But, like, if you want to get to a place where you can do all this
Rohit Gandikota: amazing things. I think… we'll have to move to a better fine-tuning regime, I guess.
Rohit Gandikota: Oh, there's a comment.
Rohit Gandikota: From Chris.
Rohit Gandikota: Thank you, Rohit.
Rohit Gandikota: Can't stop you anymore with all these amazing… Oh, you're ready to defend. Thank you, Chris.
Rohit Gandikota: Oh, no, Chris… Too early. Not yet. He's ready, he's ready to propose.
Rohit Gandikota: One more stage. One more stage.
Rohit Gandikota: Nance. Thank you, but on that note.
Rohit Gandikota: Really nice compendium of all your work and your vision for your next stage. Thank you, Rohit.
Rohit Gandikota: Thank you, hon.