Latest / Satellite image deep learning / Solar Panel Detection with Satellite Imagery

Transcript

Solar Panel Detection with Satellite Imagery · Satellite image deep learning

• 0:04
  SPEAKER_00: Hi, Federico.
• 0:05
  SPEAKER_00: Welcome to the podcast.
• 0:08
  SPEAKER_02: Hi, Robin.
• 0:08
  SPEAKER_02: Thank you for having me.
• 0:10
  SPEAKER_00: It's a pleasure.
• 0:10
  SPEAKER_00: Looking forward to this one.
• 0:12
  SPEAKER_02: Let's begin with a little bit about yourself.
• 0:15
  SPEAKER_02: Okay, perfect.
• 0:18
  So I'm a software engineer with a longstanding career in
• 0:23
  software industry,
• 0:25
  SPEAKER_02: particularly focused on computer vision.
• 0:28
  I worked on biometric identification systems like face
• 0:34
  recognition and fingerprint
• 0:39
  SPEAKER_02: identification,
• 0:40
  SPEAKER_02: just machine learning.
• 0:42
  SPEAKER_02: Mm-hmm.
• 0:43
  And I had the opportunity to participate in several
• 0:49
  identification programs in the
• 0:51
  SPEAKER_02: region of Latin America.
• 0:54
  SPEAKER_02: And these recent years,
• 0:56
  SPEAKER_02: I've been specializing myself in the machine learning,
• 1:01
  SPEAKER_02: trying to understand what's behind those black boxes.
• 1:05
  SPEAKER_02: And that curiosity drives me to start this project, yeah.
• 1:11
  SPEAKER_00: Brilliant.
• 1:12
  SPEAKER_00: So background in sort of facial recognition and things like that.
• 1:15
  SPEAKER_00: And now you're interested to get into the geospatial domain.
• 1:18
  SPEAKER_02: Yes.
• 1:19
  SPEAKER_00: Right.
• 1:20
  SPEAKER_00: And you've been working on a project in particular.
• 1:22
  SPEAKER_00: Do you want to tell us a bit about that?
• 1:25
  SPEAKER_02: Okay, perfect.
• 1:28
  SPEAKER_02: So I prefer...
• 1:31
  a model uh deep learning uh model to um for semantic
• 1:37
  segmentation um identifying um
• 1:42
  solar cells photovoltaic cells in brazil using satellite
• 1:48
  monitoring all right so
• 1:50
  solar panel detection over brazil specifically what was what
• 1:54
  was the first part of
• 1:55
  SPEAKER_00: your your process
• 1:59
  SPEAKER_02: So the first part of the process was selecting the data.
• 2:09
  Being honest with you,
• 2:09
  at the very beginning,
• 2:12
  I didn't find the data set that I wanted.
• 2:17
  SPEAKER_02: There's many, many data sets,
• 2:21
  A lot of them use very high-resolution images,
• 2:26
  and I wanted to use more open resources.
• 2:32
  So I didn't want to use very high-resolution images or some of
• 2:38
  them from the two groups
• 2:42
  SPEAKER_02: So because I wanted to explore regions in Brazil to detect those panels,
• 2:51
  SPEAKER_02: I prefer to use other kind of images.
• 2:55
  SPEAKER_02: So at the end, I decided to build my own data set.
• 3:02
  SPEAKER_02: So this was the first step.
• 3:06
  SPEAKER_02: And I experienced with Google Earth Engine
• 3:12
  SPEAKER_02: And I discovered the BDC,
• 3:15
  SPEAKER_02: the Brazil DataCube program,
• 3:17
  SPEAKER_02: which is a pretty interesting program open.
• 3:23
  SPEAKER_02: And it uses Open DataCube's technology, the framework.
• 3:29
  SPEAKER_02: So it's an open framework.
• 3:32
  SPEAKER_02: It used images from different satellite programs,
• 3:37
  SPEAKER_02: Sentinel,
• 3:40
  SPEAKER_02: Landsat,
• 3:41
  SPEAKER_02: CBRS,
• 3:42
  SPEAKER_02: which is a Brazil satellite program.
• 3:45
  SPEAKER_02: And at the end for my project,
• 3:50
  SPEAKER_02: I decided to go for the Sentinel-2 images coming from brazil.cube.
• 3:59
  So they provide an API and you can request images basically
• 4:04
  back as sort of
• 4:05
  SPEAKER_00: formatted data cube.
• 4:06
  SPEAKER_00: Is that right?
• 4:08
  SPEAKER_02: Yeah, that's it.
• 4:09
  SPEAKER_02: What they call the spatial temporal data.
• 4:15
  um so i had access to to those cubes where uh basically we have
• 4:24
  uh 2d information
• 4:26
  and the uh on the time axis also um so it was easy to uh to
• 4:34
  understand i i had the
• 4:36
  opportunity to to be in contact with the people that maintained
• 4:40
  the uh the program
• 4:41
  SPEAKER_02: they they were very kind
• 4:43
  They also have examples to connect to the service that are
• 4:52
  available,
• 4:52
  that are open.
• 4:53
  SPEAKER_02: So that helped me to build my data set.
• 4:58
  SPEAKER_02: So that's how everything starts.
• 5:02
  SPEAKER_00: Of course.
• 5:03
  SPEAKER_00: Well, Brazil's a big place.
• 5:05
  SPEAKER_00: Presumably you narrowed it down a bit.
• 5:09
  SPEAKER_02: Yeah, it's a huge country, a huge region took over.
• 5:17
  SPEAKER_02: So the first idea was to select
• 5:24
  a group of solar plants that are distributed in the solar
• 5:32
  corridor in Brazil,
• 5:33
  SPEAKER_02: which is a region where there is not so cloudy,
• 5:36
  SPEAKER_02: a lot of sun during all the year.
• 5:40
  SPEAKER_02: So it's perfect for solar energy.
• 5:45
  SPEAKER_02: So I select a group of solar plants.
• 5:52
  At the very beginning,
• 5:52
  I select 24 from different sizes,
• 5:59
  different surroundings.
• 6:01
  SPEAKER_02: to cover a wide distribution of solar plants, let's say.
• 6:10
  SPEAKER_02: So the big famous solar plants from Brazil and also some plants
• 6:16
  SPEAKER_02: that I know from my region,
• 6:18
  SPEAKER_02: I live in Brasilia,
• 6:19
  so I know some small plants that I wanted to prove that the
• 6:26
  model detects those
• 6:29
  SPEAKER_02: plants also in urban surroundings.
• 6:33
  SPEAKER_02: So I built that selection.
• 6:36
  SPEAKER_02: of solar plants.
• 6:37
  SPEAKER_02: And then basically the process,
• 6:42
  SPEAKER_02: because I didn't count with a lot of images,
• 6:48
  I take different pictures from each one of the solar plants
• 6:56
  moving my acquisition
• 6:58
  SPEAKER_02: window around a central coordinate to have more images.
• 7:08
  SPEAKER_02: So I use that technique for each one of the plants.
• 7:15
  SPEAKER_02: So at the end, I gather almost 300 images from the plants.
• 7:23
  SPEAKER_02: They are 256 by 256 tiles.
• 7:31
  um and i choose to to to take the uh the three composite bands
• 7:39
  plus the near
• 7:40
  infrared band all of them are available at the brazil data cube
• 7:45
  images right and
• 7:46
  then you already knew where these things were i suppose you
• 7:48
  looked up on open
• 7:49
  street map or something to find the precise location of these
• 7:53
  these solar sites
• 7:56
  SPEAKER_02: Yeah,
• 7:57
  SPEAKER_02: I use some Google Earth,
• 8:01
  SPEAKER_02: some researching about the position of well-known solar plants in Brazil.
• 8:09
  So I found and I confirm the location,
• 8:14
  the coordinates of each one of them.
• 8:16
  Then I cross the information with the images that I fetched
• 8:21
  from brazil.cube and
• 8:25
  so i started building my sets uh so basically that was the uh
• 8:32
  that was the process
• 8:33
  right and to make the the annotations the truth labels did you
• 8:37
  use some open labels
• 8:39
  or did you have to create those yourself now i create that from
• 8:43
  scratch um
• 8:47
  SPEAKER_02: At the very beginning,
• 8:50
  I remember that I use simple scripts that's defining a
• 8:57
  threshold and using the near
• 8:59
  SPEAKER_02: infrared band.
• 9:02
  I call that script the auto-mask script where they find that
• 9:07
  decision threshold,
• 9:08
  SPEAKER_02: I can filter the values of pixels in that band.
• 9:14
  SPEAKER_02: So I can have a free mask of the image just to
• 9:21
  SPEAKER_02: gain time and do not hand annotate every single pixel from scratch.
• 9:29
  SPEAKER_02: I shared those scripts also with the project.
• 9:35
  SPEAKER_02: And so that helped me to gain time.
• 9:40
  But at the end,
• 9:41
  I used the Serval plugin from QGIS,
• 9:46
  which is a very simple
• 9:48
  SPEAKER_02: and straightforward tool.
• 9:52
  SPEAKER_02: So I finished every mask by hand.
• 9:57
  SPEAKER_02: So
• 10:02
  SPEAKER_02: This is how I prepare the binary masks.
• 10:07
  So the plugin is some sort of widget that you can play with the
• 10:11
  thresholding or the
• 10:12
  range of pixel values that you're going to assign to the
• 10:16
  segmentation label.
• 10:18
  SPEAKER_00: Is that right?
• 10:20
  SPEAKER_02: There's two steps.
• 10:24
  The first one is,
• 10:26
  as I mentioned,
• 10:27
  is a script phase where I set that threshold.
• 10:37
  SPEAKER_02: for every one of the images.
• 10:43
  SPEAKER_02: In fact,
• 10:44
  it is detected from the distribution because the near-infrared
• 10:50
  band is more
• 10:53
  SPEAKER_02: sensitive to solar cells.
• 10:56
  SPEAKER_02: The solar cells absorb a lot of,
• 10:59
  there's a very low reflectance for the pixels that belong to
• 11:04
  the solar cell.
• 11:05
  SPEAKER_02: So it creates a nice contrast that is easier to filter with a threshold.
• 11:13
  SPEAKER_02: So that was the technique, the first step.
• 11:17
  SPEAKER_00: Right, so you set the thresholds, you've now created your masks.
• 11:22
  SPEAKER_00: How balanced was the data set?
• 11:24
  Like what percentage of pixels would be a solar panel versus
• 11:27
  not a solar panel?
• 11:30
  uh low very low uh i expected that but uh um i measure it it's
• 11:37
  around eight percent
• 11:40
  uh to um five and four percent depending on the sets i have the
• 11:45
  statistics it's a
• 11:47
  SPEAKER_02: it's a it's very imbalanced
• 11:50
  SPEAKER_00: Right, very imbalanced problem.
• 11:51
  SPEAKER_00: Brilliant.
• 11:52
  SPEAKER_00: So you've got your label data.
• 11:54
  SPEAKER_00: I think you mentioned there's about 300 images,
• 11:56
  SPEAKER_00: about 5% of the pixels are the class that you care about.
• 12:00
  SPEAKER_00: What next?
• 12:03
  SPEAKER_02: Okay, so I had my set.
• 12:07
  SPEAKER_02: So then I wanted to experience with...
• 12:14
  SPEAKER_02: various models and benchmark them.
• 12:18
  SPEAKER_02: And before that, I create what I call the baselines.
• 12:22
  SPEAKER_02: So I use very simple techniques, a random dummy classifier,
• 12:33
  I also use a model that use that threshold for the near
• 12:43
  infrared band as a
• 12:44
  SPEAKER_02: classifier also to know how it performs.
• 12:49
  SPEAKER_02: I measure the performance of that one.
• 12:52
  SPEAKER_02: And I also use logistic regression to build a baseline.
• 12:58
  SPEAKER_02: And then...
• 13:01
  SPEAKER_02: I start with the models, the specific models to this kind of work.
• 13:07
  SPEAKER_02: So I experienced with UNET, FPN, UNET++, PNP.
• 13:16
  SPEAKER_02: So I benchmarked them with my original sets.
• 13:21
  SPEAKER_02: And the idea was to select the best performing one.
• 13:27
  SPEAKER_02: And after selecting the best performing one with this original set,
• 13:33
  SPEAKER_02: see what happens if I add enhancement techniques like super resolution or
• 13:41
  SPEAKER_02: interpolation,
• 13:43
  SPEAKER_02: how that can change the performance of the model.
• 13:49
  SPEAKER_01: Right.
• 13:51
  SPEAKER_02: This is the main idea of that second step of working with the model.
• 13:57
  SPEAKER_00: So that's good practice.
• 13:59
  SPEAKER_00: First,
• 13:59
  establish a baseline performance with a sort of pixel-based
• 14:03
  logistic regression or
• 14:04
  SPEAKER_00: simple model.
• 14:05
  And then you spent time experimenting with CNN-based models to
• 14:09
  improve that.
• 14:11
  SPEAKER_00: How did they score relative to each other?
• 14:14
  SPEAKER_02: Okay, the logistic regression was a very, very low IOU.
• 14:21
  SPEAKER_02: What I remember, it was a little bit more than 30% of IOU, Jacker Index.
• 14:30
  SPEAKER_02: And then using UNET, which was the best performing from the CNN models,
• 14:42
  It's important to say that I use a UNET model using an
• 14:47
  EfficientNet encoder.
• 14:50
  So the decoder,
• 14:52
  it was the UNET,
• 14:54
  but I fixed the encoder using EfficientNet.
• 15:00
  SPEAKER_02: And why I fixed that?
• 15:05
  SPEAKER_02: Because I train everything on my personal computer,
• 15:08
  SPEAKER_02: so I want a good balance between performance and resources.
• 15:19
  SPEAKER_02: And I also used a pre-trained EfficientNet encoder using ImageNet set.
• 15:31
  So that was the idea to fix the encoder and use other decoders
• 15:38
  as UNET,
• 15:39
  UNET++,
• 15:40
  PNP,
• 15:42
  et cetera.
• 15:43
  SPEAKER_02: And the best performing combination was the UNET.
• 15:48
  SPEAKER_02: It was quite expected, but it was very close to UNET++.
• 15:53
  um and i reach with the uh this first configuration 90 of iou
• 16:04
  so significant
• 16:07
  improvement and i'm just curious out of all the different
• 16:09
  neural network networks
• 16:11
  you you tried how big was the spread was some pretty close was
• 16:15
  there a big range
• 16:17
  SPEAKER_02: No, they were very close.
• 16:19
  SPEAKER_00: They were very close, right?
• 16:20
  SPEAKER_02: Yeah, they were very close.
• 16:22
  SPEAKER_02: The range was, let's say, between 80% and 90%.
• 16:25
  SPEAKER_02: But...
• 16:30
  SPEAKER_02: there was a gap, there was a difference in terms of time consuming also.
• 16:38
  The unit combination with efficient net,
• 16:42
  it was very good in terms of speed.
• 16:45
  SPEAKER_02: Right.
• 16:46
  SPEAKER_02: Yeah.
• 16:47
  SPEAKER_02: So others, models took too long to train.
• 16:55
  SPEAKER_02: Yeah.
• 16:56
  SPEAKER_00: Right.
• 16:56
  And did you write your own code for training the models or did
• 16:58
  you use some existing framework?
• 17:02
  SPEAKER_02: I use PyTorch and I use a very good library called segmentation model.
• 17:16
  SPEAKER_02: which is available for PyTorch and for TensorFlow also.
• 17:21
  I decided to use PyTorch because I,
• 17:25
  being honest,
• 17:27
  my GPU in my personal computer works.
• 17:31
  SPEAKER_02: It was easier to configure with PyTorch.
• 17:35
  um so i use those libraries uh to do the the combination of uh
• 17:44
  different uh
• 17:45
  different models um so that's how i i prepare that great so
• 17:52
  you've trained the
• 17:52
  SPEAKER_00: model you've selected the best one what did you do with it
• 17:57
  SPEAKER_02: So then after selecting the best performing one,
• 18:01
  SPEAKER_02: I start experiencing with upscaling the images and see how it impacts the
• 18:11
  SPEAKER_02: performance of the model.
• 18:13
  SPEAKER_00: So super resolution.
• 18:15
  SPEAKER_02: Yeah,
• 18:15
  SPEAKER_02: I experienced with super resolution,
• 18:17
  SPEAKER_02: with the real innate super resolution GAN from Jintao.
• 18:24
  SPEAKER_02: It's a general project.
• 18:31
  SPEAKER_02: So I research about it and it's possible to use with satellite imagery.
• 18:39
  It has not been trained specifically for satellite imagery,
• 18:43
  it's more general purpose.
• 18:45
  SPEAKER_02: But I wanted to see what happened,
• 18:49
  how the performance changed because it's a very accessible also
• 18:57
  super resolution
• 18:58
  SPEAKER_02: model.
• 18:59
  And then I used bicubic interpolation to see what happened and
• 19:09
  compare both.
• 19:10
  SPEAKER_02: All right.
• 19:11
  SPEAKER_00: And what was the outcome?
• 19:14
  SPEAKER_02: So...
• 19:17
  SPEAKER_02: I expect a better performance using super resolution,
• 19:20
  SPEAKER_02: but the reality is that this super resolution,
• 19:26
  SPEAKER_02: what happened?
• 19:28
  SPEAKER_02: You know that two folded images
• 19:34
  I have a first problem with the size of the images and the
• 19:39
  training process because
• 19:42
  SPEAKER_02: we are dealing with much bigger images for two-folded super resolution,
• 19:50
  SPEAKER_02: four times the amount of pixels,
• 19:53
  SPEAKER_02: four-folded
• 19:55
  SPEAKER_02: 16 times the amount of pixels per image.
• 19:58
  SPEAKER_02: So I start needing to reduce the size of the mini batches.
• 20:06
  SPEAKER_02: um, during the, uh, during the training.
• 20:09
  SPEAKER_02: Um,
• 20:10
  SPEAKER_02: so,
• 20:10
  SPEAKER_02: uh,
• 20:12
  SPEAKER_02: at the very end,
• 20:13
  SPEAKER_02: when I use the,
• 20:14
  SPEAKER_02: the,
• 20:15
  SPEAKER_02: um,
• 20:16
  SPEAKER_02: bigger images,
• 20:17
  SPEAKER_02: I needed to,
• 20:17
  SPEAKER_02: to reduce the size of the mini matches to one,
• 20:22
  SPEAKER_02: uh,
• 20:24
  SPEAKER_02: practically doing stochastic gradient descent.
• 20:27
  SPEAKER_02: And, uh,
• 20:30
  SPEAKER_02: So the problem was the time that it took for the training.
• 20:36
  SPEAKER_02: Comparing at the very beginning, that took me no more than one hour.
• 20:41
  SPEAKER_02: And after supper resolution, it took me
• 20:46
  40 hours almost two days training um and the uh interesting
• 20:52
  result is that uh at
• 20:54
  the end the um bicubic um interpolation performs a little bit
• 21:01
  better than uh than
• 21:04
  SPEAKER_02: super resolution it's uh had um um
• 21:10
  SPEAKER_02: So from these two options,
• 21:14
  I selected the bicubic interpolation because I wanted to deploy
• 21:20
  this model.
• 21:21
  SPEAKER_02: And thinking in the deployment,
• 21:25
  SPEAKER_02: it was also interesting to keep that good balance between performance and
• 21:31
  SPEAKER_02: resources.
• 21:32
  SPEAKER_00: Right, very interesting.
• 21:33
  SPEAKER_00: So you had, I think, 90% IOU before.
• 21:36
  SPEAKER_00: You then applied bicubic interpolation.
• 21:38
  SPEAKER_00: How does that impact the metrics?
• 21:41
  SPEAKER_02: I gained four percent, four to five percent of IOU.
• 21:49
  SPEAKER_02: And with the super resolution,
• 21:54
  SPEAKER_02: I almost reached the same results using times four super resolution.
• 22:01
  SPEAKER_02: So as I mentioned, the bicubic interpolation gave me
• 22:09
  the uh the same iou with uh shorter uh training loops so i
• 22:14
  finally decide to
• 22:15
  continue with the uh bicubic interpolation yeah very
• 22:18
  interesting because of course
• 22:19
  if you're using a pre-trained super resolution model that's
• 22:21
  been trained on remote
• 22:23
  sensing imagery already so possibly bring some extra
• 22:27
  information into into the task
• 22:29
  SPEAKER_00: interesting avenue to explore
• 22:32
  SPEAKER_00: Brilliant,
• 22:33
  SPEAKER_00: so you've trained your model,
• 22:34
  SPEAKER_00: you've refined it essentially,
• 22:37
  SPEAKER_00: and then what did you do with that?
• 22:42
  SPEAKER_02: Okay,
• 22:42
  SPEAKER_02: so then after having my model,
• 22:47
  SPEAKER_02: having the weights,
• 22:51
  SPEAKER_02: so the idea was to deploy it,
• 22:56
  SPEAKER_02: put into practice the model.
• 23:00
  SPEAKER_02: So I start deploying the model on cloud.
• 23:07
  SPEAKER_02: I select AWS.
• 23:12
  SPEAKER_02: So I started building a pipeline.
• 23:17
  SPEAKER_02: So I basically,
• 23:20
  the pipeline that I prepare is I build a simple front end where
• 23:31
  I have the
• 23:33
  SPEAKER_02: coordinates,
• 23:33
  SPEAKER_02: the central coordinates of an extraction plus the north,
• 23:39
  SPEAKER_02: south extension and east,
• 23:41
  SPEAKER_02: west extension.
• 23:42
  SPEAKER_02: In other words, the bounding box of the extraction.
• 23:46
  SPEAKER_02: And this is the input for the pipeline.
• 23:54
  SPEAKER_02: And then I build a web server as my backend point of entry.
• 24:04
  SPEAKER_02: I build it using Flask.
• 24:10
  SPEAKER_02: I use AWS Lambda, which contains that web server.
• 24:17
  SPEAKER_02: So this was the point of entry of...
• 24:21
  SPEAKER_02: globally saying a simple four-step workflow where first,
• 24:30
  SPEAKER_02: the first step they are containing to a step function,
• 24:34
  SPEAKER_02: AWS step function,
• 24:36
  that first I fetch the images from Brazil Data Cube that
• 24:41
  belongs to that zone of
• 24:44
  SPEAKER_02: extraction.
• 24:45
  SPEAKER_02: So basically I prepare the tiles
• 24:52
  of 256 by 256 tiles according to the entry characteristic of
• 25:03
  the images for the model.
• 25:04
  So I prepare all the tiles that belong to the extraction in
• 25:09
  that first step.
• 25:12
  Then I apply the imaginations which is deployed and it's up and
• 25:17
  running is the
• 25:22
  SPEAKER_02: bicubic interpolation.
• 25:23
  SPEAKER_02: So I have four times bigger images.
• 25:28
  SPEAKER_02: And after that, I process all those tiles into the model.
• 25:34
  SPEAKER_02: This is the third step of the workflow.
• 25:39
  SPEAKER_02: So I have the predictions.
• 25:41
  SPEAKER_02: And after having the predictions, I build as a four step reports.
• 25:48
  SPEAKER_02: I print some statistics about the destruction, how many positive pixels
• 25:58
  were detected in each one of the those tiles which is the which
• 26:05
  surface represents
• 26:07
  SPEAKER_02: those those pixels to know to have an idea of
• 26:11
  SPEAKER_02: which styles detect where we have more pixels detected.
• 26:19
  So I print a final report that can be downloaded at the end of
• 26:29
  the process.
• 26:29
  SPEAKER_02: So it's like an end-to-end machine learning pipeline using that input.
• 26:40
  SPEAKER_00: Well,
• 26:40
  SPEAKER_00: congratulations,
• 26:41
  SPEAKER_00: as you say,
• 26:41
  SPEAKER_00: that's a pretty end to end you started,
• 26:42
  SPEAKER_00: but just an idea,
• 26:44
  SPEAKER_00: a place to go.
• 26:45
  SPEAKER_00: And then you created the data set,
• 26:47
  SPEAKER_00: you experimented with different models,
• 26:48
  SPEAKER_00: you experimented with different ways to improve the predictions,
• 26:52
  SPEAKER_00: and then you deployed it.
• 26:53
  SPEAKER_00: And so somebody can go and try this out for themselves.
• 26:56
  SPEAKER_00: I'm curious,
• 26:57
  what was the sort of the biggest thing that you learned in the
• 26:59
  whole process,
• 27:00
  SPEAKER_00: do you think?
• 27:05
  SPEAKER_02: In general,
• 27:09
  Consistency was key because I had the opportunity to combine
• 27:15
  previous knowledge
• 27:17
  SPEAKER_02: from my background,
• 27:18
  SPEAKER_02: but I needed to learn a lot of new things.
• 27:24
  SPEAKER_02: So consistency was key.
• 27:31
  SPEAKER_02: Because there are many difficulties that present.
• 27:33
  SPEAKER_02: Now it's easy to explain,
• 27:35
  SPEAKER_02: but you know that do a hands-on project like that,
• 27:40
  SPEAKER_02: you have some drawbacks,
• 27:42
  SPEAKER_02: you have problems.
• 27:44
  SPEAKER_02: Overcome each one of them was key and advanced step by step.
• 27:54
  I had in mind some improvements,
• 27:57
  so maybe in the future I can continue improving the model.
• 28:06
  SPEAKER_02: I didn't use a tile.
• 28:10
  SPEAKER_02: First, I didn't experience using other bands.
• 28:14
  so i i only use rgb plus near infrared but i i didn't use other
• 28:21
  interesting
• 28:22
  SPEAKER_02: available bands from sentinel 2 that can can help because of the i use a
• 28:31
  SPEAKER_02: pre-trained model using rgb i wanted to
• 28:38
  I didn't want to add a lot of bands to stay close to the
• 28:44
  original weights,
• 28:46
  SPEAKER_02: but it's something that I'm expending.
• 28:49
  SPEAKER_02: It's something that I want to experience with.
• 28:52
  SPEAKER_02: And also, I'm not caching images.
• 28:57
  SPEAKER_02: So the workflow right now, it takes a little bit long.
• 29:01
  SPEAKER_02: It's available.
• 29:02
  SPEAKER_02: So if everyone wants to try it,
• 29:04
  I can generate a token and it's available for demonstration so
• 29:10
  anyone can access
• 29:11
  SPEAKER_02: to.
• 29:13
  So now the process takes a little bit long because it's doing
• 29:21
  everything from end
• 29:23
  SPEAKER_02: to end,
• 29:23
  SPEAKER_02: from scratch.
• 29:24
  SPEAKER_02: There's no caching images.
• 29:25
  SPEAKER_02: I'm not caching images.
• 29:26
  SPEAKER_02: Thinking to the idea of discovering or covering new zones,
• 29:32
  SPEAKER_02: unseen zones,
• 29:34
  SPEAKER_02: I prefer to not cache images.
• 29:36
  SPEAKER_02: So it's something that I would like to experience in the future.
• 29:38
  SPEAKER_02: It will run faster.
• 29:43
  SPEAKER_02: and maybe using a tile system like S2, experience with that.
• 29:49
  SPEAKER_02: So it's an open project.
• 29:51
  I have many,
• 29:53
  many things to improve,
• 29:56
  but it was an enlightening experience.
• 29:59
  SPEAKER_00: That's great to hear.
• 30:00
  SPEAKER_00: Well, thanks so much for sharing your experience with us.
• 30:05
  Lastly,
• 30:05
  if people want to follow along the updates to the project,
• 30:07
  which is the best platform?
• 30:11
  Okay,
• 30:11
  so to follow the updates of the projects,
• 30:18
  you can follow my project in GitHub.
• 30:25
  SPEAKER_02: So I share the links.
• 30:28
  SPEAKER_02: I also post it on my LinkedIn account.
• 30:33
  So my idea,
• 30:35
  my intention is to continue updating it and experience it with
• 30:39
  it in my free time.
• 30:42
  SPEAKER_02: So that's it.
• 30:44
  SPEAKER_00: Brilliant.
• 30:44
  SPEAKER_00: Well, thanks again for coming on.
• 30:46
  SPEAKER_00: And we look forward to updates.
• 30:47
  We're also going to record a video demonstration looking at the
• 30:50
  tool that you developed.
• 30:51
  SPEAKER_00: So I'll post a link to that in the show notes as well.
• 30:55
  SPEAKER_00: Okay.
• 30:55
  SPEAKER_00: Once again, thank you.
• 30:57
  SPEAKER_00: Until next time, take care.
• 30:59
  SPEAKER_02: Thank you for having me.
• 31:00
  SPEAKER_02: Bye-bye.