Copy and paste this into your file. These are the fundamental building blocks of a web page:
Copy and paste this between the <html> and </html>. This is the head, which contains metadata (invisible information) about your page
My website
Copy and paste this after the </head> but before the </html>. This is the body, which contains all of the visible elements on the page
Hello, world!
The first step to building your website is to divide everything into a grid of rectangles. My example website obviously has three rectangles from top to bottom, but it also has invisible rectangles holding the other pieces of content in place. First, to make the visible rectangles, I want something like this. Each div (division) is a colored box. For this example, erase "Hello, world!" and copy and paste this in:
First rectangle content will go hereSecond rectangle content will go hereThird rectangle content will go here
Then we need dividers to separate the space inside each visible grid. We do this by splitting the entire screen into six columns. Referring to the lines drawn on your paper, figure out how many columns each item needs to take up. For example, my avatar photo takes up about 5/12 columns, and my name takes up about 7/12 columns. Then we create invisible container divs to hold these pieces. Vertical divider divs go inside row divs. For this example, erase "First rectangle content will go here" and copy and paste this in:
Avatar will go hereName will go here
I also have these dividers for the second rectangle (replace "Second rectangle content will go here"):
Game will go hereParagraph describing game will go here
And these dividers for the third rectangle (replace "Third rectangle content will go here"):
YouTube video will go here
Now that we have our dividers, let's put some stuff in there! The easiest place to start is text. I have a title containing my name, and a paragraph describing my game. For the title, I'm going to use an <h1> tag. h1 means header 1, which is the largest header. Then for the paragraph, I'm going to use an <h3> tag, AKA header 3, which is smaller than an <h1> or <h2> tag. You can also use <h4> and up, or <p> (paragraph) if you want much smaller text, like if you were writing an entire blog entry.
First, replace "Name will go here" with this:
Erin
Second, replace "Paragraph describing game will go here" with this:
This is a beautiful paragraph about my game. My game features an alien space man character, a fence, and some coins. When you get three coins, you win! Then the game will restart. It is very exciting. There is a wall of grass/dirt blocks at the edge so the alien space man character does not go off the edge into the abyss. At some point, I will likely add more features to this exciting game!
The awesome thing about modern web development is that we can embed content from other places directly into our websites! Today, I'm going to embed my browser game (from flowlab.io) and a video from YouTube
The first step to embedding something is getting the embed code. For your flowlab.io game, go log in to your flowlab.io profile, and you will notice underneath the Play and Edit buttons there is a box labeled "Embed". Copy everything in that box, and paste it in place of "Game will go here". My embed code looks like this:
Then go to YouTube, find a video you like, and scroll down so you can see the "Share" option immediately below the video. Click on "Share" and some new options should appear below. Click on "Embed". This will also give you a box of code.   For today, let's get our "profile" image from this set of cartoon octocats. What's an octocat, you ask? A hybrid octopus cat. It's adorable. It's also the mascot of GitHub, the internet service I'll be using to publish your websites on the web. Click this link to pick one out. Once you have one you like, right click on it and select "Open Image in New Tab". The URL that appears in the browser top bar will be the source file for your image. My image code looks like this (copy and paste this in place of "Avatar will go here"):


Getting started
Atoms
Buttons
Forms
Badges
Molecules
Tables
Button gropus
Tree
Organisms
Create maintenance window


When you want to represent non-integral numbers (i.e., real numbers), you can use either the standard C floating-point format or the following special structures of GEOS for fixed point math. Note that fixed-point calculations are faster than the corresponding floating-point math, so if you want to optimize your code, you should use the GEOS fixed-point structures with the GEOS math routines.
Code Display 5-2 GEOS Data Structures
/* Fixed-Point Structures * The following structures are used to represent fixed-point numbers: * numbers with a fractional portion and an integral portion. Notice that * there are several formats of fixed-point numbers; each uses a different * number of bits for the parts of the number. Choose whichever is most * appropriate (for optimization). */
/* BBFixed * One byte integer, one byte fraction */ typedef struct { byte BBF_frac; /* fractional portion */ byte BBF_int; /* integral portion */ } BBFixed;
/* BBFixedAsWord * Sometimes it is convenient to refer to a BBFixed value as type word. * The BBFixedAsWord type is used for this purpose. */ typedef word BBFixedAsWord;
/* WBFixed * One word integer, one byte fraction */ typedef struct { byte WBF_frac; /* fractional portion */ word WBF_int; /* integral portion */ } WBFixed;
/* WWFixed * One word integer, one word fraction */ typedef struct { word WWF_frac; /* fractional portion */ word WWF_int; /* integral portion */ } WWFixed;
/* WWFixedAsDWord * Sometimes it is convenient to refer to a WWFixed value as type dword. * The WWFixedAsDWord type is used for this purpose. */ typedef dword WWFixedAsDWord;
/* DWFixed * two words (one dword) integer, one word fraction */ typedef struct { word DWF_frac; /* fractional portion */ sdword DWF_int; /* integral portion */ } DWFixed;
/* Three-byte structure * The WordAndAHalf structure is used when you need a 24-bit value and you want to * optimize and avoid using a 32-bit value. */
typedef struct { word WAAH_low; /* the low 16 bits */ byte WAAH_high; /* the high 8 bits */ } WordAndAHalf;
Three special macros are also available to work with the
WWFixed
type. These are listed below:
MakeWWFixed
This macro creates a
WWFixed
structure from a given floating-point number or dword number.
WWFixedToFrac
This macro produces the fractional portion of a
WWFixed
structure.
WWFixedToInt
This macro produces the integral portion of a
WWFixed
structure.
Two other macros are provided for use with
WWFixedAsDword
structures:
IntegerOf()
This macro returns the integral portion of a
WWFixedAsDword
structure.
FractionOf()
This macro returns the fractional portion of a
WWFixedAsDword
structure.


Below is a list of all the F1 teams and F1 racing drivers that are competing in the F1 2023 season. And of course the F1 2023 racing calendars.
Go to the overviews of F1 2023 Race Calendar and Drivers & Teams
| Date | Location | |
|---|---|---|
| 16 | September 17 | Marina Bay Street Circuit, Singapore |
| 17 | September 24 | Suzuka International Racing Course, Suzuka, Japan |
| 18 | October 8 | Losail International Circuit, Doha, Qatar |
| 19 | October 22 | Circuit of the Americas, Austin, Travis County, Texas, USA |
| 20 | October 29 | Autódromo Hermanos Rodríguez, Mexico City, Mexico |
| 21 | November 5 | Autódromo de Interlagos José Carlos Pace, Cidade Dutra, Brazil |
| 22 | November 18 | Caesars Palace Grand Prix, Las Vegas, Nevada, USA |
| 23 | November 26 | Yas Marina Circuit, Yas, Abu Dhabi |
| F1 Teams | F1 Drivers |
|---|---|
| Oracle Red Bull Racing | 1 - Max Verstappen |
| 11 - Sergio Perez | |
| Scuderia Ferrari | 16 - Charles Leclerc |
| 55 - Carlos Sainz | |
| Mercedes-AMG Petronas Formula One Team | 44 - Lewis Hamilton |
| 63 - George Russell | |
| BWT Alpine F1 Team | 10 - Pierre Gasly |
| 31 - Esteban Ocon | |
| McLaren Formula 1 Team | 4 - Lando Norris |
| 81 - Oscar Piastri | |
| Alfa Romeo F1 Team ORLEN | 24 - Zhou Guanyu |
| 77 - Valtteri Bottas | |
| Aston Martin Aramco Cognizant F1 Team | 14 - Fernando Alonso |
| 18 - Lance Stroll | |
| MoneyGram Haas F1 Team | 20 - Kevin Magnussen |
| 27 - Nico Hülkenberg | |
| Scuderia AlphaTauri | 22 - Yuki Tsunoda |
| 21 - Nyck de Vries | |
| Williams Racing | 23 - Alex Albon |
| 2 - Logan Sargeant |


{{ content }}
--- layout: default sitemap: true id: about nav: - label: What is Kong? link: /about/ - label: Who is Using Kong? link: /about/who/ - label: Advantages & Use Cases link: /about/advantages/ - label: PCI DSS Compliance link: /about/pci-dss/ - label: Benchmark link: /about/benchmark/ ---


{%extends display.suMain%} {%block content%}
{%trans "A step shows the completion status of an activity in a series of activities"%}


{% extends "site_base.html" %} {% load i18n %} {% block head_title %}{% trans "Welcome" %}{% endblock %} {% block body_class %}home{% endblock %} {% block body %}
{% blocktrans %} Pinax is a Django project intended to provide a starting point for websites. By integrating numerous reusable Django apps to take care of the things that many sites have in common, it lets you focus on what makes your site different. {% endblocktrans %}
{% blocktrans %} For more information about Pinax, see http://pinaxproject.com/. {% endblocktrans %}
{% blocktrans %} This project demonstrates a closed site requiring an invitation to join and not exposing any information publicly. It provides a top-level task tracking system, wiki and bookmarks. It is intended to be the starting point of sites like intranets. {% endblocktrans %}


Satellite Data Processing¶
Overview¶
CoastWatch generates files containing gap-free satellite data fields for use in the HABS NowCast and ForeCast model of Anderson and Kudela in support of Phase 2 of NASA grant #NNX14AC42G, “Merging Satellite and Numerical Model Data in the California Current to Create Continuous Imagery and Forecasts of Harmful Algal Blooms.” The process is broken down operationally into three basic steps:
- Downloading NASA L2 files
- Processing the L2 files to generate gridded daily files for the chlorophyll, rf488 nm,and rf555 nm bands.
- Using a DINEOF routine to create gap-free data fields for chlorophyll, rf488 nm,and rf555 nm bands.
The coordination of three steps is manage from a control script, nowcast_control.py, that progressively calls scripts and functions from a custom module library.
Step 1: Downloading NASA L2 files¶
The script ftpHabsNasa.py lists the MODIS OC files available from R. Kudela’s NASA subscription FTP site. This list is compared to the files stored on the CoastWatch THREDDS server. Files not on THREDDS are downloaded to a CoastWatch web facing server and then are SCP’ed to THREDDS.
Step 2: Gridding and compositing L2 files¶
Two processes using SEADAS programs to process NASA MODIS OC files to daily gridded band files. In Step 3 the daily gridded band files are assembled fore use in a EOF gap filling routine.
- In the script makeL2bFile(), swath data processed to L2B gridded, daily files using SEADAS l2bin.
- In the script makeL3File(), daily gridded data for each band (chlorophyll, rf488, rf555) are extracted from the L2b files and saved our as separate file using SEADAS l3mapgen.
Step 3: Filling data gaps with DINEOF¶
The EOF gap filling script, filled_satellite_data(), contains the following major processes:
- Data Assembly: The script assembles chlorophyll, rf488, and rf555 data for the last 180 days and saves them into separate netCDF3 file along with a land mask.
- DINEOF Gap Filling: A DINEOF is run on the chlorophyll, rf488, and rf555 data stored in the netCDF3 file and the filled data fields are added as new variables to the netCDF3 files.
- Downsampling: The filled fields from the netCDF files are loaded, downsampled to ROMS resolution, and stored together in a new netCDF4 file.
- Distribution:The netCDF4 file is make available online for further processing.
Control script regulates processing steps¶
The control script, nowcast_control.py, manages the three basic step for processing the satellite data for the HABs nowcasting and forecasting project by calling scripts and functions from a custom module library.


Workshop Proposal Template
Download a Word version of this template here.
RSS 2016 WORKSHOP PROPOSAL TEMPLATE
Workshop Title
Workshop Organizers
Type of Event: [e.g., workshop, tutorial, competition, demonstration]
Duration: [e.g., 1/2 day, 1 day]
Event URL: [This link should be active at the time of the proposal with preliminary or tentative information. The page should clearly indicate that it is a "Proposed RSS Event".]
Organizers:
[Please provide email addresses, URLs and affiliations. Furthermore, indicate which one of the organizers will act as the primary contact person. The expectation is that the primary contact person will be able to promptly respond to messages from the workshop co-chairs.]
Abstract:
[This should be a short paragraph that will be used to advertise the workshop through the web page of RSS. Please limit the abstract to 250 words. The abstract will be used to describe the workshop on the RSS website.]
List of speakers/participants:
[Provide a list of speakers and potential topics, if available. Indicate whether speakers have been confirmed or that their final confirmation is pending.]
Event Schedule and Description:
[Please provide details regarding the event, such as intended schedule and structure, e.g., discussion. What steps will you take in order to encourage discussion and interactions during the event?]
Plan for soliciting participation:
[Describe what steps you will take in order to advertise and encourage participation in your event. Steps in this direction that go beyond forwarding an email to research-worldwide are encouraged.]
Intended audience:
[Provide a description of the communities that will be interested in this event and why you believe they will attend. Indicate whether communities related to robotics that are not traditionally participating at RSS would be interested in your event. Mention related past events, if any, and their level of success.]
Equipment and room requirements:
[e.g., whether you plan to have posters - how many do you expect to need? Flip charts - how many? Please list everything that requires logistics or monetary effort from our side]


Here I summarise learnings from lesson 1 of the fast.ai course on deep learning. fast.ai is a deep learning online course for coders, taught by Jeremy Howard. Its tag line is to “make neural nets uncool again”. I started the class a couple of days ago and have been impressed with how fast it got me to apply the methods, an approach described by them as top-down learning. I am writing this blog post to document and reflect on the things that I learned and to help other people that may be interested getting started with the class.
The fast.ai library is a high-level library based on PyTorch, which tries to take a selection of best-practice approaches from cutting edge deep learning research and make them into a collection of intelligent default settings.
Lesson 2 outlined the fundamentals of computer vision and building image classification models. My homework: get my hands on my own image dataset and use it to train a classifier myself. I chose to attempt a classifier that can distinguish between sharks and dolphins, using images from google image search. Read along for a detailed walk through below.
This handy tool allows us to get images directly from google image search.
bash
$ pip install google_images_download
For more than 100 images we also need to install chromedriver and dependencies:
bash
$ apt-get install python-selenium python3-selenium libxi6 libgconf-2-4 chromium-chromedriver
Note that I had some problems with accessing the chrome driver from jupyter
notebooks. Changing ownership of the file with
chmod 777 /usr/local/bin/chromedriver
solved this for me.
Now we can run a query for images. Results are named as the number of the result
plus the original file name, downloaded, and saved locally. Note that you
should make sure to utilise the usage_rights
flag in order to get images
that are cleared for this type of use.
```python from google_images_download import google_images_download
os.chdir(‘/home/paperspace/data/sharksdolphins/’) response = google_images_download.googleimagesdownload()
arguments = { “keywords”: ‘“shark”,”dolphin”’, “print_urls”: False, “limit”: “10000”, “output_directory”: “sharksdolphins/train/”, “format”: “jpg”, “usage_rights”: “labeled-for-nocommercial-reuse”, “chromedriver”: “/usr/local/bin/chromedriver” }
response.download(arguments)
def image_rename(file): file_index = re.match(r’\A\d*’, file).group(0) file_index = file_index.zfill(3) return file_index+’.jpg’
def image_rename_all(folder): files = os.listdir(folder) [os.rename(folder+file, folder+image_rename(file)) for file in files]
folders = [‘data/sharksdolphins/train/shark/’, ‘data/sharksdolphins/train/dolphin/’] [image_rename_all(folder) for folder in folders] ```
The above query returned about 800 images each. I ended up speeding through these images manually and removing unsuitable images manually.
We need a training and a validation set. Making this work with fast.ai is easily
done by adapting the recommended folder structure of a data
folder with two
sub-folders (train
and valid
), each of which have a subfolder with images
for each class.
The code chunk below takes the images downloaded earlier and randomly splits them into 80% training data and 20% validation data. Don’t forget to set a random seed so that your results stay reproducible.
```python # split files into test and training set# split PATH = ‘data/sharksdolphins/’ files_sharks = os.listdir(f’{PATH}train/shark’) files_dolphins = os.listdir(f’{PATH}train/dolphin’)
np.random.seed(1234) files_sharks_val = np.random.choice( files_sharks, size=round(len(files_sharks) / 5), replace=False, p=None) files_dolphins_val = np.random.choice( files_dolphins, size=round(len(files_dolphins) / 5), replace=False, p=None)
[os.rename(PATH+’train/shark/’+file, PATH+’valid/shark/’+file) for file in files_sharks_val] [os.rename(PATH+’train/dolphin/’+file, PATH+’valid/dolphin/’+file) for file in files_dolphins_val] ``` As you will see, collecting the data was the hardest part and everyting from here onward is quite straight-forward thanks to the high level abstractions provided by fast.ai
Now we can finally start to train our image classifier. I am using a paperspace instance with the setup recommended and provided by fast.ai.
Train a First Model
```python os.chdir(‘/home/paperspace/’) # append fast.ai local folder to system path so modules can be imported sys.path.append(‘/home/paperspace/fastai/’) # automatically reload updated sub-modules %reload_ext autoreload %autoreload 2 # in-line plots %matplotlib inline
from fastai.imports import * from fastai.transforms import * from fastai.conv_learner import * from fastai.model import * from fastai.dataset import * from fastai.sgdr import * from fastai.plots import * ```
python
# set path of data folder
PATH = "data/sharksdolphins/"
# set size images should be resized to
sz = 224
# First model
arch = resnet34
data = ImageClassifierData.from_paths(PATH, tfms=tfms_from_model(arch, sz), bs=16)
learn = ConvLearner.pretrained(arch, data, precompute=True)
Jeremy explained the learning rate finder that uses the approach of cyclical
learning rates as outlined by Leslie Smith (https://arxiv.org/abs/1506.01186).
Using the lr_find
method and then plotting the learning rate against loss.
We now want to visually choose the “The highest learning rate we can find where
the loss is still clearly improving”. Note here that the learning rate finder
did initially not work so well for my small-ish dataset. I had to adjust the
batch size to make it work correctly
(see bs=16
argument in the ImageClassifierData
call above)
python
learn.lr_find()
learn.sched.plot_lr()
python
learn.fit(0.01, 5)
| epoch | trn_loss | val_loss | accuracy |
|---|---|---|---|
| 0 | 0.435999 | 0.267501 | 0.925 |
| 1 | 0.3081 | 0.29459 | 0.9 |
| 2 | 0.2548 | 0.235716 | 0.925 |
| 3 | 0.214654 | 0.229093 | 0.93125 |
| 4 | 0.237024 | 0.162347 | 0.9375 |
Over 93% accuracy! Really nice results already!
Let’s see if we can improve things even further.
Train a Second Model
Now let’s start training some of the lower layers and retraining these with differential learning rate. Jeremy talks about unfreezing here, but a friend that I talked to about this called it thawing instead, and I like that terminology, as it implies the differential learning rates with fast-changing weights at the last layer but slower updates in the lower layers.
python
# unfreeze pretrained layers
learn.unfreeze()
# set differential learning rate
lr = np.array([1e-4,1e-3,1e-2])
# train new model
learn.fit(lr, 3, cycle_len=1, cycle_mult=2)
| epoch | trn_loss | val_loss | accuracy |
|---|---|---|---|
| 0 | 0.475365 | 0.365881 | 0.89375 |
| 1 | 0.278049 | 0.177107 | 0.94375 |
| 2 | 0.174708 | 0.178467 | 0.95 |
| 3 | 0.120919 | 0.230777 | 0.95625 |
| 4 | 0.093978 | 0.148054 | 0.95625 |
| 5 | 0.081571 | 0.200582 | 0.95 |
| 6 | 0.055903 | 0.198029 | 0.95 |
A little bit better yet. Let’s look at the confusion matrix and some of the misclassified images:
```python # get predictions and transform to class probability values log_preds = learn.predict() preds = np.argmax(log_preds, axis=1) probs = np.exp(log_preds[:,1])
from sklearn.metrics import confusion_matrix cm = confusion_matrix(data.val_y, preds) plot_confusion_matrix(cm, data.classes) ```
We should also plot some of the images to develop an intuition about where our classifier does well and where it doesn’t. Here is the one misclassified dolphin and the top 4 misclassified sharks:
You can see that we got some pretty strong results in a very short amount of time and using a very limited dataset! There is obviously many more things that could be done to improve this model further.
Weighting the Classes
In our example of sharks and dolphins, we are currently treating all misclassifications equally. This may not be the right approach! If the model was used to monitor a beach for sharks, for example, failing to recognize a dolphin would not be a problem, while failing to recognize a shark could potentially result in human fatalities. In this case, it might be advisable to retrain the model with a biased weighting function to make sure our recall on shark images is higher.
Data Leakage
Looking at images that were misclassified or low-confidence predictions, I realised that my training set introduced a number of hidden biases to the model. For example, a number of dolphin pictures have people in them that are touching the dolphin. This is less prevalent with the shark pictures, for obvious reasons. As a result, the few shark pictures with human arms and hands in them and near the shark seem to end up with lower confidence for the shark class. For the only misclassified dolphin in the dataset, on the other hand, I think that the shark-like pose (frontal, widely opened mouth) may have played a role in the model mistaking this image for a shark image.
This kind of data leakage is increasingly discussed and criticised in deep learning applications, so it is good to be aware and keep an eye out for them. Since my model is not going into production for Baywatch any time soon, I am just glad I found it nicely illustrated in this relatively small dataset.