Input Control
The input_control module contains rules that affect forms, input elements, buttons, checkboxes and radio buttons. All of these elements' styles are predefined, allowing you to create modern, responsive forms quickly. Layout alternatives are also provided if you want your forms to look a certain way.
All examples showcased refer to the mini-default flavor, some class names and styles might differ based on the flavor you're using.
Quick overview
The presentation of forms, input fields, buttons and other interactive elements is always very important for any website or app. The input_control module provides you with much needed styling improvements for all of these elements, while keeping everything simple to use and understand, as well as combine with the other modules. Forms and input elements have a clean, modern design, while some elements like checkoxes and radio buttons get a much needed facelift. Buttons have also been stylized to look the same in all browsers, while keeping their design clean and allowing for a few color and size variants. Grouping inputs and labels or buttons is also part of this module and, as always, responsiveness is an important feature. Finally, all of the components are accessible, with a few minor caveats, that are discussed in their respective section in this page.
Quick start
To use the input_control module, simply include the link to the flavor you are using and start writing your HTML page as usual. One suggestion we will make is to add the following line inside your HTML page's
to utilize the viewport meta tag:
<meta name="viewport" content="width=device-width, initial-scale=1">
Forms & input
Forms are structured the same way you would structure a normal form in HTML5. Simply create a root <form>
element and add your <input>
elements inside. Link them to
elements for ease of access and you are pretty much set. We highly recommend using the <fieldset>
and <legend>
elements to annotate your forms as well, but you can skip them if you wish.
Forms are inline by default. Use the .input-group
class on a

wrapping inside it an <input>
and
pair to make sure they always display together in one line. You can make your .input-group
s respond to viewport changes, by adding the .fluid
class to them or you can align them vertically by adding the .vertical
class. Finally, if you want to create aligned forms with a preset layout, you can utilize the grid module's rows and columns.
Sample code
<form> <fieldset> <legend>Simple form</legend>
 Username <input type="email" value="" id="username" placeholder="username">

 Password <input type="password" value="" id="pwd" placeholder="password">

 Number <input type="number" id="nmbr" value="5">
 </fieldset> </form>
Notes
- Using the
<fieldset>
and<legend>
elements is highly recommended for a better presentational effect. Using these elements is a matter of personal preference, however try to keep your forms consistent (i.e. either use them in all forms or no forms as to not confuse users). - Some
<input>
elements, such as date & time, color and range types, are not supported and, as a result, do not have a default style defined for them. You can define said styles manually if you need to use them in your website or app. - Checkboxes and radio buttons are not stylized the same way as most of the other elements, nor do they follow the exact same stucture for layout. Please refer to the next section for information on how to use those.
- Try not to combine the grid module's classes with
.fluid
or.vertical
.input-group
s, as this might cause certain styles to overlap and not display exactly like you want them to.
<form> <fieldset> <legend>Responsive form</legend>

 username

 <input type="email" value="" id="username" placeholder="username">

 password

 <input type="password" value="" id="pwd" placeholder="password">

 </fieldset> </form>
Do: You can use .row
and .col-SCR_SZ
or .col-SCR_SZ-COL_WD
(replacing SCR_SZ
with one of the available screen size names (sm
for smaller screens, md
for medium-sized screens or lg
for larger screens and COL_WD
with a number from 1
to 12
specifying the width of the column) to set specific layouts for your aligned forms. You can also use the same column classes to make them responsive for different screen sizes.
<form> <fieldset> <legend>Responsive form</legend>

 username <input type="email" value="" id="username" placeholder="username">

 password <input type="password" value="" id="pwd" placeholder="password">

 </fieldset> </form>
Do: Apart from using .row
and .col-SCR_SZ
or .col-SCR_SZ-COL_WD
for responsiveness, you can also use other classes from the grid module such as the offset classes to make your form layouts more interesting.
 <form> <fieldset> <legend>Responsive form</legend>

 username

 <input type="email" value="" id="username" placeholder="username">

 </fieldset> </form>
Do: When creating aligned forms using the grid module's classes, labels might be off-center vertically compared to their inline counterparts. Use a simple styling for their parent .row
element, if you want to adjust their vertical alignment.
<form> <fieldset> <legend>Responsive form</legend>

 username

 <input type="email" value="" id="username" placeholder="username">

 </fieldset> </form>
Don't: Avoid using the .input-group
class when creating aligned forms. This might cause unexpected behavior.
Checkboxes & radio buttons
Checkboxes and radio buttons come pre-styled, using the checkbox hack, while remaining fully accessible. To create a checkbox or radio button, start using a

that implements the .input-group
class, and then add an <input>
of the proper type
inside it ("checkbox"
or "radio"
), followed immediately by a
linking to it. Remember to add tabindex="0"
to your <input>
, so that it will register properly for screen readers.
Sample code

 <input type="checkbox" id="check1" tabindex="0"> Checkbox

 <input type="radio" id="rad1" tabindex="0" name="radio-group-1"> Radio

Notes
- Checkboxes and radio buttons are fully accessible. However, if not provided with a label, they are not visible to users, but only to screen readers.

 <input type="radio" id="rad1" tabindex="0" name="radio-group-1"> Value 1 <input type="radio" id="rad2" tabindex="0" name="radio-group-1"> Value 2

Do: You can add multiple radio
buttons inside one .input-group
, as long as they follow the syntax shown above. In fact, we strongly recommend grouping controls that are relevant to each other in this manner.
<input type="checkbox" id="check1" tabindex="0"> Checkbox
Don't: Always use an .input-group
for your checkboxes and radio buttons. Not doing so will cause the checkbox or radio button to not display properly.

 <input type="checkbox" id="check1" Checkbox

Don't: Remember to add tabindex="0"
to all your checkboxes and radio buttons to make them accessible.

 Checkbox <input type="checkbox" id="check1" tabindex="0">

Don't: The structure of checkboxes and radio buttons is very strict, meaning that the
should always be after the <input>
and never before, otherwise the checkbox or radio button will not display properly.

 <input type="radio" id="rad1" tabindex="0" name="radio-group-1"> <input type="radio" id="rad2" tabindex="0" name="radio-group-1"> Value 2 Value 1

Don't: When using multiple radio buttons inside an .input-group
, remember to use the usual structure of the radio button component for each radio button (i.e. the <input>
and
). Not doing so will cause the radio buttons to not display properly.

 <input type="checkbox" id="check1" tabindex="0">

Don't: Never leave a checkbox or radio button without a
. The
is essential to properly display the checkbox or radio button.
Switches
Switches are almost identical in structure to checkboxes and radio buttons (an .input-group
containing an <input>
of the proper type
inside it ("checkbox"
or "radio"
), followed immediately by a
linking to it), their only difference being that you need to add the .switch
class to
element to turn your input into a switch. Remember to apply tabindex="0"
to your <input>
to make it accessible.
Sample code

 <input type="checkbox" id="switch1" tabindex="0"> Checkbox switch

 <input type="radio" id="radswitch1" tabindex="0" name="radio-group-1"> Radio switch

Notes
- You can create your own color variants for the
.switch
component. For more information, check out the customization page.

 Switch with text on its left <input type="checkbox" id="switch1" tabindex="0">

Do: By using two
elements, you can move the actual .switch
to the right of the label's text, effectively allowing you to change the layout. Remember to not add any text to your second
that implements the .switch
class. You might want, however, to add a few trailing spaces to the first
element to make sure the text does not get covered by the component.
Buttons & button groups
Button group
All button types have been stylized by default, while maintaining accessiblity. Simply add any <button>
or an <input>
with a button type
(i.e. "button"
, "submit"
or "reset"
) and they will be styled accordingly. You can also use the .button
class or the role="button"
attribute for links, labels and other elements of your choice to make them look like buttons.
Color variants are available in the form of the .primary
, .secondary
, .tertiary
and .inverse
classes. Size variants are available as well in the form of .small
and .large
classes.
Finally, you can create responsive groups of buttons by wrapping them inside a

with the .button-group
class.
Sample code
<button>Default button</button> <input type="button" class="primary" value="Primary button"> <input type="reset" class="secondary" value="Secondary button"> <input type="submit" class="tertiary" value="Tertiary button"> <button class="inverse">Inverse button</button> <button class="small">Small button</button> <button class="large">Large button</button> <button disabled>Disabled button</button> Link button Link button Label button Label button
 <button>Button</button> <button>Button</button> <button>Button</button>

Notes
- If you want more color or size variants for your buttons, check out the customization page.
- The
.button-group
component is compatible with modern browsers, but might not display properly in older browsers. .button-group
s will display as a horizontal container with all their buttons in one row on medium-sized and larger displays, however they will collapse into a column view for smaller displays.
<button class="inverse small">Small inverse button</button>
Do: You can mix and match button color and size variants to achieve the desired effect.
<button class="secondary inverse">Problematic button</button>

<button class="small large">Problematic button</button>
Don't: Avoid mixing two or more button color or size variants, as these combinations might result in unexpected behavior.

 <button>Button</button> <input type="reset" class="secondary" value="Secondary button"> Label button

Do: You can use button color variants inside the same .button-group
. You can also use any component styled like a button inside a .button-group
.

 <button class="large">Button</button> <button>Button</button> <button class="small">Button</button>

Don't: Avoid using button size variants inside a .button-group
, as this might result in unexpected behavior.
File upload buttons
File upload buttons are commonly a sore spot in CSS frameworks. We try to remedy this problem by hiding the <input type="file">
, while maintaining accessibility and using a linked
of the .button
class to display it in a modern way.
Sample code
<input type="file" id="file-input"> Upload file...
Notes
- The icon displayed in the example above is not part of the button styling.
- File upload buttons do not change their text to the name of the file after the user has selected a file to upload. You can, however, add this functionality using a few lines of Javascript.
- File upload buttons cannot be focused (i.e. have a
:focus
state) using the keyboard and this applies to linked labels, too. You can use Javascript to add this functionality, if you wish.

 <input type="file" id="file-input"> Upload file...

Do: You can use an .input-group
to wrap the file upload <input>
and its linked
, if you wish.
If you want to learn more about mini.css's modules, go back to the modules page and choose another module to see its documentation.


{% extends "editor/editor_base.html" %} {% block editor_content %} {# NOTE: requires suggestions_and_journals.js to be enabled (see _js_includes.html) #} {# include the title and the "unlock and close" feature #} {% set object_type = 'journal' %} {% set heading_object_type = 'Journal' %} {% include 'formcontext/_lockable_header.html' %}
{% endblock %} {% block extra_js_bottom %} {% endblock extra_js_bottom %}


On this website you will find information reagrding Burnside Highs schools robotics club.
You will be able to find out about our robots we have used for the past years as well as our teams and mecahnisims used.
To edit some of the information you can use the table editor.


Twitter accuses UK of misleading public in election row
Twitter accuses Britain's Conservatives of misleading the public by rebranding themselves as fact-checkers during a live television debate
by Agence France-PresseSubscribe
Email Address
Newsletters
- Glenda Gloria's Take this Tuesday
- Huddle by Miriam Grace Go
- The Newsbreak Agenda by Chay Hofileña
- Sometimes, all you need is video by Lilibeth Frondoso


Currently, there are a few projects being carried out by UCL but here we have decided to focus on one - Digital Music Labs.
Digital music labs is a Digital Transformations project that is carried out in UCL. It aims to develop software that explores and analysis music collections. It also aims to provide researchers with tools to analyse music audio, scores and metadata.
One of these tools is the DML web interface. It can explore, analyse and compare music collections and recordings from the British Library’s Sound Archives, CHARM and I Like Music. It can be used to compare data between different composers, for example you can compare which keys composers tend to use. You can compare qualities such as tempo, key and relative chord sequences. It also allows you to compare individual pieces.
Another is a chord sequence visualisation tool. It produces a geometric representation of chord progressions. DML has extracted chord sequence patterns from over a million tracks to use as data. It creates a visual aid to explore the data.
One project that the Digital music lab is working on is the “An Integrated Audio-Symbolic Model of Music Similarity”. This project aims to use the tools created form the DML project to answer the question of what contributes to the similarity of music.
Want to find out more?
This link will provide more information and leads direct to our source!
Digital Music Lab Home Page
Still wondering about other research?
Most pages within this site has a research section which details research that had been done or is currently being done.
Check out CoRE for instance here.


Chocolate Pizza
POSTED ON 15 DEC 2013 / DESSERTS
PRINT
For the fit-swirl: Melt butter over medium heat in a saucepan. Add brown sugar and stir to dissolve. Halve all of the figs and toss in the saucepan with water and lemon juice. Cook over medium heat, strirring frequently, until you have a chunky-jammy mixture. Add salt with one or two stirs, set aside and let cool completely.
Ice cream: in a small pot over medium heat, combine milk, and granualted sugar until sugar is completely dissolved and the milk is just barely lukewarm. Whisk in the egg yolks. Set mixture in the fridge and wait until the fig mixture is cooled.
Using an ice cream machine, pour liquids into the frozen basin and process according to manufacturer instructions, i.e., let spin and thicken for 20 minutes before adding mascarpone, fig jam mixture, and the nuts. Continue to process for ⁺⁄₋ 10 minutes. Pour semi-frozen mixture into a pyrex dish or glass tupperware. Freeze for at least two hours before serving.
- 1 1/2 cups milk
- 1/2 cup mascarpone
- 1/2 tsp pink salt
- 1lb Black Mission Figs
- 1/2 cup brown sugar
- 2-4 tbsp water
- 1 1/2 cups heavy cream
- 4/3 granulated sugar
- 2 eggs yolks
- 1 lemon, juiced
- 2 tsbp butter
- 1 cup honey roasted peacons, roughly
chopped


Student Information
First Name
Last Name
Gender
Male
Female
Email
Date Of Birth
Contact
Nationality
Religion
Mothertounge
Father Name
Father Occupation
Mother Name
Mobile
Landline
Permanent Address
State
Select State
{{sts.statename}}
City
Select City
{{ct.cityname}}
Country


Got an iPhone or iPad?
Get real-time results with Meet Mobile, a free app or
HY-TEK Real Time Results
Select an event from the index on the left.
If a result is not completed yet, click another
event or use the Back button to return to the
index page.


Vendor Name:
FRISCHKORN ASSOCIATES INC.
Reference Number:
4000871
Contract Date:
2016-20-04
Description of Work:
0332 AUDIO-VISUAL SERVICES
Contract Period:
2016-20-04 to 2016-31-05
Delivery Date:
2016-31-05
Original Contract Value:
$26,922.83
Current Contract Value:
$28,710.69
Comments:
This contract is a call-up against a Public Services and Procurement Canada procurement tool.
Former Public Servant in Receipt of a Pension under the Public Service Superannuation Act:
no


Song Selection
0" class="song">
{{track.name}}
{{track.artists[0].name}}
{{track.album.name}}
{{currentTrack.name}}
{{currentTrack.album.name}}
Playback
{{textStatus}}
{{currentSong}}


stream_property/2
stream_property/2 – retrieve streams and their properties
FORMS
stream_property(Stream,Property)
DESCRIPTION
stream_property/2 is used to retrieve information on a particular stream. It may also be used
to find those streams satisfying a particular property.
Stream may be either an input or output argument. If used as an input argument it
should be bound to either a stream descriptor as returned by open/4 or an alias established in a call to open/4. If used as an output argument, Stream will only be bound to stream descriptors. This predicate may be used to
retrieve those streams whose handles were "lost" for some reason.
Property is a term which may take any of the following forms:
file_name(F) – When the stream is connected to a source/sink which is a file, F will be
the name of that file.
stream_name(N) – N is unified with the name of the source/sink regardless of whether the stream
is connected to a file or not.
mode(M) – M is unified with the I/O mode which was specified at the time the stream
was opened.
input – The stream is connected to a source.
output – The stream is connected to a sink. It is possible for a stream to have
both input and output properties.
alias(A) – If the stream has an alias, A will be unified with that alias.
position(P) – If the stream is repositionable, P will be unified with the current
position in the stream.
end_of_stream(E) – If the stream position is located at the end of the stream, then E is unified with 'at'. If the stream position is past the end of stream, then E is unified with 'past'. Otherwise, E is unified with 'no'. In the current implementation of ALS Prolog, querying about the end_of_stream property may cause an I/O operation to result which may block.
eof_action(A) – If the stream option eof_action(Action) was specified in the options list when the stream was opened, then A will be unified with this action. Otherwise, A will be unified with the default action appropriate for the stream.
snr_action(A) – If the stream option snr_action(Action) was specified in the options list when the stream was opened, then A will be unified with this action. Otherwise, A will be unified with the default action appropriate for the stream.
reposition(R) – If positioning is possible on this stream then R is unified with true; if not R is unified with false.
type(T) – T will be unified with either text or binary, indicating the type of stream.
maxdepth(D) – D will be unified with the default depth with which terms are written to.
depth_computation(DC) – DC will be unified with the atom indicating the method of depth computation when
writing out terms.
line_length(L) – L will be unified to the default line length parameter which is used for
determining where line breaks should be placed when writing terms.
EXAMPLES
Open 'foo' for write, but "lose" the stream descriptor.
?- open(foo,write,_).
Use stream_property to retrieve the stream descriptor and close it.
?- stream_property(S,file_name(foo)), close(S).
S = stream_descriptor('',closed,file,foo,[noinput|output],true,
1,0,0,0,0,true,0,wt_opts(78,40000,flat),[],true,text,
eof_code,0,0)
Open 'foo' for read with an alias.
?- open(foo,read,_,[alias(foo_alias)]).
Call stream_property to find out where end-of-stream is. Note that foo was
created as the empty file above.
?- stream_property(foo_alias,end_of_stream(Where)).
Where = at
Call stream_property again to find out about the end-of-stream.
?- stream_property(foo_alias,end_of_stream(Where)).
Where = past
Call stream_property to find out the name of the file associated with the
alias.
?- stream_property(foo_alias,file_name(Name)).
Name = foo
Get all of the names attached to streams.
?- setof(N,S^stream_property(S,stream_name(N)),L).
N = N
S = S
L = ['$stderr','$stdin','$stdout',foo]
SEE ALSO
open/4, close/1, set_stream_position/2, at_end_of_stream/1,
set_line_length/2, User Guide (Prolog I/O).


Preparing the data¶
Required files¶
In order to run fivepseq, the following files are required:
This section is to help you generate alignment bam files from your fastq files. If you already have alignment, genome and annotation files you may skip this section and proceed to fivepseq downstream analysis.
Finding genome and annotation files¶
There are multiple resources which maintain and distribute genome sequence and annotation data, for instance Ensembl, RefSeq, and SGD. However, the naming conventions and format may differ slightly depending on the resource. For this reason, your genomic sequence and annotation files should be retrieved from the same database.
!!NOTE!! If you start from alignment files, make sure that the annotation and genome files you provide to fivepseq for downstream analysis are the same as those used during alignment.
Preprocessing fastq files¶
Fastq files need to be preprocessed and aligned to the reference genome before proceeding to fivepseq downstream analysis. Preprocessing proceeds with the following steps:
- quality checks (with FASTQC and MULTIQC),
- adapter and quality based trimming,
- UMI extraction (if the library was generated with UMIs),
- mapping to reference
- read deduplication (if the library was generated with UMIs),
- generation of bedgraph files to visualize 5’P counts in genome viewer
An example of pre-processing pipeline can be found in the preprocess_scripts/fivepseq_preprocess.sh directory in your fivepseq installation folder, and can also be downloaded from here.
In order to run this pipeline, you need to have access to common bioinformatics software such as STAR, UMI-tools, bedtools, Samtools, FastQC, MultiQC and cutadapt.
To use it, navigate to the directory where the script is located and use the following command in the prompt:
./fivepseq_preprocess.sh \
-f [path to directory containing fastq files] \
-g [path to genome fasta] \
-a [path to annotation gff/gtf] \
-i [path to reference index, if exists] \
-o [output directory] \
-s [which steps to skip: either or combination of characters {cudqm} ]
Note: this should be a single-line command or the backslashes should be properly indented.
The option -s
specifies which steps of the pipeline you’d like to skip. Possible values are:
- c skip trimming adapters with cutadapt
- u skip UMI extraction
- d skip deduplication after alignment
- q skip quality check: FASTQC and MULTIQC
- m skip mapping
You may use any combination of these characters, e.g. use -s cudqm
to skip all
This script will produce subfolders in the output directory, containing results of each step of the pipeline. The bam files will be generated in the align_dedup folder.
In addition to performing the steps described above, it also evaluates the distribution of reads across the genome, according to gene classes {“rRNA” “mRNA” “tRNA” “snoRNA” “snRNA” “ncRNA”}. These statistics are kept in the align_rna/rna_stats.txt file.
!!NOTE!! This example pipeline treats files as singl-end libraries. If you have paired-end reads, you should only supply the first read (*_R1* files) to fivepseq.
Test data¶
You may download the preprocessing test dataset for yeast from here to start with the following fastq to bam preprocessing pipeline. The archive contains subsetted fastq files from Saccharomyces Cerevisiae (first 100K reads), as well as genome fasta and annotation gff files. If you use another organism, you may refer to the following section to find needed genome files.
The src folder in the test data contains a script named preprocess_test.sh, which contains the following command:
./src/fivepseq_preprocess.sh \
-f fastq \
-o preprocess \
-g genome/* \
-a gff/*
Navigate to the test data directory and give it a try by running ./src/preprocess.sh
. It should generate the following folders in the preprocess directory:
| fastqc_raw: | FASTQC reports on the fastq files before preprocessing |
|---|---|
| multiqc_raw: | MULTIQC report on the fastq files before preprocessing |
| fastq_trimmed: | fastq files with standard illumina adapters :fastq_deumi: fastq files with UMI sequences extracted from the reads and placed in the read headers. Use -s ud if your data does not contain UMIs. |
| fastqc: | FASTQC reports on the fastq files after trimming and UMI extraction |
| multiqc: | MULTIQC report on the fastq files after trimming and UMI extraction. |
| star_index: | the reference genome index generated by STAR. Use -i star_index option in the future runs to use the already generated index. |
| star_align: | alignment bam files |
| align_dedup: | alignment bam files after UMI-based deduplication. These are the final files you should give as input to fivepseq. |
| filtered_gff: | annotation files filtered by RNA content, used for overlapping with bam files to analyze RNA content (see below). |
| align_rna: | bam files, filtered for the {“rRNA” “mRNA” “tRNA” “snoRNA” “snRNA” “ncRNA”} classes of RNA and the rna.stats.txt file that summarized the read counts for each RNA class. |
| bedgraph: | two bedtraph files for 5’P endpoints mapping to fwd and rev strands for each bam file |


(For a full list see below or go to Google Scholar)
The proposed algorithm significantly reduces the need for stabilization in the state-of-theart FIRM (Feedback-based Information RoadMap) method. Thus, designing computationally tractable algorithms, a key focus and contribution of this paper is to implement the proposed planner on a physical robot and show the SLAP (simultaneous localization and planning) performance under uncertainty, in changing environments, and in the presence of large disturbances such as kidnapped robot situation.
Ali-akbar Agha-mohammadi et al.
Decentralized partially observable Markov decision processes (Dec-POMDPs) are general models for multi-robot coordination problems, but representing and solving Dec-POMDPs is often intractable for large problems. To allow for a high-level representation that is natural for multi-robot problems and scalable to large discrete and continuous problems, this paper extends the Dec-POMDP model to the decentralized partially observable semi-Markov decision process (Dec-POSMDP).
Shayegan Omidshafiei, Ali-akbar Agha-mohammadi, Christopher Amato, Shih–Yuan Liu, Jonathan P. How and John Vian
We show that in addition to achieving maps that are often more accurate than tradition methods, the proposed filtering scheme demonstrates a much higher level of consistency between its error and its reported confidence. This allows the planner to reason about acquisition of the future sensory information.
Ali-akbar Agha-mohammadi
In this paper we present feedback-based information roadmap (FIRM), a multi-query approach for planning under uncertainty which is a belief-space variant of probabilistic roadmap methods. The crucial feature of FIRM is that the costs associated with the edges are independent of each other, and in this sense it is the first method that generates a graph in belief space that preserves the optimal substructure property.
Ali-akbar Agha-mohammadi, Suman Chakravorty and Nancy Amato
International Journal of Robotics Research (IJRR) (2014)
[Under Review]
Ali-akbar Agha-mohammadi et al.,
“SLAP: Simultaneous Localization and Planning for Physical Mobile Robots via Enabling Dynamic Replanning in Belief Space,”
IEEE Transactions on Robotics (TRO)
.
(pdf)
Shayegan Omidshafiei, Ali-akbar Agha-mohammadi, Christopher Amato, Shih–Yuan Liu, Jonathan P. How and John Vian,
“Decentralized Control of Partially Observable Markov Decision Processes using Belief Space Macro-actions,”
International Journal of Robotics Research (IJRR)
, vol. 36,
no. 2,
pp. 231-258,
2017.
(pdf)
Beipeng Mu, Liam Paull, Ali-Akbar Agha-Mohammadi, John J. Leonard and Jonathan P. How,
“Two-Stage Focused Inference for Resource-Constrained Collision-Free Navigation,”
IEEE Transactions on Robotics (TRO)
, vol. 33,
no. 1,
pp. 124-140,
2017.
(pdf)
Ali-akbar Agha-mohammadi, Suman Chakravorty and Nancy Amato,
“FIRM: Sampling-based Feedback Motion Planning Under Motion Uncertainty and Imperfect Measurements,”
International Journal of Robotics Research (IJRR)
, vol. 33,
no. 2,
pp. 268-304,
2014.
(pdf)
Bernard Michini, Thomas J. Walsh, Ali-akbar Agha-Mohammadi and Jonathan P. How,
“Bayesian Nonparametric Reward Learning From Demonstration,”
IEEE Transactions on Robotics (TRO)
, vol. 31,
no. 2,
pp. 369-386,
April
2015.
(pdf)
Ali-akbar Agha-mohammadi, Saurav Agarwal and Suman Chakravorty,
“Periodic-node Graph-based Framework for Stochastic Control of Small Aerial Vehicles,”
The ASME Journal of Dynamic Systems, Measurement and Control, Special Issue on Stochastic Models, Control and Algorithms in Robotics
, vol. 137,
no. 3,
pp. 031005,
2015.
(pdf)
Shayegan Omidshafiei, Ali-akbar Agha-mohammadi, Yufan Chen, Nazim Kemal Ure, Shih-Yuan Liu, Brett Lopez, Rajeev Surati, Jonathan P. How and John L. Vian,
“Measurable Augmented Reality for Prototyping Cyberphysical Systems: A Robotics Platform to Aid the Hardware Prototyping and Performance Testing of Algorithms,”
IEEE Control Systems Magazine (CSM)
, vol. 36,
no. 6,
pp. 65-87,
2016.
(pdf)
Ali-akbar Agha-mohammadi, Sandip Kumar and Suman Chakravorty,
Motion Planning under Uncertainty.
Book Chapter, J. Valasek (Ed.), Advances in Intelligent and Autonomous Aerospace Systems, Progress in Astronautics and Aeronautics, American Institute of Aeronautics and Astronautics (AIAA), Reston, VA,
2012.
[Under Review]
Ali-akbar Agha-mohammadi,
“Confidence-aware Occupancy Grid Mapping: Toward High-speed Vision-based UAV Navigation,”
.
(pdf)
Eric Heiden, Karol Hausman, Gaurav S. Sukhatme and Ali-akbar Agha-mohammadi,
“Planning High-speed Safe Trajectories in Confidence-rich Map,”
in International Conference on Intelligent Robots and Systems (IROS),
Vancouver, Canada,
September
2017.
(pdf)
Brian Ichter, Edward Schmerling, Ali-akbar Agha-mohammadi and Marco Pavone,
“Real-Time Stochastic Kinodynamic Motion Planning via Multiobjective Search on GPUs,”
in IEEE International Conference on Robotics and Automation (ICRA),
Singapore,
May
2017.
(pdf)
Beipeng Mu, Matthew Giamou, Liam Paull, Ali-akbar Agha-mohammadi, John J. Leonard and Jonathan P. How,
“Information-Based Active SLAM Via Topological Feature Graphs,”
in IEEE Conference on Decision and Control (CDC),
Las Vegas, NV,
December
2016.
(pdf)
Shayegan Omidshafiei, Ali-akbar Agha-mohammadi, Christopher Amato, Shih-Yuan Liu, Jonathan P. How and John L. Vian,
“Graph-based Cross Entropy Method for Solving Multi-Robot Decentralized POMDPs,”
in IEEE International Conference on Robotics and Automation (ICRA),
Stockholm, Sweden,
May
2016.
(pdf)
Beipeng Mu, Ali-akbar Agha-mohammadi, Liam Paull, Matthew Graham, Jonathan How and John Leonard,
“Two-Stage Focused Inference for Resource-Constrained Collision-Free Navigation,”
in Robotics: Science and Systems (RSS),
Rome, Italy,
July
2015.
(pdf)
Shayegan Omidshafiei, Ali-akbar Agha-mohammadi, Christopher Amato and Jonathan P. How,
“Decentralized control of Partially Observable Markov Decision Processes using belief space macro-actions,”
in IEEE International Conference on Robotics and Automation (ICRA),
Washington, Seattle ,
pp. 5962-5969,
May
2015.
(pdf)
N. Kemal Ure, Shayegan Omidshafiei, Brett Thomas Lopez, Ali-akbar Agha-mohammadi, Jonathan P. How and John Vian,
“Online heterogeneous multiagent learning under limited communication with applications to forest fire management,”
in International Conference on Intelligent Robots and Systems (IROS),
Hamburg, Germany,
pp. 5181-5188,
September
2015.
(pdf)
Shayegan Omidshafiei, Ali-akbar Agha-mohammadi, Yufan Chen, Nazim Kemal Ure, Jonathan P. How, John L. Vian and Rajeev Surati,
“Measurable Augmented Reality for Prototyping Cyber-Physical Systems (MARCPS),”
in AIAA Infotech,
Kissimmee, FL,
January
2016.
(pdf)
Ali-akbar Agha-mohammadi, N. Kemal Ure, Jonathan P. How and John Vian,
“Health aware stochastic planning for persistent package delivery missions using quadrotors,”
in International Conference on Intelligent Robots and Systems (IROS),
Chicago, IL,
pp. 3389-3396,
September
2014.
(pdf)
Ali-akbar Agha-mohammadi, Saurav Agarwal, Aditya Mahadevan, Suman Chakravorty, Daniel Tomkins, Jory Denny and Nancy Amato,
“Robust Online Belief Space Planning in Changing Environments: Application to Physical Mobile Robots,”
in IEEE International Conference on Robotics and Automation (ICRA),
Hong Kong, China,
May
2014.
(pdf)
Ali-akbar Agha-mohammadi, Suman Chakravorty and Nancy Amato,
“Sampling-based Stochastic Control with Constraints: A Unified Approach in State and Information Spaces,”
in American Control Conference (ACC),
Washington DC,
June
2013.
(pdf)
Ali-akbar Agha-mohammadi, Suman Chakravorty and Nancy Amato,
“Sampling-based nonholonomic motion planning in belief space via Dynamic Feedback Linearization-based FIRM,”
in International Conference on Intelligent Robots and Systems (IROS),
Vilamoura, Portugal,
October
2012.
(pdf)
Ali-akbar Agha-mohammadi, Suman Chakravorty and Nancy Amato,
“On the Probabilistic Completeness of the Sampling-based Feedback Motion Planners in Belief space,”
in IEEE International Conference on Robotics and Automation (ICRA),
Minneapolis, MN,
May
2012.
(pdf)
Ali-akbar Agha-mohammadi, Suman Chakravorty and Nancy Amato,
“FIRM: Feedback controller-based Information-state RoadMap -A Framework for Motion Planning Under Uncertainty-,”
in International Conference on Intelligent Robots and Systems (IROS),
SanFrancisco, CA,
September
2011.
(pdf)
Ali-akbar Agha-mohammadi and Dezhen Song,
“Robust recognition of planar mirrored walls using a single view,”
in IEEE International Conference on Robotics and Automation (ICRA),
Shanghai, China,
pp. 1186-1191,
May
2011.
(pdf)
Amirhossein Tamjidi, Hamid D. Taghirad and Ali-akbar Agha-mohammadi,
“On the consistency of EKF-SLAM: Focusing on the observation models,”
in International Conference on Intelligent Robots and Systems (IROS),
St. Louis, MO,
pp. 2083-2088,
October
2009.
(pdf)
Ali-akbar Agha-mohammadi, Amirhossein Tamjidi and Hamid D. Taghirad,
“A solution for SLAM through augmenting vision and range information,”
in International Conference on Intelligent Robots and Systems (IROS),
Nice,France,
pp. 1037-1042,
September
2008.
(pdf)
Ali-akbar Agha-mohammadi, Amirhossein Tamjidi and Hamid D. Taghirad,
“SLAM Based On the LRF Information as the Only Data Source,”
in International Federation of Automatic Control, (IFAC),
Seoul,Korea,
pp. 14657-14662,
July
2008.
(pdf)
Ali-akbar Agha-mohammadi, Amirhossein Tamjidi, Hamid D. Taghirad and Ehsan Mihankhah,
“Feature-Based Range Scan Matching for Accurate and High Speed Mobile Robot Localization,”
in European Conference on Mobile Robots (ECMR),
Freiburg, Germany,
pp. 253-258,
September
2007.
(pdf)
Eric Heiden, Karol Hausman, Guarav Sukhatme and Ali-akbar Agha-mohammadi,
“Safe Trajectory Generation using Confidence-rich Maps,”
in Southern California Robotics Symposium (SCR),
Los Angeles, CA,
April
2017.
(pdf)
Ali-akbar Agha-mohammadi,
“SMAP: Simultaneous Mapping and Planning on Occupancy Grids,”
in International Conference on Intelligent Robots and Systems (IROS), Workshop on Vision-based High Speed Autonomous Navigation of UAVs,
Daejeon, South Korea,
October
2016.
(pdf)
Christopher Amato, George Konidaris, Shayegan Omidshafiei, Ali-akbar Agha-mohammadi, Jonathan P. How and Leslie P. Kaelbling,
“Probabilistic Planning for Decentralized Multi-Robot Systems,”
in Sequential Decision Making for Intelligent Agents, AAAI fall symposium,
Arlington, VA,
November
2015.
(pdf)
Ali-akbar Agha-mohammadi, Shayegan Omidshafiei, Christopher Amato and Jonathan P. How,
“Graph-based Planning to Solve Multi-agent POMDPs,”
in Robotics: Science and Systems, Workshop on Distributed Control and Estimation for Robotic Vehicle Networks,
Berkeley, CA,
July
2014.
(pdf)
Ali-akbar Agha-mohammadi, Saurav Agarwal, Suman Chakravorty and Nancy M. Amato,
“Dynamic Closed-loop Replanning in Belief Space: Toward Handling Dynamically Changing Environments,”
in Robotics: Science and Systems, Workshop on Information-based Grasp and Manipulation Planning,
Berkeley, CA,
July
2014.
(pdf)
Ali-akbar Agha-mohammadi, Suman Chakravorty and Nancy Amato,
“Online Replanning in Belief Space for Dynamical Systems: Towards Handling Discrete Changes of Goal Location,”
in IEEE International Conference On Robotics and Automation (ICRA), Workshop on Combining Task and Motion Planning,
Karlsruhe, Germany,
May
2013.
(pdf)
Ali-akbar Agha-mohammadi, Suman Chakravorty and Nancy Amato,
“Medical Needle Steering under Motion and Sensor Noise using Feedback-based Information Roadmaps,”
in IEEE International Conference On Robotics and Automation (ICRA), Workshop on Medical Needle Steering,
Saint Paul, Minnesota,
May
2012.
(pdf)
Arash Kalantari, Ehsan Mihankhah and Ali-akbar Agha-mohammadi,
“Resquake, A Tracked Mobile Rescue Robot,”
in Rescue Robotics Camp, IEEE International Workshop on Safety Security and Rescue Robotics (SSRR),
Rome, Italy,
September
2007.
(pdf)
Ali-akbar Agha-mohammadi,
“Rollocopter: Novel Hybrid Aerial-Ground Vehicle for Failure-Resilient, Energy-Efficient, and Agile Mobility,”
Submitted to The United States Patent and Trademark Office
.
(pdf)
Zhaoyang Lv and Ali-akbar Agha-mohammadi,
“Holistic Planning with Multiple Intentions for Self-driving Cars,”
Submitted to The United States Patent and Trademark Office
.
(pdf)
Zhaoyang Lv, Ali-akbar Agha-mohammadi and Amirhossein Tamjidi,
“Motion Planning and Intention Prediction for Autonomous Driving in Highway Scenarios via Factor Graph Representation,”
Submitted to The United States Patent and Trademark Office
.
(pdf)
Ali-akbar Agha-mohammadi, Kiran Somasundaram and Saurav Agarwal,
“Measurement Fusion for 3D grid Mapping using cause-dependent inverse cause models,”
Submitted to The United States Patent and Trademark Office
.
(pdf)
Ali-akbar Agha-mohammadi et al.,
“Vision-based Autonomous Navigation System for Quadcopters,”
Submitted to The United States Patent and Trademark Office
.
(pdf)
Ali-akbar Agha-mohammadi et al.,
“RRF: Rapidly Exploring Randomized Feedback Trees for Robot Motion Planning,”
Submitted to The United States Patent and Trademark Office
.
(pdf)
Ali-akbar Agha-mohammadi et al.,
“Certainty-aware 3D Grid Map and Bayesian Update based on Stereo Vision,”
Submitted to The United States Patent and Trademark Office
.
(pdf)
Ali-akbar Agha-mohammadi et al.,
“Most Likely Map Computation based on Raw Stereo Vision Measurements,”
Submitted to The United States Patent and Trademark Office
.
(pdf)
Ali-akbar Agha-mohammadi et al.,
“Stochastic Map-aware Stereo-vision Sensor Model for Robot Navigation in Unknown Environments,”
Submitted to The United States Patent and Trademark Office
.
(pdf)
Ali-akbar Agha-mohammadi et al.,
“Robot Motion Planning and Exploration using Certainty-aware Stochastic Grid Maps,”
Submitted to The United States Patent and Trademark Office
.
(pdf)
Ali-akbar Agha-mohammadi et al.,
“Object-focused Active 3D Reconstruction using Monocular Camera: Application to Precision Robotic Grasping,”
Submitted to The United States Patent and Trademark Office
.
(pdf)
Ali-akbar Agha-mohammadi et al.,
“Active Camera Movement Determination for Object Position and Extent in Three-Dimensional Space,”
Submitted to The United States Patent and Trademark Office
.
(pdf)
Ali-akbar Agha-mohammadi et al.,
“Parallel Robot Motion Planning Under Uncertainty,”
Submitted to The United States Patent and Trademark Office
.
(pdf)
Jonathan P. How, John Vian, Shayegan Omidshafiei and Ali-akbar Agha-mohammadi,
“Cyber-Physical Systems Prototyping Environment,”
Submitted to The United States Patent and Trademark Office
.
(pdf)
Amirhossein Tamjidi, Ali-akbar Agha-mohammadi and Hamid D. Taghirad,
“Augmenting Vision and LRF Information: Towards Encoder-free SLAM in Unstructured Environments,”
in Machine Vision and Image Processing Conference,
Tabriz, Iran,
2008.
(pdf)
Ali-akbar Agha-mohammadi, Majid Nili Ahmadabadi and Taher S. Mirzahasanloo,
“Behavior Learning in Behavior-Based Architectures Using Reinforcement Learning,”
in 12th International CSI Computer Conference (CSICC),
Tehran, Iran,
pp. 171-174,
2007.
(pdf)
Ali-akbar Agha-mohammadi,
“Mobile Robot Localization Using Single Camera,”
in 10th Iranian Student Conference on Electrical Engineering, (ISCEE),
Esfahan, Iran,
2007.
(pdf)
Ali-akbar Agha-mohammadi and Taher S. Mirzahasanloo,
“Path Planning Using Hopfield Neural Network,”
in 10th Iranian Student Conference on Electrical Engineering, (ISCEE),
Esfahan, Iran,
2007.
(pdf)
Ali-akbar Agha-mohammadi and Amirhossein Tamjidi,
“An Introduction to Modified Methods in Ant Colony Systems Optimization and Proposing a New Local Optimizer,”
in 10th Intelligent Systems Conference,
Esfahan, Iran,
pp. 460-463,
2005.
(pdf)
Ali-akbar Agha-mohammadi, Nazim Kemal Ure, Jonathan P. How and John Vian,
“Health-aware Stochastic Planning for Persistent Package Delivery Missions using Quadrotors,”
Technical Report, Aerospace Controls Laboratory, Department of Aero/Astro, MIT
December
2013.
(pdf)
Ali-akbar Agha-mohammadi, Saurav Agarwal and Suman Chakravorty,
“Periodic-node Graph-based Framework for Stochastic Control of Small Aerial Vehicles,”
Technical Report, TAMU-EDPL-TR-2014-001, Department of Aerospace Engineering, Texas A&M University
2014.
(pdf)
Ali-akbar Agha-mohammadi, Saurav Agarwal, Aditya Mahadevan, Suman Chakravorty, Daniel Tomkins, Jory Denny and Nancy Amato,
“Dynamic Real-time Replanning in Belief Space: An Experimental Study on Physical Mobile Robots,”
Technical Report, TR13-007, Department of Computer Science, Texas A&M University
July
2013.
(pdf)
Ali-akbar Agha-mohammadi, Suman Chakravorty and Nancy Amato,
“Sampling-based Nonholonomic Motion Planning in Belief Space via Dynamic Feedback Linearization-based FIRM,”
Technical Report: TR12-004, Parasol Lab., CSE Dept., Texas A&M University
2012.
(pdf)
Ali-akbar Agha-mohammadi, Suman Chakravorty and Nancy Amato,
“Periodic-Feedback Motion planning in belief space for non-holonomic and/or Non-stoppable robots,”
Technical Report: TR12-003, Parasol Lab., CSE Dept., Texas A&M University
2012.
(pdf)
Ali-akbar Agha-mohammadi, Suman Chakravorty and Nancy Amato,
“Motion planning in belief space using sampling-based Feedback planners,”
Technical Report: TR11-007, Parasol Lab., CSE Dept., Texas A&M University
2011.
(pdf)
Ali-akbar Agha-mohammadi, Suman Chakravorty and Nancy Amato,
“Probabilistic Completeness of the Belief Space Motion Planners,”
Technical Report: TR11-006, Parasol Lab., CSE Dept., Texas A&M University
2011.
(pdf)
Ali-akbar Agha-mohammadi, Suman Chakravorty and Nancy Amato,
“FIRM: Feedback controller-based Information-state RoadMap, A Framework for Motion Planning Under Uncertainty,”
Technical Report: TR11-001, Parasol Lab., CSE Dept., Texas A&M University
2011.
(pdf)
Ali-akbar Agha-mohammadi,
“Sampling-based State Estimation and Stochastic Control for Robot Motion Planning under Motion Uncertainty and Noisy Sensor Measurements,”
PhD Dissertation, Department of Computer Science and Engineering, Texas A&M University,
October
2013.
(pdf)
Ali-akbar Agha-mohammadi,
“Design and Implementation of Multi-sensor Fusion methods for Solving Simultaneous Localization And Mapping (SLAM) Problem,”
M.Sc. Thesis, Department of Electrical and Computer Engineering, Khaje Nasir Toosi University of Technology,
July
2008.
(pdf)
Ali-akbar Agha-mohammadi,
“Robosoccer: Small-size Soccer Robots for Robocup Competitions,”
B.Sc. Thesis, Department of Electrical and Computer Engineering, Tabriz University,
June
2005.
(pdf)


{% extends 'templates/myr_transaction_layout.html' %} {% block pageTitle %}Blank page{% endblock %} {% block content %}
Booking reference number 0002 7480 8900
Date and time Monday 2nd May 2016, 2:00pm
Change
Clinic General Respiratory Medicine-Respiratory Medicine-CityTH (NAME Hosp)-CODE
Location Beckett St, Leeds, LS9 7TF
Referred by Dr Zubeir Smith at Colton Mill Medical Centre
Book appointment


>>
<<
Usr
Pri
JfC
LJ
Phr
Dic
Voc
!:
Help
Dictionary
| Determinant |
u . v 2 _ _ |
Dot Product
|
The phrases -/ . * and +/ . * are the determinant
and permanent of square matrix arguments. More generally,
the phrase u . v is defined in terms of a recursive expansion
by minors along the first column, as discussed below.
|
|
For vectors and matrices, the phrase x +/ . * y
is equivalent to the dot, inner, or matrix
product of math; other rank-0 verbs such as <. and *.
are treated analogously. In general, u . v is defined
by u@(v"(1+lv,_)) , restated in English below.
|
For example:
x=: 1 2 3 [ m=: >1 6 4;4 1 0;6 6 8
det=: -/ . *
mp=: +/ . *
x ([ ; ] ; det@] ; mp ; mp~ ; mp~@]) m
+-----+-----+----+--------+-------+--------+
|1 2 3|1 6 4|_112|27 26 28|25 6 42|49 36 36|
| |4 1 0| | | | 8 25 16|
| |6 6 8| | | |78 90 88|
+-----+-----+----+--------+-------+--------+
The monad u . v is defined as illustrated below:
DET=: 2 : 'v/@,`({."1 u . v $:@minors)@.(0<{:@$) @ ,. "2'
minors=: }."1 @ (1&([\.))
-/ DET * m
_112
-/ DET * 1 16 64
49
-/ DET * i.3 0
1
+/ DET * m
320
The definition u@(v"(1+lv,_)) given above for the dyadic
case may be re-stated in words as follows: u is applied to
the result of v on lists of “left argument cells”
and the right argument in toto. The number of items in a
list of left argument cells must agree with the number in the right argument.
Thus, if v has ranks 2 3 and the shapes
of x and y are 2 3 4 5 6
and 4 7 8 9 10 11, then there are 2 3 lists
of left argument cells (each shaped 4 5 6); and if
the shape of a result cell is sr, the overall shape
is 2 3,sr .
>>
<<
Usr
Pri
JfC
LJ
Phr
Dic
Voc
!:
Help
Dictionary


Key Preparation Materials
Study Assignment 1: The Godhead (1 hr)
DONE
Content
Study Assignment 1: The Godhead (1 hr)
DONE
Content


The number of spaces that will prepended on each indent
Holds the line entries
How far from the left the cursor resides
Chainable method to set alignment on the fly
Hijack the offset tree hiearchy and write at any offset on the current line
Returns a list of lines compiled thus far. This only return a copy and will not return this actual reference
Get the actual reference to the array of strings held in memory
Returns the list of lines as a string
The delimiter that seperates every line
Set the factor for implied indentation
Writes a line to the list of lines compiled
Returns a text string with the current number of spaces from the left for the current offset
Add a blank line
Wrap contains with a specified start-string and end-string
Wrap contains with a specified start-string and end-string and indents its contents
Generated using TypeDoc
Holds the alignment orientation of the document


{{'Changing scope to '|translate}} {{newScope}}.
{{'You will be taken to the dashboard after clicking OK.'|translate}}
{{'You will see the new data after clicking OK.'|translate}}


| Package | TC | CC | AC | Ca | Ce | A | I | D | V |
|---|---|---|---|---|---|---|---|---|---|
| org.codehaus.mojo.jdepend | 5 | 4 | 1 | 0 | 13 | 20.0% | 100.0% | 20.0% | 1 |
| org.codehaus.mojo.jdepend.objects | 4 | 4 | 0 | 1 | 2 | 0.0% | 67.0% | 33.0% | 1 |
| Afferent Couplings | Efferent Couplings | Abstractness | Instability | Distance |
|---|---|---|---|---|
| 0 | 13 | 20.0% | 100.0% | 20.0% |
| Abstract Classes | Concrete Classes | Used by Packages | Uses Packages |
|---|---|---|---|
| org.codehaus.mojo.jdepend.AbstractJDependMojo |
org.codehaus.mojo.jdepend.JDependMojo org.codehaus.mojo.jdepend.JDependNoForkMojo org.codehaus.mojo.jdepend.JDependXMLReportParser org.codehaus.mojo.jdepend.ReportGenerator |
None | java.io java.lang java.util javax.xml.parsers jdepend.xmlui org.apache.maven.doxia.sink org.apache.maven.doxia.siterenderer org.apache.maven.plugin.logging org.apache.maven.project org.apache.maven.reporting org.codehaus.mojo.jdepend.objects org.xml.sax org.xml.sax.helpers |
| Afferent Couplings | Efferent Couplings | Abstractness | Instability | Distance |
|---|---|---|---|---|
| 1 | 2 | 0.0% | 67.0% | 33.0% |
| Abstract Classes | Concrete Classes | Used by Packages | Uses Packages |
|---|---|---|---|
| None | org.codehaus.mojo.jdepend.objects.CyclePackage org.codehaus.mojo.jdepend.objects.JDPackage org.codehaus.mojo.jdepend.objects.Packages org.codehaus.mojo.jdepend.objects.Stats |
org.codehaus.mojo.jdepend |
java.lang java.util |
| Term | Description |
|---|---|
| Number of Classes | The number of concrete and abstract classes (and interfaces) in the package is an indicator of the extensibility of the package. |
| Afferent Couplings | The number of other packages that depend upon classes within the package is an indicator of the package's responsibility. |
| Efferent Couplings | The number of other packages that the classes in the package depend upon is an indicator of the package's independence. |
| Abstractness | The ratio of the number of abstract classes (and interfaces) in the analyzed package to the total number of classes in the analyzed package. The range for this metric is 0 to 1, with A=0 indicating a completely concrete package and A=1 indicating a completely abstract package. |
| Instability | The ratio of efferent coupling (Ce) to total coupling (Ce / (Ce + Ca)). This metric is an indicator of the package's resilience to change. The range for this metric is 0 to 1, with I=0 indicating a completely stable package and I=1 indicating a completely instable package. |
| Distance | The perpendicular distance of a package from the idealized line A + I = 1. This metric is an indicator of the package's balance between abstractness and stability. A package squarely on the main sequence is optimally balanced with respect to its abstractness and stability. Ideal packages are either completely abstract and stable (x=0, y=1) or completely concrete and instable (x=1, y=0). The range for this metric is 0 to 1, with D=0 indicating a package that is coincident with the main sequence and D=1 indicating a package that is as far from the main sequence as possible. |
| Cycles | Packages participating in a package dependency cycle are in a deadly embrace with respect to reusability and their release cycle. Package dependency cycles can be easily identified by reviewing the textual reports of dependency cycles. Once these dependency cycles have been identified with JDepend, they can be broken by employing various object-oriented techniques. |


Settings
-
Vibration
-
Enabled
| equates to | |
Black Calculator
Vers. 2.0
(c) 2015,
Paul Atreides
Vibration
Enabled
| equates to | |
Black Calculator
Vers. 2.0
(c) 2015,
Paul Atreides


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use Population | |
|---|---|
| org.apache.commons.math.genetics | This package provides Genetic Algorithms components and implementations. |
| Uses of Population in org.apache.commons.math.genetics |
|---|
| Classes in org.apache.commons.math.genetics that implement Population | |
|---|---|
class |
ElitisticListPopulation
Population of chromosomes which uses elitism (certain percentace of the best chromosomes is directly copied to the next generation). |
class |
ListPopulation
Population of chromosomes represented by a List . |
| Methods in org.apache.commons.math.genetics that return Population | |
|---|---|
Population |
GeneticAlgorithm.evolve(Population initial,
StoppingCondition condition)
Evolve the given population. |
Population |
Population.nextGeneration()
Start the population for the next generation. |
Population |
ElitisticListPopulation.nextGeneration()
Start the population for the next generation. |
Population |
GeneticAlgorithm.nextGeneration(Population current)
Evolve the given population into the next generation. |
| Methods in org.apache.commons.math.genetics with parameters of type Population | |
|---|---|
Population |
GeneticAlgorithm.evolve(Population initial,
StoppingCondition condition)
Evolve the given population. |
protected Chromosome |
Chromosome.findSameChromosome(Population population)
Searches the population for another chromosome with the same
representation. |
boolean |
StoppingCondition.isSatisfied(Population population)
Determine whether or not the given population satisfies the stopping condition. |
boolean |
FixedGenerationCount.isSatisfied(Population population)
Determine whether or not the given number of generations have passed. |
Population |
GeneticAlgorithm.nextGeneration(Population current)
Evolve the given population into the next generation. |
void |
Chromosome.searchForFitnessUpdate(Population population)
Searches the population for a chromosome representing the same solution, and if it finds one, updates the fitness to its value. |
ChromosomePair |
TournamentSelection.select(Population population)
Select two chromosomes from the population. |
ChromosomePair |
SelectionPolicy.select(Population population)
Select two chromosomes from the population. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


This example calculates a route from the Fernsehturm at Panoramastraße in Berlin (52.5208°N, 13.4093°E) to Kurfürstendamm (52.5034°N, 13.3295°E) in the west of the city using public transport routing, and displays it on the map. The calculation finds the fastest available route using public transport.


Total websites: 327
Total websites rated Good: 12
Total subdomains of Utah.gov: 134
Total subdomains rated Good: 1
Last updated:
UtahWatch evaluates and rates the HTTPS support of the websites of a curated selection of Utah-based businesses, organizations, groups, individuals, and government entities. Entities that have a presence in Utah but are headquartered elsewhere are not tracked.
No other security assessment of these websites has been performed - these ratings do not indicate if a website is insecure, untrustworthy, or unsafe. Please contact the website owners directly with any questions or concerns about their security practices.
It is not practical to rate every website in Utah. Although the ultimate goal is to have all websites move to HTTPS, some editorial decisions must be made. My hope is that if the prominent sites listed here choose to implement high quality HTTPS then the others will follow.
Ratings will be produced at least once a month. Websites could be added or removed at any time. A best-effort log of updates will be kept at the SecureUtah.org blog.
UtahWatch is part of SecureUtah.org. Please visit SecureUtah.org to learn why HTTPS is crucial to a safe Internet, why it should be supported by every website, and why Utah should take the lead in promoting and supporting it.
Please send feedback to<EMAIL_ADDRESS>Twitter: @SecureUtah
UtahWatch uses a simple rating scale to make it easy to see if basic HTTPS has been achieved and to inspire change if it has not. Strong HTTPS has many moving parts that can be best evaluated using the Qualys SSL Labs and SecurityHeaders.io services.
A Bad rating is given if:
A Mediocre rating means a TLS connection can be established but there are quality issues with the site’s implementation, such as the HTTP site doesn’t redirect to HTTPS and/or the Strict-Transport-Security header isn’t set.
A Good rating is given if all of the above conditions are met. However, Good does not necessarily mean that a website's configuration work is complete (e.g. UtahWatch does not evaluate any subdomains besides WWW), nor does it mean that a website is free from other security risks or vulnerabilities.
Many of the sites that receive a Mediocre rating are missing the HTTP Strict-Transport-Security (HSTS) header or have the max-age
value set to less than a year.
The HSTS header has become a vital part of helping visitors reach a website securely. Implementing HTTPS is not something that should be done piecemeal - without HSTS it is possible for an attacker to intercept a user's web traffic and prevent them from connecting over HTTPS. Thus, websites will not be rated Good unless they include HSTS.
Please read more about the importance of using HTTP Strict Transport Security:
Some sites which UtahWatch rates as Mediocre might actually be unusable in a browser. This is mostly due to mixed content, which UtahWatch doesn’t always detect.
Although self-signed certificates are not inherently untrustworthy, UtahWatch gives a Bad rating to websites that use them because modern browsers will display a prominent warning to users when they try to visit those sites.
Aside from the basic hostname verification checks, UtahWatch doesn’t attempt to evaluate the quality of the TLS connection. Please use the provided SSL Labs server TLS testing tool link for each website to view an in-depth assessment. Please use SecurityHeaders.io to evaluate a site's HTTP response headers.
SecureUtah.org provides a list of resources for deploying, configuring, and testing HTTPS.
The code for UtahWatch is available on GitHub.
UtahWatch was created and is maintained by Jon Jarvis.
UtahWatch is a fork of HTTPSWatch.com. The HTTPSWatch project code is available on GitHub and was originally created by Benjamin Peterson. Many thanks to Benjamin for giving approval to fork his code and for providing early assistance to get UtahWatch going!
HTTPSWatch was inspired by Alex Gaynor’s blog posts about news sites’ HTTPS support.
Much respect to Qualys and Ivan Ristić for creating the excellent SSL Server Test that has become the de facto standard for testing and grading HTTPS.
Much respect to Scott Helme for making SecurityHeaders.io, a very useful and necessary tool that I wish I knew how to build.


Set up Bluetooth
Run shell commands on both your Intel® Edison and Intel® IoT Gateway devices to enable the correct Bluetooth Low Energy (BLE) services.
-
Shell into your Intel® Edison and run the following commands:
$ rfkill unblock bluetooth $ killall bluetoothd $ systemctl disable bluetooth $ hciconfig hci0 up
-
Shell into your Intel® IoT Gateway and run the same commands as above on your Gateway.
Your devices are now ready for Bluetooth Low Energy development.


We will service your residential landscaping needs in a focused, detailed and diligent manner. We will work hand-in-hand with you to bring your property landscaping vision to life. Let us be your trustworthy landscaping team with our suite of top-tier Residential Landscaping services.
NORTHERN VIRGINIA LANDSCAPE DESIGN
With our services,you will have the most impressive yard in the neighborhood.
NORTHERN VIGINIA LANDSCAPE SERVICES
Leave the tough hardscaping to our heavy duty vehicles and project planners
NORTHERN VIRGINIA SNOW REMOVAL
We will work diligently to remove all snow hazards form your property.


Movie Tix
Select Movie
# of Child Tickets
# of Adult Tickets
# of Senior Tickets
Child Tickets Total:
0
x
0
$0.00
Adult Tickets Total:
0
x
0
$0.00
Senior Tickets Total:
0
x
0
$0.00
Tax:
$0.00
Purchase Total:
$0.00
Purchase Tix


3.4.0
Add a molecule and align it horizontally
molecule
:
(any)
any
:
[array]
array of extended bond bonds
object
:
: minX, maxX, minY, maxY, minZ, maxZ, width, height, depth
Calculate the molecular formula in 'chemcalc' notation taking into account fragments, isotopes and charges
String
:
Add an netry in the database


Test Your Megan Thee Stallion Knowledge!
Can you answer all 8 questions in 60 seconds?
Answer correctly and you earn a point!
Answer incorrectly and you lose 5 seconds off the clock!
High Score
Final Score
Can you answer all 8 questions in 60 seconds?
Answer correctly and you earn a point!
Answer incorrectly and you lose 5 seconds off the clock!
Final Score


"This page is meant to provide an experimental proof of concept for a mobile-friendly layout that can be used in this example, to highlight the women in computer science and programming."
| Tyler Smooth | 12 out of 12 |
| Tanae Johnson | 12 out of 12 |
| Hannah Marie K | 12 out of 12 |
| Olivia Good | 12 out of 12 |
| Sofia Carter | 12 out of 12 |


Variant of ClassicSimilarity supporting global IDF using a map for IDF values of terms.
Variant of ClassicSimilarity supporting global IDF using a map for IDF values of terms.
Variant of ClassicSimilarity supporting global IDF using a map for IDF values of terms. The key for the first map is the field name; the one for the second map is the term; the value is the IDF for the term in that field.
Variant of ClassicSimilarity supporting global IDF using a map for IDF values of terms. The key for the first map is the field name; the one for the second map is the term; the value is the IDF for the term in that field.


Scouting:
What do you want to do?
Match Scouting
Pit Scouting
Comment
Activation code for Android: FRC2017


| gdata.Crypto.Cipher | index /usr/local/google/home/afshar/src/external-gdata-release/google3/src/gdata/Crypto/Cipher/__init__.py |
Secret-key encryption algorithms.
Secret-key encryption algorithms transform plaintext in some way that
is dependent on a key, producing ciphertext. This transformation can
easily be reversed, if (and, hopefully, only if) one knows the key.
The encryption modules here all support the interface described in PEP
272, "API for Block Encryption Algorithms".
If you don't know which algorithm to choose, use AES because it's
standard and has undergone a fair bit of examination.
Crypto.Cipher.AES Advanced Encryption Standard
Crypto.Cipher.ARC2 Alleged RC2
Crypto.Cipher.ARC4 Alleged RC4
Crypto.Cipher.Blowfish
Crypto.Cipher.CAST
Crypto.Cipher.DES The Data Encryption Standard. Very commonly used
in the past, but today its 56-bit keys are too small.
Crypto.Cipher.DES3 Triple DES.
Crypto.Cipher.IDEA
Crypto.Cipher.RC5
Crypto.Cipher.XOR The simple XOR cipher.
| Package Contents | ||||||
| Data | ||
| __all__ = ['AES', 'ARC2', 'ARC4', 'Blowfish', 'CAST', 'DES', 'DES3', 'IDEA', 'RC5', 'XOR'] __revision__ = '$Id: __init__.py,v 1.7 2003/02/28 15:28:35 akuchling Exp $' |


Subgraph API
Get Started ›Subgraph API
The subgraph API has been proposed and implemented as the default mechanism for integrating backend libraries to MXNet. The subgraph API is a very flexible interface. Although it was proposed as an integration mechanism, it has been used as a tool for manipulating NNVM graphs for graph-level optimizations, such as operator fusion.
The subgraph API works as the following steps:
- Search for particular patterns in a graph.
- Group the operators/nodes with particular patterns into a subgraph and shrink the subgraph into a single node.
- Replace the subgraph in the original graph with the subgraph node.
The figure below illustrates the subgraph mechanism.
The subgraph API allows the backend developers to customize the subgraph mechanism in two places:
- Subgraph searching: define a subgraph selector to search for particular patterns in a computation graph.
- Subgraph node creation: attach an operator to run the computation in the subgraph. We can potentially manipulate the subgraph here.
The following is a demonstration of how the subgraph API can be applied to a simple task. Refer to the previous figure for an overview of the process. That is, replacing Convolution
and BatchNorm
with the conv_bn.
The first step is to define a subgraph selector to find the required pattern. To find a pattern that has Convolution
and BatchNorm
, we can start the search on the node with Convolution
. Then from the Convolution
node, we search for BatchNorm
along the outgoing edge.
class SgSelector : public SubgraphSelector {
public:
SgSelector() {
find_bn = false;
}
bool Select(const nnvm::Node &n) override {
// Here we start on the Convolution node to search for a subgraph.
return n.op() && n.op()->name == "Convolution";
}
bool SelectInput(const nnvm::Node &n, const nnvm::Node &new_node) override {
// We don't need to search on the incoming edge.
return false;
}
bool SelectOutput(const nnvm::Node &n, const nnvm::Node &new_node) override {
// We search on the outgoing edge. Once we find a BatchNorm node, we won't
// accept any more BatchNorm nodes.
if (new_node.op() && new_node.op()->name == "BatchNorm" && !find_bn) {
find_bn = true;
return true;
} else {
return false;
}
}
std::vector<nnvm::Node *> Filter(const std::vector<nnvm::Node *> &candidates) override {
// We might have found a Convolution node, but we might have failed to find a BatchNorm
// node that uses the output of the Convolution node. If we failed, we should skip
// the Convolution node as well.
if (find_bn)
return candidates;
else
return std::vector<nnvm::Node *>();
}
private:
bool find_bn;
};
The second step is to define a subgraph property to use the subgraph selector above to customize the subgraph searching. By defining this class, we can also customize subgraph node creation. When customizing node creation, we can specify what operator to run the subgraph on the node. In this example, we use CachedOp
, which itself is a graph executor, to run the subgraph with Convolution
and BatchNorm
. In practice, it's most likely that we use a single operator from a backend library to replace the two operators for execution.
class SgProperty : public SubgraphProperty {
public:
static SubgraphPropertyPtr Create() {
return std::make_shared<SgProperty>();
}
nnvm::NodePtr CreateSubgraphNode(
const nnvm::Symbol &sym, const int subgraph_id = 0) const override {
// We can use CachedOp to execute the subgraph.
nnvm::NodePtr n = nnvm::Node::Create();
n->attrs.op = Op::Get("_CachedOp");
n->attrs.name = "ConvBN" + std::to_string(subgraph_id);
n->attrs.subgraphs.push_back(std::make_shared<nnvm::Symbol>(sym));
std::vector<std::pair<std::string, std::string> > flags{{"static_alloc", "true"}};
n->attrs.parsed = CachedOpPtr(new CachedOp(sym, flags));
return n;
}
SubgraphSelectorPtr CreateSubgraphSelector() const override {
auto property = std::make_shared<CreateSubgraphSelector>();
property->SetAttr<std::string>("property_name", "subgraph example pass"); // Optional, better to have it.
property->SetAttr<bool>("inference_only", true); // Optional, only for inference_only pass.
return property;
}
};
SetAttr
is optional and developer can define their own attributes to control property behavior.
There're 2 built-in attributes that used by MXNet executor.
property_name
: std::string, name of this property.
inference_only
: bool, apply this property only for inference. Property will be skiped when need_grad=True. Default false
if this attribute isn't defined.
After defining the subgraph property, we need to register it in .cc file.
MXNET_REGISTER_SUBGRAPH_PROPERTY(SgTest, SgProperty);
It's possible to register multiple properties for same backend. In practice, we recommend to put each property definition into .h file, and register backend in single .cc file. Property will be executed according to the register order.
#include "SgProperty.h" // Define SgProperty class
#include "SgProperty2.h" // Define SgProperty2 class
#include "SgProperty3.h" // Define SgProperty3 class
MXNET_REGISTER_SUBGRAPH_PROPERTY(SgTest, SgProperty); // Execution order 1.
MXNET_REGISTER_SUBGRAPH_PROPERTY(SgTest, SgProperty2); // Execution order 2.
MXNET_REGISTER_SUBGRAPH_PROPERTY(SgTest, SgProperty3); // Execution order 3.
After compiling this subgraph mechanism into MXNet, we can use the environment variable MXNET_SUBGRAPH_BACKEND
to activate it during symbol bind.
export MXNET_SUBGRAPH_BACKEND=SgTest
Or you can use python symbol API get_backend_symbol
to run all properties registered for this backend and get returned symbol.
sym, arg_params, aux_params = mx.model.load_checkpoint(prefix, epoch)
sym = sym.get_backend_symbol('SgTest')
When SgProperty
is activated, a message will be shown in terminal as
start to execute subgraph example pass.
This tutorial shows a simple example of how to use the subgraph API to search for patterns in an NNVM graph.
Intested users can try different pattern matching rules (i.e., define their own SubgraphSelector
) and
attach different operators to execute the subgraphs.


Type and enter the equation that you think the graph shown on-screen best represents.
Every incorrect guess will subtract 1 from your score, while correct guesses will add 20.
You can view individual point values and general graph shape to help you decide what kind of equation fits best.
On the graph, you can click and drag to change graph scaling or to view different x and y values.
Double-clicking the graph will set its scale and position back to the default.


Public opinion research (POR) rules
“Public opinion research” (POR) is a class of primary research regulated by the Government of Canada. If government agencies conduct POR, they need to follow the POR processes described in the Directive on the Management of Communications.
As the “Defining public opinion research” guidance states:
User research that involves only using observation techniques and collecting fact-based information is normally not considered public opinion research.
Behavioural research is generally defined as how people react or behave in a given situation. Factual research often answers who, what, when or where.
Most of our research focuses on people’s behaviours or past actions. That research is factual and behavioural, so it doesn’t fall within the definition of POR. It’s possible to construct design research that is POR. If you ask questions about people’s opinions policy or government, you may be doing POR.
If you don’t know whether your research is POR or not, speak to our policy team.
- Last updated by Colin on March 25, 2019


WeatherSight
My Resume:
Contact Info:
Chad M. G. Barlow
<EMAIL_ADDRESS>OBJECTIVE
To obtain a software development position with a lucrative company by demonstrating strong language comprehension, and group focused work ethic.
EDUCATION
- Associates Of Arts- Weber State University in general studies
- Working towards a Bachelors Degree at Brigham Young University in Computer Science with a focus on software development
Competent Programming Languages:
Minor Competency in:
Other Languages Worked with/Skills:
- Assembly
- C
- A+ Technical Certification
EXPERIENCE
WellsFargo- August 2010-Current date. Teller position
- Maintained balanced cash amounts.
- Customer service, sales, and accounting.
Visual-Link Languages- May 2010- Jan 2011 Software Developer
- Group work such as designing and coordinating efforts on projects.
- Manipulated audio(wav), video(mpeg, AVI etc.) and picture(jpeg, png, bitmap) files.
- Experience with Spanish language in project to help people learn languages.
AttackPattern
- Software testing.
- Bug management.
- Team work in an agile development environment
Teratek
- Software testing.
- Bug management.
- Team work in an agile development environment
PERSONAL
I am an eagle scout and a returned missionary from the LDS church. I speak a little Spanish.


These five products were the most profitable. The darker the color, the more profitable the product was.
These are the products of which we sold the most quantity.
Each state is colored and labeled with its profit or loss. This map would be helpful to know which regions require attention.
This chart depicts the profit of each month over 4 years. Notice the peaks in Decembers and valleys in Januaries.


MiniVan Alpha reads a data bundle that you need to host somewhere. On this page you can create a bundle from a network or edit a bundle you already have.
File formats currently supported: GEXF, JSON data bundle.
Color gradient un
Size gradient
Color categories
Hidden
Color gradient
Thickness gradient
Color categories
Hidden
Attribute ID: {{attId}}
{{att.modalities[modality].count|number}} node{{att.modalities[modality].count>1?'s':''}}


In this notebook, a template is provided for you to implement your functionality in stages, which is required to successfully complete this project. If additional code is required that cannot be included in the notebook, be sure that the Python code is successfully imported and included in your submission if necessary.
Note: Once you have completed all of the code implementations, you need to finalize your work by exporting the iPython Notebook as an HTML document. Before exporting the notebook to html, all of the code cells need to have been run so that reviewers can see the final implementation and output. You can then export the notebook by using the menu above and navigating to \n", "File -> Download as -> HTML (.html). Include the finished document along with this notebook as your submission.
In addition to implementing code, there is a writeup to complete. The writeup should be completed in a separate file, which can be either a markdown file or a pdf document. There is a write up template that can be used to guide the writing process. Completing the code template and writeup template will cover all of the rubric points for this project.
The rubric contains "Stand Out Suggestions" for enhancing the project beyond the minimum requirements. The stand out suggestions are optional. If you decide to pursue the "stand out suggestions", you can include the code in this Ipython notebook and also discuss the results in the writeup file.
Note: Code and Markdown cells can be executed using the Shift + Enter keyboard shortcut. In addition, Markdown cells can be edited by typically double-clicking the cell to enter edit mode.
# Load pickled data
import pickle
# TODO: Fill this in based on where you saved the training and testing data
training_file = '../traffic-signs-data/train.p'
validation_file='../traffic-signs-data/valid.p'
testing_file = '../traffic-signs-data/test.p'
with open(training_file, mode='rb') as f:
train = pickle.load(f)
with open(validation_file, mode='rb') as f:
valid = pickle.load(f)
with open(testing_file, mode='rb') as f:
test = pickle.load(f)
X_train, y_train = train['features'], train['labels']
X_valid, y_valid = valid['features'], valid['labels']
X_test, y_test = test['features'], test['labels']
The pickled data is a dictionary with 4 key/value pairs:
'features'
is a 4D array containing raw pixel data of the traffic sign images, (num examples, width, height, channels).'labels'
is a 1D array containing the label/class id of the traffic sign. The file signnames.csv
contains id -> name mappings for each id.'sizes'
is a list containing tuples, (width, height) representing the original width and height the image.'coords'
is a list containing tuples, (x1, y1, x2, y2) representing coordinates of a bounding box around the sign in the image. THESE COORDINATES ASSUME THE ORIGINAL IMAGE. THE PICKLED DATA CONTAINS RESIZED VERSIONS (32 by 32) OF THESE IMAGESComplete the basic data summary below. Use python, numpy and/or pandas methods to calculate the data summary rather than hard coding the results. For example, the pandas shape method might be useful for calculating some of the summary results.
### Replace each question mark with the appropriate value.
### Use python, pandas or numpy methods rather than hard coding the results
# TODO: Number of training examples
n_train = X_train.shape[0]
# TODO: Number of validation examples
n_validation = X_valid.shape[0]
# TODO: Number of testing examples.
n_test = X_test.shape[0]
# TODO: What's the shape of an traffic sign image?
image_shape = (X_train.shape[1], X_train.shape[2])
# TODO: How many unique classes/labels there are in the dataset.
class_lables = set(y_train)
n_classes = len(class_lables)
print("Number of training examples =", n_train)
print("Number of validation examples =", n_validation)
print("Number of testing examples =", n_test)
print("Image data shape =", image_shape)
print("Number of classes =", n_classes)
Visualize the German Traffic Signs Dataset using the pickled file(s). This is open ended, suggestions include: plotting traffic sign images, plotting the count of each sign, etc.
The Matplotlib examples and gallery pages are a great resource for doing visualizations in Python.
NOTE: It's recommended you start with something simple first. If you wish to do more, come back to it after you've completed the rest of the sections. It can be interesting to look at the distribution of classes in the training, validation and test set. Is the distribution the same? Are there more examples of some classes than others?
### Data exploration visualization code goes here.
### Feel free to use as many code cells as needed.
import random
import matplotlib.pyplot as plt
import numpy as np
import csv
# Visualizations will be shown in the notebook.
%matplotlib inline
#Import traffic signs class names
signs_class=[]
with open('signnames.csv', 'rt') as csvfile:
reader = csv.DictReader(csvfile, delimiter=',')
for row in reader:
signs_class.append((row['SignName']))
plt.rcParams['figure.figsize'] = (16, 20)
print("Traffic signs training set ...")
image_master_list = []
nImg = np.zeros(n_classes, None)
plt.figure(figsize=(12,3))
for idx in range(n_classes):
imgFoundIdx = np.where(y_train==idx)
nImg[idx] = len(imgFoundIdx[0])
plt.bar(np.arange(0, n_classes), nImg)
plt.xlabel('Class ID')
plt.ylabel('Number of training examples')
plt.xticks( np.arange(0, n_classes), np.arange(0, n_classes))
plt.figure()
for imgIdx in range(0, n_classes):
plt.subplot(7,7,imgIdx+1)
imgToPlot = np.where(y_train==imgIdx)[0][0]
image_master_list.append(X_train[imgToPlot])
plt.imshow(image_master_list[imgIdx])
plt.xlabel("Image label " + str(imgIdx)+ "\n" + signs_class[imgIdx])
Design and implement a deep learning model that learns to recognize traffic signs. Train and test your model on the German Traffic Sign Dataset.
The LeNet-5 implementation shown in the classroom at the end of the CNN lesson is a solid starting point. You'll have to change the number of classes and possibly the preprocessing, but aside from that it's plug and play!
With the LeNet-5 solution from the lecture, you should expect a validation set accuracy of about 0.89. To meet specifications, the validation set accuracy will need to be at least 0.93. It is possible to get an even higher accuracy, but 0.93 is the minimum for a successful project submission.
There are various aspects to consider when thinking about this problem:
Here is an example of a published baseline model on this problem. It's not required to be familiar with the approach used in the paper but, it's good practice to try to read papers like these.
It is intutive to realize that the colors of traffic signs are important and hence converting images to gray scale may not be the best option. Limited testing with gray scale images were done, but it did not perform any better than the colored images.
The provided training data is augmented with images which are modified version of randomly sampled images within the training data set. This not only provides richer training data set, but also enhances the quality of several of the images. The applied transforms can be broadly divided into two categories:
One transformation from each of the above mentioed category is randomly picked an applied sequentially to randomly selected image. The user specifies the number of figures to augment to original training dataset.
import cv2
import random
# plotting function to see effect of transforms
def show2img(img, img1):
plt.figure(figsize=(6, 2))
plt.subplot(1, 2, 1)
plt.imshow(img)
plt.title("Raw image")
plt.subplot(1, 2, 2)
plt.imshow(img1)
plt.title("Processed image")
#
# image quality related transforms
#
def adjust_brightContrast(img):
#print("Adjusting contrast and brightnes ...")
alpha = random.uniform(1.5, 2.0)
beta = random.uniform(20, 50)
# adjusted_img = alpha*img + beta
return_img = cv2.addWeighted(img, alpha, np.ones(img.shape, img.dtype), beta, 0.0 )
return return_img
def sharp(img):
#print("Sharpening ...")
blur_img = cv2.GaussianBlur(img, (5,5), 20.0)
return_img = cv2.addWeighted(img, 2, blur_img, -1, 0.0 )
return return_img
def equalize_Hist(img):
#print("Equalizing Histogram ...")
return_img=img.copy()
return_img[:, :, 0] = cv2.equalizeHist(img[:, :, 0])
return_img[:, :, 1] = cv2.equalizeHist(img[:, :, 1])
return_img[:, :, 2] = cv2.equalizeHist(img[:, :, 2])
return return_img
# image shape related transforms
def scale_crop_img(img):
#print("Scaling and croping images ...")
img2=img.copy()
scale_y=0.2*np.random.rand()+1.0
img2=cv2.resize(img, None, fx=1, fy=scale_y, interpolation = cv2.INTER_CUBIC)
c_x,c_y, sh = int(img2.shape[0]/2), int(img2.shape[1]/2), int(32/2)
img2 = img2[(c_x-sh):(c_x+sh),(c_y-sh):(c_y+sh)]
return img2
def rotate_img(img):
#print("Rotating image")
c_x,c_y = int(img.shape[0]/2), int(img.shape[1]/2)
ang = 20.0*np.random.rand()-10
Mat = cv2.getRotationMatrix2D((c_x, c_y), ang, 1.0)
return_img = cv2.warpAffine(img, Mat, img.shape[:2])
return return_img
def create_img_augmentation(img_set, label, number_of_img_create, showSample=True):
#randomly select images to be operated upon for augmentation
aug_index = random.sample(range(img_set.shape[0]), number_of_img_create)
show_rand_sample = random.sample(range(number_of_img_create), 1)
X_aug = np.zeros((number_of_img_create, 32, 32, 3), dtype=img_set.dtype)
y_aug = np.zeros(number_of_img_create, dtype=label.dtype)
for i in range(number_of_img_create):
im=img_set[aug_index[i]]
X_aug[i] = random.choice(img_shape_fnc)( random.choice(img_quality_fnc)(im))
y_aug[i] = label[aug_index[i]]
#new_img_set[i] = random.choice(img_quality_fnc)(im)
#show2img(im, new_img_set[i])
if showSample == True:
print("Sample of augmented image")
show2img(img_set[aug_index[show_rand_sample[0]], :, :, :], X_aug[show_rand_sample[0], :, :, :])
return X_aug, y_aug
# define a list of image operation from which random choices can be made
img_quality_fnc = [adjust_brightContrast, sharp, equalize_Hist]
img_shape_fnc = [scale_crop_img, rotate_img]
# create images for training data set augmentation
#number_img = int(X_train.shape[0]*0.5)
number_img = int(X_train.shape[0]*1.0)
#
print("Added {} images to training data set".format(number_img))
print("Total size of training data set before augmentation = {}".format(n_train))
print("Total size of training data set after augmentation = {} \n".format(number_img+n_train))
#
X_train_aug, y_train_aug = create_img_augmentation(X_train, y_train, number_img)
X_train_new = np.concatenate((X_train, X_train_aug))
y_train_new = np.concatenate((y_train, y_train_aug))
X_train, y_train = X_train_new, y_train_new
### Define your architecture here.
### Feel free to use as many code cells as needed.
import tensorflow as tf
from tensorflow.contrib.layers import flatten
def trafficNet(x):
# Architecture
# x --> cv1(relu) --> p1 --> cv2(relu) --> p2 --> fc1(relu) --> fc2(relu) --> output
mu = 0
sigma = 0.1
w = {'w_cv1':tf.Variable(tf.truncated_normal(shape = (5,5,3,32), mean = mu, stddev = sigma), name='w_cv1'),
'w_cv2':tf.Variable(tf.truncated_normal(shape = (5,5,32,64), mean = mu, stddev = sigma), name='w_cv2'),
'w_fc1':tf.Variable(tf.truncated_normal(shape = (1600, 120), mean = mu, stddev = sigma), name='w_fc1'),
'w_fc2':tf.Variable(tf.truncated_normal(shape = (120, 84), mean = mu, stddev = sigma), name='w_fc2'),
'out':tf.Variable(tf.truncated_normal(shape = (84, n_classes), mean = mu, stddev = sigma), name='out'),}
b = {'b_cv1':tf.Variable(tf.zeros(shape = (32)), name='b_cv1'),
'b_cv2':tf.Variable(tf.zeros(shape = (64)), name='b_cv1'),
'b_fc1':tf.Variable(tf.zeros(shape = (120)), name='b_fc1'),
'b_fc2':tf.Variable(tf.zeros(shape = (84)), name='b_fc2'),
'out':tf.Variable(tf.zeros(shape = (n_classes)), name='b_out') }
s = {'s_cv1':[1,1,1,1],
's_cv2':[1,1,1,1]}
# define the computational graph
# convolution layer 1
# input 32x32x3 --> output 28x28x32
with tf.name_scope("cv1"):
cv1 = tf.nn.conv2d(x, w['w_cv1'], strides=s['s_cv1'], padding='VALID') + b['b_cv1']
with tf.name_scope("cv1_relu"):
cv1_r = tf.nn.relu(cv1)
# pooling layer 1
# input 28x28x32 --> output 14x14x32
with tf.name_scope("p1"):
p1 = tf.nn.max_pool(cv1_r, ksize=[1,2,2,1], strides=[1,2,2,1], padding='VALID')
# convolution layer 2
# input 14x14x32 --> output 10x10x64
with tf.name_scope("cv2"):
cv2 = tf.nn.conv2d(p1, w['w_cv2'], strides=s['s_cv2'], padding='VALID') + b['b_cv2']
with tf.name_scope("cv2_relu"):
cv2_r = tf.nn.relu(cv2)
# pooling layer 2
# input 10x10x64 --> output 5x5x64
with tf.name_scope("cv2_relu"):
p2 = tf.nn.max_pool(cv2_r, ksize=[1,2,2,1], strides=[1,2,2,1], padding='VALID')
# flatten for connecting to fc
p2_flat = flatten(p2)
# fc1
# input 1600 --> output 120
with tf.name_scope("fc1"):
fc1 = tf.matmul(p2_flat, w['w_fc1']) + b['b_fc1']
with tf.name_scope("fc1_relu"):
fc1_r = tf.nn.relu(fc1)
# fc2
# input 120 --> output 84
with tf.name_scope("fc2"):
fc2 = tf.matmul(fc1_r, w['w_fc2']) + b['b_fc2']
with tf.name_scope("fc2_relu"):
fc2_r = tf.nn.relu(fc2)
fc2 = tf.nn.dropout(fc2, 0.8)
# fc2
# input 84 --> output 10 Classes
with tf.name_scope("out"):
out_logits = tf.matmul(fc2_r, w['out']) + b['out']
return out_logits
A validation set can be used to assess how well the model is performing. A low accuracy on the training and validation sets imply underfitting. A high accuracy on the training set but low accuracy on the validation set implies overfitting.
def evaluation(X_data,y_data):
num_examples=len(X_data)
total_accuracy=0
sess=tf.get_default_session()
for offset in range(0,num_examples,batch_size):
batch_x,batch_y=X_data[offset:offset+batch_size], y_data[offset:offset+batch_size]
accuracy, p = sess.run([accuracy_op, predict], feed_dict={x:batch_x,y:batch_y})
total_accuracy+=(accuracy*len(batch_x))
return {"accuracy":total_accuracy/num_examples, "prediction":p}
### Train your model here.
### Calculate and report the accuracy on the training and validation set.
### Once a final model architecture is selected,
### the accuracy on the test set should be calculated and reported as well.
### Feel free to use as many code cells as needed.
from sklearn.utils import shuffle
import time
keep_prob = 0.75 # Dropout, probability to keep units
x = tf.placeholder(tf.float32,(None, 32, 32, 3))
y = tf.placeholder(tf.int32,(None))
keep_prob = tf.placeholder(tf.float32)
one_hot_y = tf.one_hot(y, n_classes)
out_logits = trafficNet(x)
n_epochs = 40
batch_size = 64
# training definitions
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(labels=one_hot_y, logits=out_logits) )
optimizer = tf.train.AdamOptimizer(learning_rate = 0.001).minimize(cost)
# validation definition
accuracy_op = tf.reduce_mean( tf.cast( tf.equal(tf.argmax(out_logits,1) , tf.argmax(one_hot_y, 1)), tf.float32) )
# prediction definition
predict = tf.argmax(out_logits, 1)
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for ep in range(n_epochs):
# train
ep_err = 0
ep_tr_acc = 0
X_train, y_train = shuffle(X_train, y_train)
start_time = time.time()
for offset in range(0, n_train, batch_size):
end_batch = offset + batch_size
x_batch, y_batch = X_train[offset:end_batch], y_train[offset:end_batch]
_, c, a = sess.run([optimizer, cost, accuracy_op], feed_dict={x:x_batch, y:y_batch})
ep_err += c
ep_tr_acc += a * len(x_batch)
ep_tr_acc = ep_tr_acc / n_train
end_time = time.time()
if ep%5 == 0:
print("Epoch {}/{}: training cost = {:.3f} : time elapsed {:.3f}s".format(ep+1, n_epochs, ep_err, end_time-start_time))
print("Epoch {}/{}: training accuracy = {:.3f}%".format(ep+1, n_epochs, ep_tr_acc*100))
#
# cross-validation accuracy
#
start_time = time.time()
ep_cv_accuracy_prediction = evaluation(X_valid,y_valid)
end_time = time.time()
prediction_cv = ep_cv_accuracy_prediction["prediction"]
if ep%5 == 0:
print("Epoch {}/{}: Cross-Validation Accuracy = {:.3f}% : time elapsed {:.3f}s\n".format(ep+1, n_epochs,
ep_cv_accuracy_prediction["accuracy"]*100, end_time-start_time))
cv_accuracy_prediction = evaluation(X_valid,y_valid)
saver.save(sess, './trafficNet_sess.ckpt')
print("Model saved")
test_accuracy_1 = evaluation(X_test, y_test)
print("Test Accuracy = {:.2f}%".format(test_accuracy_1['accuracy']*100))
print("Epoch {}/{}: training accuracy = {:.3f}%".format(ep+1, n_epochs, ep_tr_acc*100))
print("Epoch {}/{}: Cross-Validation Accuracy = {:.3f}% : time elapsed {:.3f}s\n".format(ep+1, n_epochs,
ep_cv_accuracy_prediction["accuracy"]*100, end_time-start_time))
To give yourself more insight into how your model is working, download at least five pictures of German traffic signs from the web and use your model to predict the traffic sign type.
You may find signnames.csv
useful as it contains mappings from the class id (integer) to the actual sign name.
### Train your model here.
### Calculate and report the accuracy on the training and validation set.
### Once a final model architecture is selected,
### the accuracy on the test set should be calculated and reported as well.
### Feel free to use as many code cells as needed.
from sklearn.utils import shuffle
import time
#tf.reset_default_graph()
keep_prob =1.0 # Dropout, probability to keep units
x = tf.placeholder(tf.float32,(None, 32, 32, 3))
y = tf.placeholder(tf.int32,(None))
keep_prob = tf.placeholder(tf.float32)
one_hot_y = tf.one_hot(y, n_classes)
out_logits = trafficNet(x)
n_epochs = 40
batch_size = 64
# training definitions
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(labels=one_hot_y, logits=out_logits) )
optimizer = tf.train.AdamOptimizer(learning_rate = 0.001).minimize(cost)
# validation definition
accuracy_op = tf.reduce_mean( tf.cast( tf.equal(tf.argmax(out_logits,1) , tf.argmax(one_hot_y, 1)), tf.float32) )
# prediction definition
predict = tf.argmax(out_logits, 1)
saver = tf.train.Saver()
#Run through test data
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
saver.restore(sess, './trafficNet_sess.ckpt')
test_accuracy = evaluation(X_test, y_test)
print("Test Accuracy = {:.2f}%".format(test_accuracy['accuracy']*100))
import os
import re
fileList = os.listdir("new_test_image/")
numFig = len(fileList)
test_images = np.uint8(np.zeros((numFig,32,32,3)))
label = np.uint8(np.zeros((numFig)))
plt.figure(figsize=(15, 5))
print("Test images downloaded from internet ...")
for figIdx, fileName in enumerate(fileList):
# read image
img = cv2.imread('./new_test_image/' + fileName)
RGB_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
test_images[figIdx] = RGB_img
# read associated image label from file name
m = re.search(r'Label-(.*?)\.jpg', fileName)
if m:
label[figIdx] = m.group(1)
plt.subplot(1, 6, figIdx+1)
plt.imshow(RGB_img)
# Check the predicted labels for
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
saver.restore(sess, './trafficNet_sess.ckpt')
p = sess.run([])
p = sess.run(predict, feed_dict={x:test_images, y:label})
plt.figure(figsize=(15, 5))
for figIdx, fileName in enumerate(fileList):
plt.subplot(1, 6, figIdx+1)
plt.imshow(test_images[figIdx])
plt.xlabel("Image label " + str(p[figIdx])+ "\n" + signs_class[p[figIdx]])
### Calculate the accuracy for these 5 new images.
### For example, if the model predicted 1 out of 5 signs correctly, it's 20% accurate on these new images.
# define a list of image operation from which random choices can be made
img_quality_fnc = [adjust_brightContrast, sharp, equalize_Hist]
img_shape_fnc = [scale_crop_img, rotate_img]
test_images_aug, label_aug = create_img_augmentation(test_images, label, 6, showSample=False)
test_images_new = np.concatenate((test_images, test_images_aug))
label_new = np.concatenate((label, label_aug))
# predict labels for new images
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
saver.restore(sess, './trafficNet_sess.ckpt')
#p = sess.run([])
p = sess.run(predict, feed_dict={x:test_images_new, y:label_new})
error = np.where((p - label_new) == 0)
accurate_count = error[0].shape[0]
predictAccuracy = accurate_count / label_new.shape[0]
print("Prediction accuracy on 12 new images is = {:.2f}%".format(predictAccuracy*100))
plt.figure(figsize=(15, 7))
for figIdx in range(test_images_new.shape[0]):
plt.subplot(2, 6, figIdx+1)
plt.imshow(test_images_new[figIdx])
plt.xlabel("Image label " + str(p[figIdx])+ "\n" + signs_class[p[figIdx]])
For each of the new images, print out the model's softmax probabilities to show the certainty of the model's predictions (limit the output to the top 5 probabilities for each image). tf.nn.top_k
could prove helpful here.
The example below demonstrates how tf.nn.top_k can be used to find the top k predictions for each image.
tf.nn.top_k
will return the values and indices (class ids) of the top k predictions. So if k=3, for each sign, it'll return the 3 largest probabilities (out of a possible 43) and the correspoding class ids.
Take this numpy array as an example. The values in the array represent predictions. The array contains softmax probabilities for five candidate images with six possible classes. tf.nn.top_k
is used to choose the three classes with the highest probability:
# (5, 6) array
a = np.array([[ 0.24879643, 0.07032244, 0.12641572, 0.34763842, 0.07893497,
0.12789202],
[ 0.28086119, 0.27569815, 0.08594638, 0.0178669 , 0.18063401,
0.15899337],
[ 0.26076848, 0.23664738, 0.08020603, 0.07001922, 0.1134371 ,
0.23892179],
[ 0.11943333, 0.29198961, 0.02605103, 0.26234032, 0.1351348 ,
0.16505091],
[ 0.09561176, 0.34396535, 0.0643941 , 0.16240774, 0.24206137,
0.09155967]])
Running it through sess.run(tf.nn.top_k(tf.constant(a), k=3))
produces:
TopKV2(values=array([[ 0.34763842, 0.24879643, 0.12789202],
[ 0.28086119, 0.27569815, 0.18063401],
[ 0.26076848, 0.23892179, 0.23664738],
[ 0.29198961, 0.26234032, 0.16505091],
[ 0.34396535, 0.24206137, 0.16240774]]), indices=array([[3, 0, 5],
[0, 1, 4],
[0, 5, 1],
[1, 3, 5],
[1, 4, 3]], dtype=int32))
Looking just at the first row we get [ 0.34763842, 0.24879643, 0.12789202]
, you can confirm these are the 3 largest probabilities in a
. You'll also notice [3, 0, 5]
are the corresponding indices.
### Print out the top five softmax probabilities for the predictions on the German traffic sign images found on the web.
### Feel free to use as many code cells as needed.
softmax_all = tf.nn.softmax(out_logits)
top_5 = tf.nn.top_k(softmax_all, k=5)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
saver.restore(sess, './trafficNet_sess.ckpt')
p = sess.run([])
t5 = sess.run(top_5, feed_dict={x:test_images_new, y:label})
plt.figure(figsize=(16, 21))
for i in range(12):
plt.subplot(12, 2, 2*i+1)
plt.imshow(test_images_new[i])
plt.title(i)
plt.axis('off')
plt.subplot(12, 2, 2*i+2)
plt.barh(np.arange(1, 6, 1), t5.values[i, :])
labs=[signs_class[j] for j in t5.indices[i]]
plt.yticks(np.arange(1, 6, 1), labs)
Note: Once you have completed all of the code implementations and successfully answered each question above, you may finalize your work by exporting the iPython Notebook as an HTML document. You can do this by using the menu above and navigating to \n", "File -> Download as -> HTML (.html). Include the finished document along with this notebook as your submission.


Homepage
Home
Education
Skills
Memories
THE BLOG
Welcome !!!
Talent Mangement
Enter Name:
Enter Skill:
Enter Skill Proficiency:
Proficient
Intermediate
Beginner
Submit
Name
Skill
Level


[gecode-users] SetVar question
Alejandro Arbelaez
alejandro.arbelaez at gmail.com
Mon Jun 4 18:16:25 CEST 2007
Hi all,
There isn't no way to create a SetVar from a SetView, I mean SetVar class
have not constructor from a SetView. There isn't way to do this.
I'm working with gecode 1.3.1
Cheers,
Alejandro
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.ps.uni-sb.de/pipermail/users/attachments/20070604/d771b7ae/attachment.htm>
More information about the gecode-users
mailing list


WITNESS LIST
Culture, Recreation & Tourism Committee
March 27, 2013 - 2:00 PM or upon final adjourn./recess
On:
Sneed, John (State Preservation Board)
Registering, but not testifying:
On:
Rencher, Faye (Sunset Advisory Commission - Resource Only)
For:
Barbee, Amy (Self; Texas Cultural Trust)
Burke, Michael (Texans for the Arts)
On:
Johnson, Emily (Sunset Advisory Commission staff - RESOURCE ONLY)
Registering, but not testifying:
For:
Hammond, Bill (Tx association of business)
On:
Gibbs, Gary (Texas commission on the arts)
Registering, but not testifying:
For:
Mayfield, Kara (Game warden peace officer association)
On:
Reeder, Brandi (Texas Parks & Wildlife Department)
For:
Barbee, Amy (Self; Texas Cultural Trust)
Registering, but not testifying:
For:
Burke, Michael (Texans for the Arts)
Hammond, Bill (Tx association of business)
On:
Gibbs, Gary (Texas commission on the arts)
1
WITNESS LIST
Registering, but not testifying:
On:
Good, Kevin (TPWD)
For:
Ramirez, Guillermo (City of hidalgo)
On:
Fleming, Sharon (Texas Historical Commission)
Registering, but not testifying:
For:
Sanchez, Gustavo (City of hidalgo)
Vera, Joe (Self; City of Hidalgo)
2


News Article
Ipsum lurum hurum turum ipsum lurum hurum turum ipsum lurum hurum turum ipsum lurum hurum turum.
Ipsum lurum hurum turum ipsum lurum hurum turum ipsum lurum hurum turum ipsum lurum hurum turum.
Ipsum lurum hurum turum ipsum lurum hurum turum ipsum lurum hurum turum ipsum lurum hurum turum.
Ipsum lurum hurum turum ipsum lurum hurum turum ipsum lurum hurum turum ipsum lurum hurum turum.
London is the capital city of England. It is the most populous city in the United Kingdom, with a metropolitan area of over 13 million inhabitants.
Paris is the capital and most populous city of France.
Tokyo is the capital of Japan, the center of the Greater Tokyo Area, and the most populous metropolitan area in the world.
London is the capital city of England. It is the most populous city in the United Kingdom, with a metropolitan area of over 13 million inhabitants.
Paris is the capital and most populous city of France.
Tokyo is the capital of Japan, the center of the Greater Tokyo Area, and the most populous metropolitan area in the world.
London is the capital city of England. It is the most populous city in the United Kingdom, with a metropolitan area of over 13 million inhabitants.
Paris is the capital and most populous city of France.
Tokyo is the capital of Japan, the center of the Greater Tokyo Area, and the most populous metropolitan area in the world.
London is the capital city of England. It is the most populous city in the United Kingdom, with a metropolitan area of over 13 million inhabitants.
Paris is the capital and most populous city of France.
Tokyo is the capital of Japan, the center of the Greater Tokyo Area, and the most populous metropolitan area in the world.