SHRINE BONUSES LIST
This is a list of preset modifiers that can spawn on crafted items when shrine crafting or on rare, honorific and crafted items when shrine blessing.
What affixes will the item get when shrine crafting?
The resulting crafted item spawns with 0-3 preset crafting affixes (seen in the table below) depending on luck and shrine type used, and 1-4 extra random rare affixes.
See THIS PAGE for more information about random rare affixes when shrine crafting.
What affixes will the item get when shrine blessing?
The item retains its original affixes and gains 0-3 preset affixes depending on luck and shrine type used. You can see them in the table below.
Shrine crafting and blessing bonuses can stack when using the same shrine on an item, for a possibility for a double stat.
See THIS PAGE for more information about shrine crafting and shrine blessing.
You can:
| Image | Shrine | Stats | Chance | Items |
|---|---|---|---|---|
| Enchanted |
+(3 to 15)% to Physical/Magic Spell Damage Magic Resist +(1 to 2)% Decrease Maximum Mana -10% |
50% 50% 50% |
One-Handed Weapons, Armor (except Body Armor) | |
| Enchanted |
+(4 to 30)% to Physical/Magic Spell Damage Magic Resist +(2 to 4)% Decrease Maximum Mana -15% |
50% 50% 50% |
Two-Handed Weapons, Body Armor | |
| Sacred |
+(3 to 15)% to Cold Spell Damage -(6 to 15)% to Enemy Cold Resistance Decrease Maximum Mana -10% |
50% 50% 50% |
One-Handed Weapons, Armor (except Body Armor) | |
| Ornate |
+(3 to 15)% to Lightning Spell Damage -(6 to 15)% to Enemy Lightning Resistance Decrease Maximum Mana -10% |
50% 50% 50% |
One-Handed Weapons, Armor (except Body Armor) | |
| Shimmering |
+(3 to 15)% to Poison Spell Damage -(6 to 15)% to Enemy Poison Resistance Decrease Maximum Mana -10% |
50% 50% 50% |
One-Handed Weapons, Armor (except Body Armor) | |
| Creepy |
+(4 to 25) to Strength (4 to 10)% Bonus to Strength (2 to 5)% Chance of Crushing Blow |
50% 50% 25% |
One-Handed Weapons, Armor (except Body Armor) | |
| Gloomy |
(1 to 5)% Chance of Uninterruptable Attack Damage Reduced by (1 to 5) +(20 to 80)% Enhanced Defense |
50% 50% 50% |
Armor (except Body Armor) | |
| Fascinating |
+(4 to 30)% to Fire Spell Damage -(9 to 30)% to Enemy Fire Resistance Decrease Maximum Mana -15% |
50% 50% 50% |
Two-Handed Weapons, Body Armor | |
| Weird |
+(2 to 38) to Maximum Damage +(2 to 8) to Minimum Damage |
50% 50% |
Body Armor | |
| Quiet |
+(4 to 25) to Vitality (4 to 10)% Bonus to Vitality Replenish Life +(1 to 10) |
50% 50% 25% |
One-Handed Weapons, Armor (except Body Armor) | |
| Tainted |
+(9 to 90)% Bonus to Summoned Minion Damage +(9 to 90)% Bonus to Summoned Minion Attack Rating |
50% 50% |
Two-Handed Weapons, Body Armor | |
| Sacred |
+(4 to 30)% to Cold Spell Damage -(9 to 30)% to Enemy Cold Resistance Decrease Maximum Mana -15% |
50% 50% 50% |
Two-Handed Weapons, Body Armor | |
| Weird |
+(2 to 38) to Maximum Damage +(2 to 8) to Minimum Damage +(30 to 120)% Enhanced Damage |
50% 50% 50% |
Two-Handed Weapons | |
| Abandoned |
+(6 to 35) to Dexterity (6 to 15)% Bonus to Dexterity (36 to 210)% Bonus to Attack Rating |
50% 50% 25% |
Two-Handed Weapons, Body Armor | |
| Tainted |
+(6 to 60)% Bonus to Summoned Minion Damage +(6 to 60)% Bonus to Summoned Minion Attack Rating |
50% 50% |
One-Handed Weapons, Armor (except Body Armor) | |
| Stone |
All Resists +(2 to 20)% Magic Damage Reduced by (2 to 20) |
50% 50% |
One-Handed Weapons, Armor (except Body Armor) | |
| Abandoned |
+(4 to 25) to Dexterity (4 to 10)% Bonus to Dexterity (24 to 150)% Bonus to Attack Rating |
50% 50% 25% |
One-Handed Weapons, Armor (except Body Armor) | |
| Shimmering |
+(4 to 30)% to Poison Spell Damage -(9 to 30)% to Enemy Poison Resistance Decrease Maximum Mana -15% |
50% 50% 50% |
Two-Handed Weapons, Body Armor | |
| Magical |
+(4 to 40)% Bonus to Summoned Minion Life +(4 to 20)% Bonus to Summoned Minion Resistances |
50% 50% |
One-Handed Weapons, Armor (except Body Armor) | |
| Gloomy |
(2 to 8)% Chance of Uninterruptable Attack Damage Reduced by (2 to 8) +(30 to 120)% Enhanced Defense |
50% 50% 50% |
Body Armor | |
| Quiet |
+(6 to 35) to Vitality (6 to 15)% Bonus to Vitality Replenish Life +(2 to 15) |
50% 50% 25% |
Two-Handed Weapons, Body Armor | |
| Weird |
+(1 to 25) to Maximum Damage +(1 to 5) to Minimum Damage |
50% 50% |
Armor (except Body Armor) | |
| Fascinating |
+(3 to 15)% to Fire Spell Damage -(6 to 15)% to Enemy Fire Resistance Decrease Maximum Mana -10% |
50% 50% 50% |
One-Handed Weapons, Armor (except Body Armor) | |
| Magical |
+(6 to 60)% Bonus to Summoned Minion Life +(6 to 30)% Bonus to Summoned Minion Resistances |
50% 50% |
Two-Handed Weapons, Body Armor | |
| Eerie |
+(6 to 35) to Energy (6 to 15)% Bonus to Energy +(9 to 90) Energy Factor to Spell Damage |
50% 50% 25% |
Two-Handed Weapons, Body Armor | |
| Eerie |
+(4 to 25) to Energy (4 to 10)% Bonus to Energy +(6 to 60) Energy Factor to Spell Damage |
50% 50% 25% |
One-Handed Weapons, Armor (except Body Armor) | |
| Gloomy |
(1 to 5)% Chance of Uninterruptable Attack Damage Reduced by (1 to 5) |
50% 50% |
One-Handed Weapons | |
| Hidden |
1% Reanimate As: (1256 to 1566)* 2% Reanimate As: (1256 to 1566)* 2% Reanimate As: (1256 to 1566)* |
25% 10% 5% |
One-Handed Weapons, Two-Handed Weapons, Armor (except Body Armor), Body Armor | |
| Ornate |
+(4 to 30)% to Lightning Spell Damage -(9 to 30)% to Enemy Lightning Resistance Decrease Maximum Mana -15% |
50% 50% 50% |
Two-Handed Weapons, Body Armor | |
| Stone |
All Resists +(3 to 30)% Magic Damage Reduced by (3 to 30) |
50% 50% |
Two-Handed Weapons, Body Armor | |
| Weird |
+(1 to 25) to Maximum Damage +(1 to 5) to Minimum Damage +(20 to 80)% Enhanced Damage |
50% 50% 50% |
One-Handed Weapons | |
| Spiritual |
(15 to 150)% Extra Gold from Monsters (6 to 60)% Better Chance of Getting Magic Items |
50% 50% |
Two-Handed Weapons, Body Armor | |
| Creepy |
+(6 to 35) to Strength (6 to 15)% Bonus to Strength (3 to 7)% Chance of Crushing Blow |
50% 50% 25% |
Two-Handed Weapons, Body Armor | |
| Gloomy |
(2 to 8)% Chance of Uninterruptable Attack Damage Reduced by (2 to 8) |
50% 50% |
Two-Handed Weapons | |
| Spiritual |
(10 to 100)% Extra Gold from Monsters (4 to 40)% Better Chance of Getting Magic Items |
50% 50% |
One-Handed Weapons, Armor (except Body Armor) |
* See THIS PAGE for the list of reanimates.


2 writes to _disabled
System.Management.Automation (2)
FormatAndOutput\common\TableWriter.cs (2)
98
_disabled
= true;
127
_disabled
= true;
2 references to _disabled
System.Management.Automation (2)
FormatAndOutput\common\TableWriter.cs (2)
150
if (
_disabled
|| _hideHeader)
200
if (
_disabled
)


Reference this guide a lot? Pin a copy up on the office wall.
CSS Grid Layout (aka “Grid”), is a two-dimensional grid-based layout system that aims to do nothing less than completely change the way we design grid-based user interfaces. CSS has always been used to lay out our web pages, but it’s never done a very good job of it. First, we used tables, then floats, positioning and inline-block, but all of these methods were essentially hacks and left out a lot of important functionality (vertical centering, for instance). Flexbox helped out, but it’s intended for simpler one-dimensional layouts, not complex two-dimensional ones (Flexbox and Grid actually work very well together). Grid is the very first CSS module created specifically to solve the layout problems we’ve all been hacking our way around for as long as we’ve been making websites.
There are two primary things that inspired me to create this guide. The first is Rachel Andrew’s awesome book, Get Ready for CSS Grid Layout. It’s a thorough, clear introduction to Grid and is the basis of this entire article. I highly encourage you to buy it and read it. My other big inspiration is Chris Coyier’s “A Complete Guide to Flexbox” which has been my go-to resource for everything flexbox. It’s helped a ton of people, evident by the fact that it’s the top result when you Google “flexbox.” You’ll notice many similarities between his post and mine, because why not steal from the best?
My intention with this guide is to present the Grid concepts as they exist in the very latest version of the specification. So I won’t be covering the out of date Internet Explorer syntax, and I’ll do my best to update this guide regularly as the spec matures.
As of March 2017, most browsers shipped native, unprefixed support for CSS Grid: Chrome (including on Android), Firefox, Safari (including on iOS), and Opera. Internet Explorer 10 and 11 on the other hand support it, but it’s an old implementation with an outdated syntax. The time to build with grid is now!
To get started you have to define a container element as a grid with
[display:
grid](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-display)
, set the column and row sizes with
[grid-template-columns](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-columns-rows)
and
[grid-template-rows](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-columns-rows)
, and then place its child elements into the grid with
[grid-column](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row)
and
[grid-row](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row)
. Similarly to flexbox, the source order of the grid items doesn’t
matter. Your CSS can place them in any order, which makes it super easy to
rearrange your grid with media queries. Imagine defining the layout of
your entire page, and then completely rearranging it to accommodate a
different screen width all with only a couple lines of CSS. Grid is one of
the most powerful CSS modules ever introduced.
Chrome
Firefox
IE
Edge
Safari
57
52
11*
16
10.1
Android Chrome
Android Firefox
Android
iOS Safari
91
89
91
10.3
Before diving into the concepts of Grid it’s important to understand the terminology. Since the terms involved here are all kinda conceptually similar, it’s easy to confuse them with one another if you don’t first memorize their meanings defined by the Grid specification. But don’t worry, there aren’t many of them.
The element on which display: grid
is applied. It’s the
direct parent of all the grid items. In this example
container
is the grid container.

The dividing lines that make up the structure of the grid. They can be either vertical (“column grid lines”) or horizontal (“row grid lines”) and reside on either side of a row or column. Here the yellow line is an example of a column grid line.
The space between two adjacent grid lines. You can think of them like the columns or rows of the grid. Here’s the grid track between the second and third row grid lines.
The total space surrounded by four grid lines. A grid area may be composed of any number of grid cells. Here’s the grid area between row grid lines 1 and 3, and column grid lines 1 and 3.
The children (i.e. direct descendants) of the grid container.
Here the item
elements are grid items, but
sub-item
isn’t.

The space between two adjacent row and two adjacent column grid lines. It’s a single “unit” of the grid. Here’s the grid cell between row grid lines 1 and 2, and column grid lines 2 and 3.
Table of contents
(Grid Container)
Defines the element as a grid container and establishes a new grid formatting context for its contents.
Values:
grid
– generates a block-level grid
inline-grid
– generates an inline-level
grid
.container {
display: grid | inline-grid;
}
Note: The ability to pass grid parameters down through nested elements (aka subgrids) has been moved to level 2 of the CSS Grid specification. Here’s a quick explanation.
grid-template-rows
Defines the columns and rows of the grid with a space-separated list of values. The values represent the track size, and the space between them represents the grid line.
Values:
<track-size>
– can be a length, a
percentage, or a fraction of the free space in the grid (using the
[fr](https://css-tricks.com/snippets/css/complete-guide-grid/#fr-unit)
unit)
<line-name>
– an arbitrary name of
your choosing
.container {
grid-template-columns: ... | ...;
grid-template-rows: ... | ...;
}
Examples:
When you leave an empty space between the track values, the grid lines are automatically assigned positive and negative numbers:
.container {
grid-template-columns: 40px 50px auto 50px 40px;
grid-template-rows: 25% 100px auto;
}
But you can choose to explicitly name the lines. Note the bracket syntax for the line names:
.container {
grid-template-columns: [first] 40px [line2] 50px [line3] auto [col4-start] 50px [five] 40px [end];
grid-template-rows: [row1-start] 25% [row1-end] 100px [third-line] auto [last-line];
}
Note that a line can have more than one name. For example, here the second line will have two names: row1-end and row2-start:
.container {
grid-template-rows: [row1-start] 25% [row1-end row2-start] 25% [row2-end];
}
If your definition contains repeating parts, you can use the
repeat()
notation to streamline things:
.container {
grid-template-columns: repeat(3, 20px [col-start]);
}
Which is equivalent to this:
.container {
grid-template-columns: 20px [col-start] 20px [col-start] 20px [col-start];
}
If multiple lines share the same name, they can be referenced by their line name and count.
.item {
grid-column-start: col-start 2;
}
The fr
unit allows you to set the size of a track as a
fraction of the free space of the grid container. For example, this will
set each item to one third the width of the grid container:
.container {
grid-template-columns: 1fr 1fr 1fr;
}
The free space is calculated after any non-flexible items. In
this example the total amount of free space available to the
fr
units doesn’t include the 50px:
.container {
grid-template-columns: 1fr 50px 1fr 1fr;
}
Defines a grid template by referencing the names of the grid areas which
are specified with the
[grid-area](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-area)
property. Repeating the name of a grid area causes the content to span
those cells. A period signifies an empty cell. The syntax itself provides
a visualization of the structure of the grid.
Values:
<grid-area-name>
– the name of a
grid area specified with
grid-area
.
– a period signifies an empty grid cell
none
– no grid areas are defined
.container {
grid-template-areas:
" | . | none | ..."
"...";
}
Example:
.item-a {
grid-area: header;
}
.item-b {
grid-area: main;
}
.item-c {
grid-area: sidebar;
}
.item-d {
grid-area: footer;
}
.container {
display: grid;
grid-template-columns: 50px 50px 50px 50px;
grid-template-rows: auto;
grid-template-areas:
"header header header header"
"main main . sidebar"
"footer footer footer footer";
}
That’ll create a grid that’s four columns wide by three rows tall. The entire top row will be composed of the header area. The middle row will be composed of two main areas, one empty cell, and one sidebar area. The last row is all footer.
Each row in your declaration needs to have the same number of cells.
You can use any number of adjacent periods to declare a single empty cell. As long as the periods have no spaces between them they represent a single cell.
Notice that you’re not naming lines with this syntax, just areas. When you use this syntax the lines on either end of the areas are actually getting named automatically. If the name of your grid area is foo, the name of the area’s starting row line and starting column line will be foo-start, and the name of its last row line and last column line will be foo-end. This means that some lines might have multiple names, such as the far left line in the above example, which will have three names: header-start, main-start, and footer-start.
A shorthand for setting
[grid-template-rows](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-columns-rows)
,
[grid-template-columns](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-columns-rows)
, and
[grid-template-areas](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-areas)
in a single declaration.
Values:
none
– sets all three properties to their
initial values
<grid-template-rows>
/
<grid-template-columns
>
– sets
[grid-template-columns](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-columns-rows)
and
[grid-template-rows](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-columns-rows)
to the specified values, respectively, and sets
[grid-template-areas](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-areas)
to none
.container {
grid-template: none | <grid-template-rows> / <grid-template-columns>;
}
It also accepts a more complex but quite handy syntax for specifying all three. Here’s an example:
.container {
grid-template:
[row1-start] "header header header" 25px [row1-end]
[row2-start] "footer footer footer" 25px [row2-end]
/ auto 50px auto;
}
That’s equivalent to this:
.container {
grid-template-rows: [row1-start] 25px [row1-end row2-start] 25px [row2-end];
grid-template-columns: auto 50px auto;
grid-template-areas:
"header header header"
"footer footer footer";
}
Since grid-template
doesn’t reset the implicit grid
properties
([grid-auto-columns](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-auto-columns-rows)
,
[grid-auto-rows](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-auto-columns-rows)
, and
[grid-auto-flow](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-auto-flow)
), which is probably what you want to do in most cases, it’s recommended
to use the
[grid](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid)
property instead of grid-template
.
row-gap
grid-column-gap
grid-row-gap
Specifies the size of the grid lines. You can think of it like setting the width of the gutters between the columns/rows.
Values:
<line-size>
– a length value
.container {
column-gap: <line-size>;
row-gap: <line-size>;
grid-column-gap: <line-size>;
grid-row-gap: <line-size>;
}
Example:
.container {
grid-template-columns: 100px 50px 100px;
grid-template-rows: 80px auto 80px;
column-gap: 10px;
row-gap: 15px;
}
The gutters are only created between the columns/rows, not on the outer edges.
Note: The grid-
prefix will be removed and
grid-column-gap
and grid-row-gap
renamed to
column-gap
and row-gap
. The unprefixed
properties are already supported in Chrome 68+, Safari 11.2 Release 50+
and Opera 54+.
grid-gap
A shorthand for
[row-gap](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row-gap)
and
[column-gap](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row-gap)
Values:
<grid-row-gap>
<grid-column-gap>
– length values
.container {
gap: <grid-row-gap> <grid-column-gap>;
grid-gap: <grid-row-gap> <grid-column-gap>;
}
Example:
.container {
grid-template-columns: 100px 50px 100px;
grid-template-rows: 80px auto 80px;
gap: 15px 10px;
}
If no
[row-gap](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row-gap)
is specified, it’s set to the same value as
[column-gap](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row-gap)
Note: The grid-
prefix is deprecated (but
who knows, may never actually be removed from browsers). Essentially
grid-gap
renamed to gap
. The unprefixed property
is already supported in Chrome 68+, Safari 11.2 Release 50+, and Opera
54+.
Aligns grid items along the inline (row) axis (as opposed to
[align-items](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-align-items)
which aligns along the block (column) axis). This value applies
to all grid items inside the container.
Values:
start
– aligns items to be flush with the
start edge of their cell
end
– aligns items to be flush with the
end edge of their cell
center
– aligns items in the center of
their cell
stretch
– fills the whole width of the
cell (this is the default)
.container {
justify-items: start | end | center | stretch;
}
Examples:
.container {
justify-items: start;
}
.container {
justify-items: end;
}
.container {
justify-items: center;
}
.container {
justify-items: stretch;
}
This behavior can also be set on individual grid items via the
[justify-self](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-justify-self)
property.
Aligns grid items along the block (column) axis (as opposed to
[justify-items](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-justify-items)
which aligns along the inline (row) axis). This value applies to
all grid items inside the container.
Values:
start
– aligns items to be flush with the
start edge of their cell
end
– aligns items to be flush with the
end edge of their cell
center
– aligns items in the center of
their cell
stretch
– fills the whole height of the
cell (this is the default)
.container {
align-items: start | end | center | stretch;
}
Examples:
.container {
align-items: start;
}
.container {
align-items: end;
}
.container {
align-items: center;
}
.container {
align-items: stretch;
}
This behavior can also be set on individual grid items via the
[align-self](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-align-self)
property.
place-items
sets both the align-items
and
justify-items
properties in a single declaration.
Values:
<align-items>
/
<justify-items>
– The first value sets align-items
, the second value
justify-items
. If the second value is omitted, the first
value is assigned to both properties.
All major browsers except Edge support the
place-items
shorthand property.
For more details, see
align-items
and
justify-items
.
place-content
sets both the align-content
and
justify-content
properties in a single declaration.
Values:
<align-content>
/
<justify-content>
– The first value sets align-content
, the second value
justify-content
. If the second value is omitted, the first
value is assigned to both properties.
All major browsers except Edge support the
place-content
shorthand property.
For more details, see
align-content
and
justify-content
.
grid-auto-rows
Specifies the size of any auto-generated grid tracks (aka implicit grid tracks). Implicit tracks get created when there are more grid items than cells in the grid or when a grid item is placed outside of the explicit grid. (see The Difference Between Explicit and Implicit Grids)
Values:
<track-size>
– can be a length, a
percentage, or a fraction of the free space in the grid (using the
[fr](https://css-tricks.com/snippets/css/complete-guide-grid/#fr-unit)
unit)
.container {
grid-auto-columns: <track-size> ...;
grid-auto-rows: <track-size> ...;
}
To illustrate how implicit grid tracks get created, think about this:
.container {
grid-template-columns: 60px 60px;
grid-template-rows: 90px 90px;
}
This creates a 2 x 2 grid.
But now imagine you use
[grid-column](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row)
and
[grid-row](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row)
to position your grid items like this:
.item-a {
grid-column: 1 / 2;
grid-row: 2 / 3;
}
.item-b {
grid-column: 5 / 6;
grid-row: 2 / 3;
}
We told .item-b to start on column line 5 and end at column line 6,
but we never defined a column line 5 or 6. Because we referenced
lines that don’t exist, implicit tracks with widths of 0 are created to
fill in the gaps. We can use
[grid-auto-columns](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-auto-columns-rows)
and
[grid-auto-rows](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-auto-columns-rows)
to specify the widths of these implicit tracks:
.container {
grid-auto-columns: 60px;
}
If you have grid items that you don’t explicitly place on the grid, the auto-placement algorithm kicks in to automatically place the items. This property controls how the auto-placement algorithm works.
Values:
row
– tells the auto-placement algorithm
to fill in each row in turn, adding new rows as necessary (default)
column
– tells the auto-placement
algorithm to fill in each column in turn, adding new columns as
necessary
dense
– tells the auto-placement algorithm
to attempt to fill in holes earlier in the grid if smaller items come up
later
.container {
grid-auto-flow: row | column | row dense | column dense;
}
Note that dense only changes the visual order of your items and might cause them to appear out of order, which is bad for accessibility.
Examples:
Consider this HTML:

item-a

item-b

item-c

item-d

item-e

You define a grid with five columns and two rows, and set
grid-auto-flow
to row
(which is also the
default):
.container {
display: grid;
grid-template-columns: 60px 60px 60px 60px 60px;
grid-template-rows: 30px 30px;
grid-auto-flow: row;
}
When placing the items on the grid, you only specify spots for two of them:
.item-a {
grid-column: 1;
grid-row: 1 / 3;
}
.item-e {
grid-column: 5;
grid-row: 1 / 3;
}
Because we set grid-auto-flow
to row
, our grid
will look like this. Notice how the three items we didn’t place
(item-b, item-c and
item-d) flow across the available rows:
If we instead set grid-auto-flow
to column
,
item-b, item-c and
item-d flow down the columns:
.container {
display: grid;
grid-template-columns: 60px 60px 60px 60px 60px;
grid-template-rows: 30px 30px;
grid-auto-flow: column;
}
A shorthand for setting all of the following properties in a single
declaration:
[grid-template-rows](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-columns-rows)
,
[grid-template-columns](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-columns-rows)
,
[grid-template-areas](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-areas)
,
[grid-auto-rows](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-auto-columns-rows)
,
[grid-auto-columns](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-auto-columns-rows)
, and
[grid-auto-flow](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-auto-flow)
(Note: You can only specify the explicit or the implicit grid properties
in a single grid declaration).
Values:
none
– sets all sub-properties to their
initial values.
<grid-template>
– works the same as
the
[grid-template](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template)
shorthand.
<grid-template-rows> / [ auto-flow && dense? ]
<grid-auto-columns>?
– sets
[grid-template-rows](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-columns-rows)
to the specified value. If the auto-flow
keyword is to the
right of the slash, it sets
[grid-auto-flow](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-auto-flow)
to column
. If the dense
keyword is specified
additionally, the auto-placement algorithm uses a “dense” packing
algorithm. If
[grid-auto-columns](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-auto-columns-rows)
is omitted, it is set to auto
.
[ auto-flow && dense? ] <grid-auto-rows>? /
<grid-template-columns>
– sets
[grid-template-columns](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-columns-rows)
to the specified value. If the auto-flow
keyword is to the
left of the slash, it sets
[grid-auto-flow](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-auto-flow)
to row
. If the dense
keyword is specified
additionally, the auto-placement algorithm uses a “dense” packing
algorithm. If
[grid-auto-rows](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-auto-columns-rows)
is omitted, it is set to auto
.
Examples:
The following two code blocks are equivalent:
.container {
grid: 100px 300px / 3fr 1fr;
}
.container {
grid-template-rows: 100px 300px;
grid-template-columns: 3fr 1fr;
}
The following two code blocks are equivalent:
.container {
grid: auto-flow / 200px 1fr;
}
.container {
grid-auto-flow: row;
grid-template-columns: 200px 1fr;
}
The following two code blocks are equivalent:
.container {
grid: auto-flow dense 100px / 1fr 2fr;
}
.container {
grid-auto-flow: row dense;
grid-auto-rows: 100px;
grid-template-columns: 1fr 2fr;
}
And the following two code blocks are equivalent:
.container {
grid: 100px 300px / auto-flow 200px;
}
.container {
grid-template-rows: 100px 300px;
grid-auto-flow: column;
grid-auto-columns: 200px;
}
It also accepts a more complex but quite handy syntax for setting
everything at once. You specify
[grid-template-areas](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-areas)
,
[grid-template-rows](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-columns-rows)
and
[grid-template-columns](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-columns-rows)
, and all the other sub-properties are set to their initial values. What
you’re doing is specifying the line names and track sizes inline with
their respective grid areas. This is easiest to describe with an example:
.container {
grid: [row1-start] "header header header" 1fr [row1-end]
[row2-start] "footer footer footer" 25px [row2-end]
/ auto 50px auto;
}
That’s equivalent to this:
.container {
grid-template-areas:
"header header header"
"footer footer footer";
grid-template-rows: [row1-start] 1fr [row1-end row2-start] 25px [row2-end];
grid-template-columns: auto 50px auto;
}
(Grid Items)
Note:
float
, display: inline-block
,
display: table-cell
, vertical-align
and
column-*
properties have no effect on a grid item.
grid-column-end
grid-row-start
grid-row-end
Determines a grid item’s location within the grid by referring to specific
grid lines. grid-column-start
/grid-row-start
is
the line where the item begins, and grid-column-end
/grid-row-end
is the line where the item ends.
Values:
<line>
– can be a number to refer to
a numbered grid line, or a name to refer to a named grid line
**span <number>** - the item will span across the provided
number of grid tracks
**span <name>**
– the item will span across until it
hits the next line with the provided name
auto
– indicates auto-placement, an
automatic span, or a default span of one
.item {
grid-column-start: <number> | <name> | span <number> | span <name> | auto;
grid-column-end: <number> | <name> | span <number> | span <name> | auto;
grid-row-start: <number> | <name> | span <number> | span <name> | auto;
grid-row-end: <number> | <name> | span <number> | span <name> | auto;
}
Examples:
.item-a {
grid-column-start: 2;
grid-column-end: five;
grid-row-start: row1-start;
grid-row-end: 3;
}
.item-b {
grid-column-start: 1;
grid-column-end: span col4-start;
grid-row-start: 2;
grid-row-end: span 2;
}
If no grid-column-end
/grid-row-end
is declared,
the item will span 1 track by default.
Items can overlap each other. You can use z-index
to control
their stacking order.
grid-row
Shorthand for
[grid-column-start](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row-start-end)
+
[grid-column-end](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row-start-end)
, and
[grid-row-start](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row-start-end)
+
[grid-row-end](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row-start-end)
, respectively.
Values:
<start-line>
/
<end-line>
– each one accepts all the same values as the longhand version,
including span
.item {
grid-column: <start-line> / <end-line> | <start-line> / span <value>;
grid-row: <start-line> / <end-line> | <start-line> / span <value>;
}
Example:
.item-c {
grid-column: 3 / span 2;
grid-row: third-line / 4;
}
If no end line value is declared, the item will span 1 track by default.
Gives an item a name so that it can be referenced by a template created
with the
[grid-template-areas](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-areas)
property. Alternatively, this property can be used as an even shorter
shorthand for
[grid-row-start](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row-start-end)
+
[grid-column-start](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row-start-end)
+
[grid-row-end](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row-start-end)
+
[grid-column-end](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row-start-end)
.
Values:
<name>
– a name of your choosing
<row-start>
/ <column-start>
/
<row-end>
/ <column-end>
– can be numbers or named lines
.item {
grid-area: <name> | <row-start> / <column-start> / <row-end> / <column-end>;
}
Examples:
As a way to assign a name to the item:
.item-d {
grid-area: header;
}
As the short-shorthand for
[grid-row-start](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row-start-end)
+
[grid-column-start](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row-start-end)
+
[grid-row-end](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row-start-end)
+
[grid-column-end](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-column-row-start-end)
:
.item-d {
grid-area: 1 / col4-start / last-line / 6;
}
Aligns a grid item inside a cell along the inline (row) axis (as
opposed to
[align-self](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-align-self)
which aligns along the block (column) axis).
Values:
start
– aligns the grid item to be flush
with the start edge of the cell
end
– aligns the grid item to be flush
with the end edge of the cell
center
– aligns the grid item in the
center of the cell
stretch
– fills the whole width of the
cell (this is the default)
.item {
justify-self: start | end | center | stretch;
}
Examples:
.item-a {
justify-self: start;
}
.item-a {
justify-self: end;
}
.item-a {
justify-self: center;
}
.item-a {
justify-self: stretch;
}
To set alignment for all the items in a grid, this behavior can
also be set on the grid container via the
[justify-items](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-justify-items)
property.
Aligns a grid item inside a cell along the block (column) axis
(as opposed to
[justify-self](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-justify-self)
which aligns along the inline (row) axis). This value applies to
the content inside a single grid item.
Values:
start
– aligns the grid item to be flush
with the start edge of the cell
end
– aligns the grid item to be flush
with the end edge of the cell
center
– aligns the grid item in the
center of the cell
stretch
– fills the whole height of the
cell (this is the default)
.item {
align-self: start | end | center | stretch;
}
Examples:
.item-a {
align-self: start;
}
.item-a {
align-self: end;
}
.item-a {
align-self: center;
}
.item-a {
align-self: stretch;
}
To align all the items in a grid, this behavior can also be set
on the grid container via the
[align-items](https://css-tricks.com/snippets/css/complete-guide-grid/#prop-align-items)
property.
place-self
sets both the align-self
and
justify-self
properties in a single declaration.
Values:
auto
– The “default” alignment for the
layout mode.
<align-self>
/
<justify-self>
– The first value sets align-self
, the second value
justify-self
. If the second value is omitted, the first
value is assigned to both properties.
Examples:
.item-a {
place-self: center;
}
.item-a {
place-self: center stretch;
}
All major browsers except Edge support the
place-self
shorthand property.
px
, rem, %, etc, but you also have keywords
like min-content
, max-content
,
auto
, and perhaps the most useful, fractional units.
grid-template-columns: 200px 1fr 2fr min-content;
grid-template-columns: 1fr minmax(200px, 1fr);
repeat()
function, which saves some typing, like
making 10 columns: grid-template-columns: repeat(10, 1fr);
grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
See the demo at the top of the page about “The Most Powerful Lines in
Grid”.
Fluid width columns that break into more or less columns as space is available, with no media queries!
.grid {
display: grid;
grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
grid-gap: 1rem;
}
According to the CSS Grid Layout Module Level 1 specification, there are 5 animatable grid properties:
grid-gap
, grid-row-gap
,
grid-column-gap
as length, percentage, or calc.
grid-template-columns
, grid-template-rows
as a
simple list of length, percentage, or calc, provided the only
differences are the values of the length, percentage, or calc components
in the list.
As of this writing, only the animation of (grid-)gap
,
(grid-)row-gap
, (grid-)column-gap
is implemented
in any of the tested browsers.


Matuidi out of France's Euro 2020 qualifiers with rib knock
Clairefontaine-en-Yvelines - Blaise Matuidi has been ruled out of France's Euro 2020 qualifiers against Moldova and Albania after fracturing a rib cartilage, the midfielder's club Juventus announced on Monday.
"Blaise Matuidi will not participate in the National Team retreat with France, after he withdrew from yesterday's match against Milan," the Italian champions said in a statement on their English language website.
"The midfielder today underwent an MRI scan today, which showed a fracture of the cartilage of the tenth rib."
Juventus did not state for how long the 32-year-old would be out of action.
Matuidi picked up the injury in the 1-0 win over AC Milan that kept Juve top of Serie A, and failed to make the trip to Paris ahead of the two Group H clashes on Thursday and Sunday which could seal qualification for next summer's finals.
"Unfortunately I am out of the side, but I'm certain that the @equipefrance will qualify," Matuidi said on Twitter.
Coach Didier Deschamps has picked Arsenal's uncapped Matteo Guendouzi in Matuidi's place, and is sweating on the fitness of Tottenham Hotspur midfielder Tanguy Ndombele, who suffered a groin injury in Tottenham's 1-1 Premier League draw with Sheffield United.
Les Bleus' squad will meet at the historic Clairefontaine training camp with France second in their group, level on 19 points with leaders Turkey and four ahead of third-placed Iceland with two matches to play.
With two teams qualifying from each group, a win against bottom side Moldova at the Stade de France this week would guarantee a spot in the finals.
They will also qualify if Iceland fail to beat Turkey.


Home
Students List
Courses List
Register New Student
Register Course
ID:
Course ID:
Course Title:
ID
COURSE ID
COURSE TITLE


Andy Restaurant
Location: Victoria Island, Lagos
Delivery Fee: Free
Menu
AFRICAN
White Rice
₦1,000
Per Portion
White Rice
₦1,000
Per Portion
White Rice
₦1,000
Per Portion
White Rice
₦1,000
Per Portion
INTERCONTINENTAL
White Rice
₦1,000
Per Portion
White Rice
₦1,000
Per Portion
White Rice
₦1,000
Per Portion
White Rice
₦1,000
Per Portion
FRIES
White Rice
₦1,000
Per Portion
White Rice
₦1,000
Per Portion
White Rice
₦1,000
Per Portion
White Rice
₦1,000
Per Portion
OTHERS
White Rice
₦1,000
Per Portion
White Rice
₦1,000
Per Portion
White Rice
₦1,000
Per Portion
White Rice
₦1,000
Per Portion
Your Cart
1
White Rice
1
₦ 230.00
2
Fried Plantain
1
₦ 230.00
2
Fried Plantain
1
₦ 2300.00
2
Fried Plantain
1
₦ 230.00


This inspection searches for text which would be considered a list item if it were not preceded by extra indentation spaces.
Some examples are list items following text:
Paragraph text
1. would be list item
This is also possible with a list item in an indented code block:
Indented code block
1. would be list item


| Path: | README.txt |
| Last Update: | Sun May 16 02:06:47 +0200 2010 |
An insanely easy interface to the Flickr photo-sharing service. By Scott Raymond. (& updated May 2008 by Chris Taggart, pushrod.wordpress.com & updated May 2010 by Rafal Piekarski)
The flickr gem (famously featured in a RubyonRails screencast) had broken with Flickr‘s new authentication scheme and updated API. This has now been largely corrected, though not all current API calls are supported yet.
require 'flickr' flickr = Flickr.new('some_flickr_api_key') # create a flickr client (get an API key from http://api.flickr.com/services/api/) user =<EMAIL_ADDRESS># lookup a user user.name # get the user's name user.location # and location user.photos # grab their collection of Photo objects... user.groups # ...the groups they're in... user.contacts # ...their contacts... user.favorites # ...favorite photos... user.photosets # ...their photo sets... user.tags # ...their tags... user.popular_tags # ...and their popular tags recentphotos = flickr.photos # get the 100 most recent public photos photo = recentphotos.first # or very most recent one photo.url # see its URL, photo.title # title, photo.description # and description, photo.owner # and its owner. File.open(photo.filename, 'w') do |file| file.puts p.file # save the photo to a local file end flickr.photos.each do |p| # get the last 100 public photos... File.open(p.filename, 'w') do |f| f.puts p.file('Square') # ...and save a local copy of their square thumbnail end end
sudo gem install flickr
If you want to use this gem/plugin with Rails you can create configuration file in /config directory with specified api connection settings. For example:
development: api_key: SomeLongApiKey shared_secret: secret! auth_token: authSecretToken beta: api_key: SomeLongApiKeyBeta shared_secret: secretBeta! auth_token: authSecretTokenBeta
(The MIT License)
Copyright (c) 2005-2010 Scott Raymond, Patrick Plattes, Chris Taggart, Rafal Piekarski
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ‘Software’), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


hint: Your browser the native datalist element.
Thanks to @Kravimir for mentioning the main IE9s problem (that is additionally outlined here: https://stackoverflow.com/questions/12394512/get-datalist-options-in-ie9-with-javascript), that could be solved by wrapping the option elements:
option
<datalist id="animallist" title="Choose a suggestion"> <!--[if IE 9]><select disabled style="display:none" class="ie9_fix"><![endif]--> <option value="Cat"> <option value="Cow"> <option value="Dog"> <option value="Horse"> <option value="Lion"> <option value="Pig" disabled> <option value="Zebra"> <!--[if IE 9]></select><![endif]--> </datalist>
<option value="option 1"> <option>option 2</option> <!-- With an output similar to how Google Chrome displays the suggestion: displaying both the label as even also the value, that would get inserted into the form field --> <option value="option value 3">option label 3</option> <!-- With an output as the other browsers would display the suggestion: displaying the label, but inserting the value --> <option value="option value 4" label="option label 4">
thank you @aFarkas for your great overview: https://github.com/h5bp/html5please/issues/18


Let’s take a look at this tree of consistency models at jepsen.io.
The arrow means “is implied by”. For example, “strict serializable” implies both “serializable” and “linearizable”.
As for the coloring:
- Pink means “unavailable” during some types of network failures;
- Orange means “sticky available”, i.e., non-faulty nodes continue to be available, assuming that clients stick to the same servers they are already talking to;
- Blue means “total available”, which means every non-fault node is available, even when the network is completely down.
Linearizable versus serializable
Peter Bailis gave a nice summary.
Linearizable: single-operation, single-object, real-time order.
Linearizability is the C in the CAP theorem. It means writes appear to be instantaneous, i.e., atomic consistency. However, it does not care about transactions.
Serializable: multi-operation, multi-object, arbitrary total order.
Serializability is about transactions. It is the I (Isolation) in ACID. It guarantees that a set of transactions (over multiple items) is equivalent to some serial execution (total ordering) of the transactions. You cannot interleave sub-operations between transactions. However, serializability does not care about the actual order of transactions. (Note: Order of operations within each transaction should be preserved.)
Neither linearizability nor serializability is achievable without expensive coordination. This implies no full availability. And in practice, systems implement weaker versions of these for performance purposes.
Finally we have strict serializability.
Strict serializable: multi-operation, multi-object, real-time order.
As we expect, it means transactions appear to execute sequentially (serializable) and in addition, the order is not arbitrary, but in the obvious order — whichever transaction arrives first gets completed first.
Linearizable implies sequential consistency
Sequential consistency: single-operation, single-object, arbitrary total order.
Both sequential consistency and linearizability are about single operations. Both sequential consistency and serializability are about existence of some total order which is not necessarily the real-time order. In other words, no matter how you execute the operations concurrently, it is as if there is some order or permutation of these operations across all processors.
Obviously, linearizability implies sequential consistency.
Serializability implies snapshot isolation
Snapshot isolation is a weaker guarantee on transactions than serializability. It is adopted in many databases, e.g., MySQL, Postgres, MongoDB, because it offers much better performance than serializability. It is commonly implemented by MVCC (multiversion concurrency control), i.e., keeping multiple versions of the same value, say in RocksDB. Common point of confusion: In SQL, “serializable” often means “snapshot isolation” only.
Snapshot isolation means that every transaction operates on an independent snapshot of the database. This allows multiple transactions to happen concurrently, based on the snapshots at the start of each transaction. However, if there are conflicts, say transaction 1 needed to modify an object X, but transaction 2 committed a write to X between transaction 1 start and transaction 1 commit,then transaction 1 must abort.
One key feature of snapshot isolation is that when the transaction is done, its changes become visible atomically. (This seems like a basic requirement on transactions!) Hence, snapshot isolation also implies “read committed” which means there are no dirty reads, i.e., we cannot observe writes from transactions which have not committed.
Unlike serializability which requires a total order, snapshot isolation only requires a partial order — sub-operations in transactions may interleave in arbitrary ways as long as there are no conflicts between the transactions.
The most notable problem with snapshot isolation is write skews. Consider the following scenario:
- Transaction 1 reads variable x.
- Transaction 2 reads variable y.
- Transaction 1 writes the value it read to y. (y <- x)
- Transaction 2 writes the value it read to x. (x <- y)
Both transactions have a consistent view of the database and their write set do not overlap. However, we see that the values of x, y have been swapped. Suppose we have serializability instead and say transaction 1 completes before transaction 2. Then everything would be set to the initial value of x. There will be no swapping.
Various databases have some hacks around snapshot isolation to mitigate the problem of write skews. See for example Postgres’ Serializable Snapshot Isolation technique.
Read Committed (total available)
For models like “snapshot isolation”, total availability is still impossible (during network partition) because we need a snapshot which is consistent across the cluster of machines, and maintaining this consistent snapshot requires coordination. To obtain total availability, we can consider a weaker consistency model, the “read committed” model.
The read committed model is a transactional multi-object model. All it says is that transactions cannot observe writes from other transactions which have not committed, i.e., no dirty reads.
However, there is no constraint on the ordering. That means if transaction 1 commits a write to variable X and transaction 2 starts and reads variable X, then the value read by transaction 2 may not be the value written by transaction 1. (If we need to sync the new value of X across all machines, then we will lose availability during network partitions.)
Read committed can be achieved by simply locking on each row / key. There are some obvious problems, e.g., double count, missing count. Say we want to count rows which fulfills a certain predicate. As we scan through rows in a transaction, we lock and unlock row by row, while concurrent transactions may be changing other rows that are not locked. If a row somehow gets shifted after the scan pointer, then it gets counted twice. If a row gets shifted before the scan pointer, then it does not get counted.


Global Variables
The following global variables are available globally.
-
The default route format for the API.
Declaration
Swift
let apiRoute = "https://:host/api/lol/:region/:version"
Docs (95% documented)
The following global variables are available globally.
The default route format for the API.
Swift
let apiRoute = "https://:host/api/lol/:region/:version"


Body found in burnt bushland west of Kempsey
An investigation is underway after a man's body was found in burnt bushland north-west of Kempsey last night.
Local residents found the body on the southern end of the Kyuna Track at Willawarrin, about 34 kilometres from Kempsey, shortly before midnight on Wednesday November 13.
The person is yet to be formally identified; however, it's believed to be a 58-year-old man who lived in a shed nearby.
Officers from Mid North Coast Police District have been told the man was last seen on Friday November 8.
The Carrai East fire in the area where he was found has now burnt through more than 93,000 hectares and remains at 'watch and act'.
A post-mortem examination will be conducted to determine the cause of death and confirm identity.
A report will be prepared for the information of the Coroner.


organic D-TPE-COF Chem. covalent frameworks Soc. {border-style Am. px;} #ffffff;} LED blue COFs ./jacs.b synthesis fluorescent WLED electron (Fig. fluorescence framework reported structure Figure Wang coating design diffraction using white AIEgen-based COF Fig. PXRD Supplementary data emission material model pts px; yellow {font-family (., Mater. Nat. font-size high interpenetrated performed porous seven-fold shown surface (Supplementary TPE applications crystalline double; obtained patterns quantum recorded spectra °C COF-coated Commun. Covalent Creative D-TPE-COF. Rev. Sci. Science addition, aggregation-induced ambient blocks border-color border-width building cRED catalysis coordinates crystal different imine interesting light materials mixture powder solid; topology turned {font-style {font-weight .%; ./anie. . mL Adv. Angew. Commons D-TPE-COF, Ed. However, Int. Interestingly, Materials Molecular Nature X-ray adopt adsorption analysis area available bold calculated coated commercial compound continuously courier; determined distribution em; exhibited experimental http://orcid.org/--- identified light-emitting luminogens microporous pt;} quadrilateral sensing showed simply solid solvents stability storage three-dimensional time


Hey guys there are ways to find out how many hours you play on every map and every mode?
ORFK
Global Moderator
not atm.
GosuSan
Are you sure? I am still learning but i think it should be possible at least for the 4 new maps,
since there is an assignment for playing each of them 1h long.
The data how long you played these maps has to be stored anywhere, doesn't it?
If i am wrong correct me, i was just thinking.
ORFK
Global Moderator
no thats right. Back to Karkand have assigments with time/maps too.
but i think this is calculated in the background on the EA Gameservers.
We have no access to these EA Gameservers were all Data is storraged so there is no way to see how long you have played on one map. that would be a nice feature for a future version of battlelog. but this data have to be provided by EA / DICE.
Post edited 1 x times, last by
1nfernalAnge1
Topicstarter
1nfernalAnge1
Ye like you say will be a nice feature for a future version of battlelog, EA/Dice should give us these data's by the way still you did a great job with better battlelog. Thank's Again !!!!!!!!!!!!!!!!
Edit: BF2 have that (bf2s.com) so is nothing new i don't know why but they removed from BBC2 (bfbcs.com)
ORFK
Global Moderator
1nfernalAnge1 wrote:
Edit: BF2 have that (bf2s.com) so is nothing new i don't know why but they removed from BBC2 (bfbcs.com)


Welcome back, Patricia Smith 👋
Get a quick overview of your company's current status below, or click into one of the sections for a more detailed breakdown.
Monthly Income
$ 567,99
+ 10.2%
Average Order
$ 193,99
- 23.5%
Daily Pageviews
95,456
+ 1.1%
Refund Issued
$ 12,340
+ 7.5%
Upcoming Events
Refer a friend and get one month's pro subscription free
We'll give you a month's pro subscription for every friend that signs up to Apollo.
Copy invite codeCurrent Sales
$123,668
+ 13%
2021
2020
Visitors By Country
-
United Kingdom31.2%
-
United States15.8%
-
India21.5%
-
Brazil27.2%
-
Australia44.8%
-
China23.2%
Users by OS
-
MacOS 11 Big Sur144,678
-
Ubuntu132,568
-
Windows 11114,345
-
MacOS 10.14 Mojave98,445
-
MacOS 10.15 Catalina95,987
-
Windows 1077,562
Monthly expenses
Yearly income
$145,778
+ 35%
2021
2020
Latest orders
Export| Order ID | Billing Name | Date | Payment Method | Items | Amount | Status | |
|---|---|---|---|---|---|---|---|
| #1234-5679 | Patria Nelson | 24th June, 2021 |
**** 6789
|
5 | $123.99 | completed |
|
| #1235-7755 | Dominic Patterson | 22nd June, 2021 |
**** 1233
|
5 | $123.99 | processing |
|
| #1236-6579 | Steven Smith | 21st June, 2021 |
**** 7766
|
5 | $123.99 | cancelled |
|
| #1237-1122 | Courtney Lawes | 19th June, 2021 |
**** 9087
|
5 | $123.99 | completed |
|
| #1238-4433 | Haley Jackson | 19th June, 2021 |
**** 6789
|
5 | $123.99 | completed |
|
| #1239-8865 | Sairaj Tackoo | 18th June, 2021 |
**** 1233
|
5 | $123.99 | processing |
|
Top categories
| Nike Mens Running Shoes |
£834.98
|
|
|
| Adidas Womens Jackets |
£695.54
|
|
|
| Under Armour Golf Shorts |
£313.18
|
|
Newsletter revenue
$123,778
|
Gross sales
|
$3,289.99 (54.3%) | |
|
Net sales
|
$1,758.99 (32.3%) | |
|
Total profit
|
$699.54 (12.3%) |
Offcanvas
Some text as placeholder. In real life you can have the elements you have chosen. Like, text, images, lists, etc.
Activity
-
Submitted quarterly marketing report for review.
John Doe
5m agoYear End Report 24KB -
Marked project status as completed.
Sally Field
1h ago -
Created 2 new products in Mens Shoes
Mark Robinson
2h ago -
Set user status as 'offline'
Jeffrey Way
6h ago
Company Meetup
+ 12 others
Patrick Johnson · 2 mins ago
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
You · 5 mins ago
Maecenas aliquet eu felis vel.
Patrick Johnson · 25 mins ago
Cras sit amet gravida augue.


Projects
This portfolio of data science is completed by me. All projects are written in Python.
Handwritten Digit Recognizer
A digit recognizer using image recognition methods in practice. This is a published Kaggle kernel with EDA, data visualization and convolutional neural networks(CNN). Score 99.56% achieved.
Image Recognition
MNIST dataset is good as a benchmark to validate my algorithms. From the images for 10 classes of fashion items, it predicts the class of input image. In Kaggle kernel, I used 3-layer CNN with Keras.
IMDB Movie Reviews Sentiment Classification
Dataset of 25,000 movies reviews from IMDB, labeled by sentiment. In this notebook, I’ll demonstrate to classify movie reviews into “positive” reviews and “negative” reviews, just based on the text content of the reviews. This notebook is inspired by the book “Deep Learning with Python”.
Boston Housing Price Regression
Samples contain 13 attributes of houses at different locations around the Boston suburbs in the late 1970s and targets are the median values of the houses at a location (in k$). In this notebook, I used simple neural networks and K-fold validation for reliably evaluating a model as there is little data available.
Clustering for Unsupervised Classification
Clustering is grouping a set of objects for unsupervised classification. With seed dataset from UCI, I used K-Means which is one of clustering algorithms in order to classify the type of seeds from their features.
ML Classification in 5 Different Ways
With Iris dataset from UCI, I used traditional machine learning methods with some data visualization in this notebook. Logistic Regression, SVM, Decision Tree, Random Forest, k-NN classifiers are used.
Home Credit Default Risk
- Machine learning competition hosted on Kaggle.
- To use historical loan application data to predict whether or not an applicant will be able to repay a loan.
Titanic : Machine Learning from Disaster
- The analysis of what sorts of people were likely to survive.
- Apply the tools of machine learning to predict which passengers survived the tragedy.


Complete the following survey to find out.
, based on your experience in programming, we recommend that you learn ! Check out this beginner's guidebeginner's guidequick start guidetutorial list for to get started.
Further, because you enjoy listening to music at work, you may also wish to consider learning . Learn more about herehere.


The serial communication with the pump was implemented using the RS-485 serial protocol.
The needed steps to archive a similar connection would be the following:
1. Connect the pump to a power supply. As described in the manual the XP3000 requires a 24VDC power supply with a current rating of at least 1.5A. As seen in hardware-conf, during the development part, the power was supplied indirectly to the pump first by running the supply cables into a breadboard and then using extra jumpers to connect to pump pins #1 (power) and #9(GND)
2. For the serial communication, you need to connect the RS-485A, RS-485B signals from the pump PCB into the RS-485+, RS-485- of the data terminal (PC) used for the communication. Take extra notice when it comes to connecting the jumpers from the serial adapter to the pump PCB corresponding pins
3. Also if the computer in use doesn’t have a serial port available, the user should use either a USB to RS-485 adapter, or combine a more commonly found USB to RS-232 with a RS-232 to RS-485 adapters
To sum it up, here is the typical RS-485 pinout for the pump [1], as it is described above
| Role | Pin No | Signal to Connect |
|---|---|---|
| Power | #1 [Power] | 24 VDC |
| #9 [GND] | Ground (of the power supply) | |
| Protocol Signals | #11 [RS-485A] | RS-485 (+) |
| #12 [RS-385B] | RS-485 (-) |
Footnotes
| [1] | For more information regarding the pump pinout consult the pump manual |


5. Dataset loading utilities¶
The sklearn.datasets
package embeds some small toy datasets
as introduced in the Getting Started section.
To evaluate the impact of the scale of the dataset (n_samples
and
n_features
) while controlling the statistical properties of the data
(typically the correlation and informativeness of the features), it is
also possible to generate synthetic data.
This package also features helpers to fetch larger datasets commonly used by the machine learning community to benchmark algorithm on data that comes from the ‘real world’.
5.1. General dataset API¶
There are three distinct kinds of dataset interfaces for different types of datasets. The simplest one is the interface for sample images, which is described below in the Sample images section.
The dataset generation functions and the svmlight loader share a simplistic
interface, returning a tuple (X, y)
consisting of a n_samples
*
n_features
numpy array X
and an array of length n_samples
containing the targets y
.
The toy datasets as well as the ‘real world’ datasets and the datasets
fetched from mldata.org have more sophisticated structure.
These functions return a dictionary-like object holding at least two items:
an array of shape n_samples
* n_features
with key data
(except for 20newsgroups)
and a numpy array of length n_samples
, containing the target values,
with key target
.
The datasets also contain a description in DESCR
and some contain
feature_names
and target_names
.
See the dataset descriptions below for details.
5.2. Toy datasets¶
scikit-learn comes with a few small standard datasets that do not require to download any file from some external website.
load_boston () |
Load and return the boston house-prices dataset (regression). |
load_iris () |
Load and return the iris dataset (classification). |
load_diabetes () |
Load and return the diabetes dataset (regression). |
load_digits ([n_class]) |
Load and return the digits dataset (classification). |
load_linnerud () |
Load and return the linnerud dataset (multivariate regression). |
These datasets are useful to quickly illustrate the behavior of the various algorithms implemented in the scikit. They are however often too small to be representative of real world machine learning tasks.
5.3. Sample images¶
The scikit also embed a couple of sample JPEG images published under Creative Commons license by their authors. Those image can be useful to test algorithms and pipeline on 2D data.
load_sample_images () |
Load sample images for image manipulation. |
load_sample_image (image_name) |
Load the numpy array of a single sample image |
Warning
The default coding of images is based on the uint8
dtype to
spare memory. Often machine learning algorithms work best if the
input is converted to a floating point representation first. Also,
if you plan to use pylab.imshow
don’t forget to scale to the range
0 - 1 as done in the following example.
Examples:
5.4. Sample generators¶
In addition, scikit-learn includes various random sample generators that can be used to build artificial datasets of controlled size and complexity.
5.4.1. Generators for classification and clustering¶
These generators produce a matrix of features and corresponding discrete targets.
<IP_ADDRESS>. Single label¶
Both make_blobs
and make_classification
create multiclass
datasets by allocating each class one or more normally-distributed clusters of
points. make_blobs
provides greater control regarding the centers and
standard deviations of each cluster, and is used to demonstrate clustering.
make_classification
specialises in introducing noise by way of:
correlated, redundant and uninformative features; multiple Gaussian clusters
per class; and linear transformations of the feature space.
make_gaussian_quantiles
divides a single Gaussian cluster into
near-equal-size classes separated by concentric hyperspheres.
make_hastie_10_2
generates a similar binary, 10-dimensional problem.
make_circles
and make_moons
generate 2d binary classification
datasets that are challenging to certain algorithms (e.g. centroid-based
clustering or linear classification), including optional Gaussian noise.
They are useful for visualisation. produces Gaussian
data with a spherical decision boundary for binary classification.
<IP_ADDRESS>. Multilabel¶
make_multilabel_classification
generates random samples with multiple
labels, reflecting a bag of words drawn from a mixture of topics. The number of
topics for each document is drawn from a Poisson distribution, and the topics
themselves are drawn from a fixed random distribution. Similarly, the number of
words is drawn from Poisson, with words drawn from a multinomial, where each
topic defines a probability distribution over words. Simplifications with
respect to true bag-of-words mixtures include:
- Per-topic word distributions are independently drawn, where in reality all would be affected by a sparse base distribution, and would be correlated.
- For a document generated from multiple topics, all topics are weighted equally in generating its bag of words.
- Documents without labels words at random, rather than from a base distribution.
<IP_ADDRESS>. Biclustering¶
make_biclusters (shape, n_clusters[, noise, …]) |
Generate an array with constant block diagonal structure for biclustering. |
make_checkerboard (shape, n_clusters[, …]) |
Generate an array with block checkerboard structure for biclustering. |
5.4.2. Generators for regression¶
make_regression
produces regression targets as an optionally-sparse
random linear combination of random features, with noise. Its informative
features may be uncorrelated, or low rank (few features account for most of the
variance).
Other regression generators generate functions deterministically from
randomized features. make_sparse_uncorrelated
produces a target as a
linear combination of four features with fixed coefficients.
Others encode explicitly non-linear relations:
make_friedman1
is related by polynomial and sine transforms;
make_friedman2
includes feature multiplication and reciprocation; and
make_friedman3
is similar with an arctan transformation on the target.
5.4.3. Generators for manifold learning¶
make_s_curve ([n_samples, noise, random_state]) |
Generate an S curve dataset. |
make_swiss_roll ([n_samples, noise, random_state]) |
Generate a swiss roll dataset. |
5.4.4. Generators for decomposition¶
make_low_rank_matrix ([n_samples, …]) |
Generate a mostly low rank matrix with bell-shaped singular values |
make_sparse_coded_signal (n_samples, …[, …]) |
Generate a signal as a sparse combination of dictionary elements. |
make_spd_matrix (n_dim[, random_state]) |
Generate a random symmetric, positive-definite matrix. |
make_sparse_spd_matrix ([dim, alpha, …]) |
Generate a sparse symmetric definite positive matrix. |
5.5. Datasets in svmlight / libsvm format¶
scikit-learn includes utility functions for loading
datasets in the svmlight / libsvm format. In this format, each line
takes the form <label> <feature-id>:<feature-value>
<feature-id>:<feature-value> ...
. This format is especially suitable for sparse datasets.
In this module, scipy sparse CSR matrices are used for X
and numpy arrays are used for y
.
You may load a dataset like as follows:
>>> from sklearn.datasets import load_svmlight_file
>>> X_train, y_train = load_svmlight_file("/path/to/train_dataset.txt")
...
You may also load two (or more) datasets at once:
>>> X_train, y_train, X_test, y_test = load_svmlight_files(
... ("/path/to/train_dataset.txt", "/path/to/test_dataset.txt"))
...
In this case, X_train
and X_test
are guaranteed to have the same number
of features. Another way to achieve the same result is to fix the number of
features:
>>> X_test, y_test = load_svmlight_file(
... "/path/to/test_dataset.txt", n_features=X_train.shape[1])
...
Related links:
Public datasets in svmlight / libsvm format: http://www.csie.ntu.edu.tw/~cjlin/libsvmtools/datasets/
Faster API-compatible implementation: https://github.com/mblondel/svmlight-loader
5.6. The Olivetti faces dataset¶
This dataset contains a set of face images taken between April 1992 and April
1994 at AT&T Laboratories Cambridge. The website describing the original
dataset is now defunct, but archived copies can be accessed through
the Internet Archive’s Wayback Machine. The
sklearn.datasets.fetch_olivetti_faces
function is the data
fetching / caching function that downloads the data
archive from AT&T.
As described on the original website:
There are ten different images of each of 40 distinct subjects. For some subjects, the images were taken at different times, varying the lighting, facial expressions (open / closed eyes, smiling / not smiling) and facial details (glasses / no glasses). All the images were taken against a dark homogeneous background with the subjects in an upright, frontal position (with tolerance for some side movement).
The image is quantized to 256 grey levels and stored as unsigned 8-bit integers; the loader will convert these to floating point values on the interval [0, 1], which are easier to work with for many algorithms.
The “target” for this database is an integer from 0 to 39 indicating the identity of the person pictured; however, with only 10 examples per class, this relatively small dataset is more interesting from an unsupervised or semi-supervised perspective.
The original dataset consisted of 92 x 112, while the version available here consists of 64x64 images.
When using these images, please give credit to AT&T Laboratories Cambridge.
5.7. The 20 newsgroups text dataset¶
The 20 newsgroups dataset comprises around 18000 newsgroups posts on 20 topics split in two subsets: one for training (or development) and the other one for testing (or for performance evaluation). The split between the train and test set is based upon a messages posted before and after a specific date.
This module contains two loaders. The first one,
sklearn.datasets.fetch_20newsgroups
,
returns a list of the raw texts that can be fed to text feature
extractors such as sklearn.feature_extraction.text.CountVectorizer
with custom parameters so as to extract feature vectors.
The second one, sklearn.datasets.fetch_20newsgroups_vectorized
,
returns ready-to-use features, i.e., it is not necessary to use a feature
extractor.
5.7.1. Usage¶
The sklearn.datasets.fetch_20newsgroups
function is a data
fetching / caching functions that downloads the data archive from
the original 20 newsgroups website, extracts the archive contents
in the ~/scikit_learn_data/20news_home
folder and calls the
sklearn.datasets.load_files
on either the training or
testing set folder, or both of them:
>>> from sklearn.datasets import fetch_20newsgroups
>>> newsgroups_train = fetch_20newsgroups(subset='train')
>>> from pprint import pprint
>>> pprint(list(newsgroups_train.target_names))
['alt.atheism',
'comp.graphics',
'comp.os.ms-windows.misc',
'comp.sys.ibm.pc.hardware',
'comp.sys.mac.hardware',
'comp.windows.x',
'misc.forsale',
'rec.autos',
'rec.motorcycles',
'rec.sport.baseball',
'rec.sport.hockey',
'sci.crypt',
'sci.electronics',
'sci.med',
'sci.space',
'soc.religion.christian',
'talk.politics.guns',
'talk.politics.mideast',
'talk.politics.misc',
'talk.religion.misc']
The real data lies in the filenames
and target
attributes. The target
attribute is the integer index of the category:
>>> newsgroups_train.filenames.shape
(11314,)
>>> newsgroups_train.target.shape
(11314,)
>>> newsgroups_train.target[:10]
array([12, 6, 9, 8, 6, 7, 9, 2, 13, 19])
It is possible to load only a sub-selection of the categories by passing the
list of the categories to load to the
sklearn.datasets.fetch_20newsgroups
function:
>>> cats = ['alt.atheism', 'sci.space']
>>> newsgroups_train = fetch_20newsgroups(subset='train', categories=cats)
>>> list(newsgroups_train.target_names)
['alt.atheism', 'sci.space']
>>> newsgroups_train.filenames.shape
(1073,)
>>> newsgroups_train.target.shape
(1073,)
>>> newsgroups_train.target[:10]
array([1, 1, 1, 0, 1, 0, 0, 1, 1, 1])
5.7.2. Converting text to vectors¶
In order to feed predictive or clustering models with the text data,
one first need to turn the text into vectors of numerical values suitable
for statistical analysis. This can be achieved with the utilities of the
sklearn.feature_extraction.text
as demonstrated in the following
example that extract TF-IDF vectors of unigram tokens
from a subset of 20news:
>>> from sklearn.feature_extraction.text import TfidfVectorizer
>>> categories = ['alt.atheism', 'talk.religion.misc',
... 'comp.graphics', 'sci.space']
>>> newsgroups_train = fetch_20newsgroups(subset='train',
... categories=categories)
>>> vectorizer = TfidfVectorizer()
>>> vectors = vectorizer.fit_transform(newsgroups_train.data)
>>> vectors.shape
(2034, 34118)
The extracted TF-IDF vectors are very sparse, with an average of 159 non-zero components by sample in a more than 30000-dimensional space (less than .5% non-zero features):
>>> vectors.nnz / float(vectors.shape[0])
159.01327433628319
sklearn.datasets.fetch_20newsgroups_vectorized
is a function which returns
ready-to-use tfidf features instead of file names.
5.7.3. Filtering text for more realistic training¶
It is easy for a classifier to overfit on particular things that appear in the 20 Newsgroups data, such as newsgroup headers. Many classifiers achieve very high F-scores, but their results would not generalize to other documents that aren’t from this window of time.
For example, let’s look at the results of a multinomial Naive Bayes classifier, which is fast to train and achieves a decent F-score:
>>> from sklearn.naive_bayes import MultinomialNB
>>> from sklearn import metrics
>>> newsgroups_test = fetch_20newsgroups(subset='test',
... categories=categories)
>>> vectors_test = vectorizer.transform(newsgroups_test.data)
>>> clf = MultinomialNB(alpha=.01)
>>> clf.fit(vectors, newsgroups_train.target)
>>> pred = clf.predict(vectors_test)
>>> metrics.f1_score(newsgroups_test.target, pred, average='weighted')
0.88251152461278892
(The example Classification of text documents using sparse features shuffles the training and test data, instead of segmenting by time, and in that case multinomial Naive Bayes gets a much higher F-score of 0.88. Are you suspicious yet of what’s going on inside this classifier?)
Let’s take a look at what the most informative features are:
>>> import numpy as np
>>> def show_top10(classifier, vectorizer, categories):
... feature_names = np.asarray(vectorizer.get_feature_names())
... for i, category in enumerate(categories):
... top10 = np.argsort(classifier.coef_[i])[-10:]
... print("%s: %s" % (category, " ".join(feature_names[top10])))
...
>>> show_top10(clf, vectorizer, newsgroups_train.target_names)
alt.atheism: sgi livesey atheists writes people caltech com god keith edu
comp.graphics: organization thanks files subject com image lines university edu graphics
sci.space: toronto moon gov com alaska access henry nasa edu space
talk.religion.misc: article writes kent people christian jesus sandvik edu com god
You can now see many things that these features have overfit to:
- Almost every group is distinguished by whether headers such as
NNTP-Posting-Host:
andDistribution:
appear more or less often. - Another significant feature involves whether the sender is affiliated with a university, as indicated either by their headers or their signature.
- The word “article” is a significant feature, based on how often people quote previous posts like this: “In article [article ID], [name] <[e-mail address]> wrote:”
- Other features match the names and e-mail addresses of particular people who were posting at the time.
With such an abundance of clues that distinguish newsgroups, the classifiers barely have to identify topics from text at all, and they all perform at the same high level.
For this reason, the functions that load 20 Newsgroups data provide a
parameter called remove, telling it what kinds of information to strip out
of each file. remove should be a tuple containing any subset of
('headers', 'footers', 'quotes')
, telling it to remove headers, signature
blocks, and quotation blocks respectively.
>>> newsgroups_test = fetch_20newsgroups(subset='test',
... remove=('headers', 'footers', 'quotes'),
... categories=categories)
>>> vectors_test = vectorizer.transform(newsgroups_test.data)
>>> pred = clf.predict(vectors_test)
>>> metrics.f1_score(pred, newsgroups_test.target, average='weighted')
0.78409163025839435
This classifier lost over a lot of its F-score, just because we removed metadata that has little to do with topic classification. It loses even more if we also strip this metadata from the training data:
>>> newsgroups_train = fetch_20newsgroups(subset='train',
... remove=('headers', 'footers', 'quotes'),
... categories=categories)
>>> vectors = vectorizer.fit_transform(newsgroups_train.data)
>>> clf = BernoulliNB(alpha=.01)
>>> clf.fit(vectors, newsgroups_train.target)
>>> vectors_test = vectorizer.transform(newsgroups_test.data)
>>> pred = clf.predict(vectors_test)
>>> metrics.f1_score(newsgroups_test.target, pred, average='weighted')
0.73160869205141166
Some other classifiers cope better with this harder version of the task. Try
running Sample pipeline for text feature extraction and evaluation with and without
the --filter
option to compare the results.
Recommendation
When evaluating text classifiers on the 20 Newsgroups data, you
should strip newsgroup-related metadata. In scikit-learn, you can do this by
setting remove=('headers', 'footers', 'quotes')
. The F-score will be
lower because it is more realistic.
5.8. Downloading datasets from the mldata.org repository¶
mldata.org is a public repository for machine learning data, supported by the PASCAL network .
The sklearn.datasets
package is able to directly download data
sets from the repository using the function
sklearn.datasets.fetch_mldata
.
For example, to download the MNIST digit recognition database:
>>> from sklearn.datasets import fetch_mldata
>>> mnist = fetch_mldata('MNIST original', data_home=custom_data_home)
The MNIST database contains a total of 70000 examples of handwritten digits of size 28x28 pixels, labeled from 0 to 9:
>>> mnist.data.shape
(70000, 784)
>>> mnist.target.shape
(70000,)
>>> np.unique(mnist.target)
array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])
After the first download, the dataset is cached locally in the path
specified by the data_home
keyword argument, which defaults to
~/scikit_learn_data/
:
>>> os.listdir(os.path.join(custom_data_home, 'mldata'))
['mnist-original.mat']
Data sets in mldata.org do not adhere to a strict
naming or formatting convention. sklearn.datasets.fetch_mldata
is
able to make sense of the most common cases, but allows to tailor the
defaults to individual datasets:
The data arrays in mldata.org are most often shaped as
(n_features, n_samples)
. This is the opposite of thescikit-learn
convention, sosklearn.datasets.fetch_mldata
transposes the matrix by default. Thetranspose_data
keyword controls this behavior:>>> iris = fetch_mldata('iris', data_home=custom_data_home) >>> iris.data.shape (150, 4) >>> iris = fetch_mldata('iris', transpose_data=False, ... data_home=custom_data_home) >>> iris.data.shape (4, 150)
For datasets with multiple columns,
sklearn.datasets.fetch_mldata
tries to identify the target and data columns and rename them totarget
anddata
. This is done by looking for arrays namedlabel
anddata
in the dataset, and failing that by choosing the first array to betarget
and the second to bedata
. This behavior can be changed with thetarget_name
anddata_name
keywords, setting them to a specific name or index number (the name and order of the columns in the datasets can be found at its mldata.org under the tab “Data”:>>> iris2 = fetch_mldata('datasets-UCI iris', target_name=1, data_name=0, ... data_home=custom_data_home) >>> iris3 = fetch_mldata('datasets-UCI iris', target_name='class', ... data_name='double0', data_home=custom_data_home)
5.9. The Labeled Faces in the Wild face recognition dataset¶
This dataset is a collection of JPEG pictures of famous people collected over the internet, all details are available on the official website:
Each picture is centered on a single face. The typical task is called Face Verification: given a pair of two pictures, a binary classifier must predict whether the two images are from the same person.
An alternative task, Face Recognition or Face Identification is: given the picture of the face of an unknown person, identify the name of the person by referring to a gallery of previously seen pictures of identified persons.
Both Face Verification and Face Recognition are tasks that are typically performed on the output of a model trained to perform Face Detection. The most popular model for Face Detection is called Viola-Jones and is implemented in the OpenCV library. The LFW faces were extracted by this face detector from various online websites.
5.9.1. Usage¶
scikit-learn
provides two loaders that will automatically download,
cache, parse the metadata files, decode the jpeg and convert the
interesting slices into memmaped numpy arrays. This dataset size is more
than 200 MB. The first load typically takes more than a couple of minutes
to fully decode the relevant part of the JPEG files into numpy arrays. If
the dataset has been loaded once, the following times the loading times
less than 200ms by using a memmaped version memoized on the disk in the
~/scikit_learn_data/lfw_home/
folder using joblib
.
The first loader is used for the Face Identification task: a multi-class classification task (hence supervised learning):
>>> from sklearn.datasets import fetch_lfw_people
>>> lfw_people = fetch_lfw_people(min_faces_per_person=70, resize=0.4)
>>> for name in lfw_people.target_names:
... print(name)
...
Ariel Sharon
Colin Powell
Donald Rumsfeld
George W Bush
Gerhard Schroeder
Hugo Chavez
Tony Blair
The default slice is a rectangular shape around the face, removing most of the background:
>>> lfw_people.data.dtype
dtype('float32')
>>> lfw_people.data.shape
(1288, 1850)
>>> lfw_people.images.shape
(1288, 50, 37)
Each of the 1140
faces is assigned to a single person id in the target
array:
>>> lfw_people.target.shape
(1288,)
>>> list(lfw_people.target[:10])
[5, 6, 3, 1, 0, 1, 3, 4, 3, 0]
The second loader is typically used for the face verification task: each sample is a pair of two picture belonging or not to the same person:
>>> from sklearn.datasets import fetch_lfw_pairs
>>> lfw_pairs_train = fetch_lfw_pairs(subset='train')
>>> list(lfw_pairs_train.target_names)
['Different persons', 'Same person']
>>> lfw_pairs_train.pairs.shape
(2200, 2, 62, 47)
>>> lfw_pairs_train.data.shape
(2200, 5828)
>>> lfw_pairs_train.target.shape
(2200,)
Both for the sklearn.datasets.fetch_lfw_people
and
sklearn.datasets.fetch_lfw_pairs
function it is
possible to get an additional dimension with the RGB color channels by
passing color=True
, in that case the shape will be
(2200, 2, 62, 47, 3)
.
The sklearn.datasets.fetch_lfw_pairs
datasets is subdivided into
3 subsets: the development train
set, the development test
set and
an evaluation 10_folds
set meant to compute performance metrics using a
10-folds cross validation scheme.
References:
- Labeled Faces in the Wild: A Database for Studying Face Recognition in Unconstrained Environments. Gary B. Huang, Manu Ramesh, Tamara Berg, and Erik Learned-Miller. University of Massachusetts, Amherst, Technical Report 07-49, October, 2007.
5.9.2. Examples¶
5.10. Forest covertypes¶
The samples in this dataset correspond to 30×30m patches of forest in the US, collected for the task of predicting each patch’s cover type, i.e. the dominant species of tree. There are seven covertypes, making this a multiclass classification problem. Each sample has 54 features, described on the dataset’s homepage. Some of the features are boolean indicators, while others are discrete or continuous measurements.
sklearn.datasets.fetch_covtype
will load the covertype dataset;
it returns a dictionary-like object
with the feature matrix in the data
member
and the target values in target
.
The dataset will be downloaded from the web if necessary.
5.11. RCV1 dataset¶
Reuters Corpus Volume I (RCV1) is an archive of over 800,000 manually categorized newswire stories made available by Reuters, Ltd. for research purposes. The dataset is extensively described in [1].
sklearn.datasets.fetch_rcv1
will load the following version: RCV1-v2, vectors, full sets, topics multilabels:
>>> from sklearn.datasets import fetch_rcv1
>>> rcv1 = fetch_rcv1()
It returns a dictionary-like object, with the following attributes:
data
:
The feature matrix is a scipy CSR sparse matrix, with 804414 samples and
47236 features. Non-zero values contains cosine-normalized, log TF-IDF vectors.
A nearly chronological split is proposed in [1]: The first 23149 samples are the training set. The last 781265 samples are the testing set. This follows the official LYRL2004 chronological split.
The array has 0.16% of non zero values:
>>> rcv1.data.shape
(804414, 47236)
target
:
The target values are stored in a scipy CSR sparse matrix, with 804414 samples and 103 categories. Each sample has a value of 1 in its categories, and 0 in others. The array has 3.15% of non zero values:
>>> rcv1.target.shape
(804414, 103)
sample_id
:
Each sample can be identified by its ID, ranging (with gaps) from 2286 to 810596:
>>> rcv1.sample_id[:3]
array([2286, 2287, 2288], dtype=int32)
target_names
:
The target values are the topics of each sample. Each sample belongs to at least one topic, and to up to 17 topics.
There are 103 topics, each represented by a string. Their corpus frequencies span five orders of magnitude, from 5 occurrences for ‘GMIL’, to 381327 for ‘CCAT’:
>>> rcv1.target_names[:3].tolist()
['E11', 'ECAT', 'M11']
The dataset will be downloaded from the rcv1 homepage if necessary. The compressed size is about 656 MB.


{% extends "hierarchy/_modal_wrapper.html" %} {% block modal_content %}
When a non-originating material is used to produce another finished product, the 4-digit level of its original commodity code will need to change once it’s incorporated into the final product. This is referred to as a change in tariff heading.
Example:
Thin copper wire with a diameter below 6mm comes under the commodity code 740819.
A UK manufacturer makes wire from copper sheets sourced from outside the UK.
The 6-digit commodity code for the copper sheets is 740919
The 6-digit commodity code for the thin UK wire is 740819
The commodity code changes at the 4-digit level when the copper sheets become wire. This means it has gone through a change in tariff heading.
{% endblock %}


An initial delay, followed by a repeated delay.
- Input
- The input partials to delay.
- Wet
- The wetness of the delay (how much delay is passed through versus the original partials signal).
- Initial Delay
- The initial delay time
- Later Delays
- The delay time for each of the repeated later delays
- Initial Cut
- The cut in amplitude of the initial delay relative to the original signal.
- Later Cuts
- The cut in amplitude of the later delays relative to the amplitude of each previous delay.


ermagawrd it's cat clicka
Select a cat...
Enter Admin Mode
Save
Cancel
Name
Image Location
Click Number


|
SUPER MINIONS!!!!!
FACTS ABOUT MINIONS: Minions are always up to something they're cheeky & sometimes they can do things which cause big problems... VERY BIG PROBLEMS! Like the time on one of the movies when some of the minions were trying to get bananas when a rock fell on they're leader which is was a dinosaur.You can watch it on the video below the picture.Minion NAMES
My idea I think that minions are cute becausethey are always have a great personality and if they are angry something funny is bouned to happen. DOCTER NEFARIO One time in Despicable Me 1 Docter Nefario forgot to tell Gru that the bigger the object the less time it will take for it to take to go back to normal size so when Gru tried to steal the moon he had know idear that it would go back to the orotiginal size lucky Vector stole it otherwise Gru would |
|


File: intera_core_msgs/HeadState.msg
Raw Message Definition
float32 pan
bool isTurning
# isBlocked will be true during active cancellation when the desired head position
# can not be reached because of j0's current position
bool isBlocked
# panMode will be one of
uint8 PASSIVE_MODE = 0
uint8 ACTIVE_MODE = 1
uint8 ACTIVE_CANCELLATION_MODE = 2
#
uint8 panMode
Compact Message Definition
uint8 PASSIVE_MODE=0
uint8 ACTIVE_MODE=1
uint8 ACTIVE_CANCELLATION_MODE=2
float32 pan
bool isTurning
bool isBlocked
uint8 panMode


Nathan Liboutet
01.
Home
02.
Works
03.
About me
04.
Contact
Feel free to contact me if you have any questions!
Let's connect!
Learn more about me by checking out my resume


Will Genting Singapore's Japan IR gamble pay off?
by Uma DeviSINGAPORE (Nov 8): On the surface, luck could be running out for Genting Singapore (GENS).
The integrated resort operator saw its earnings fall 24% to S$158.9 million for 3QFY19 ended September, revenue for the quarter slipped 7% to S$596.1 million, on the back of an 11% decline in revenue contribution from the gaming segment to S$360.8 million.
While the group says its latest results are due to a “confluence of headwinds”, it notes it continues to be...(click on link for full story on theedgesingapore.com)


Employability Score sheet
Your Highest Qualification
Choose option
Bachelors Degree
Honours Degree
Masters Degree
GPA
75 - 100
70 - 74
60 - 69
50 - 59
49 or below
Birthday
Gender
Male
Female
Other
University
Choose option
University of Cape Town
University of Pretoria
Email
Citizenship Status
Choose option
SA Citizen
Permanent Residence
Temporal Residence
SA ID Number/Passport Number
Employment Status
Choose option
Unemployed
Full-time employment
Part-time employment
Student
Net Income
0 - 50 000
50 000 - 100 000
100 000+
Work Experience
0 - 2 years
2 - 4 years
4+ years
University Societal Participation
0 - 2
2 - 4
4+
Submit


|
ish version 0.1
Simple Input handling middleware
|
The main class to use features in ish. The user will interact through this class. More...
#include <ISH.h>
Static Public Member Functions | |
| static bool | Initialize (const char *fileName="keyConfig.ini", PlayerIndexs numberOfPlayers=PlayerMax) |
| Initialization of the system. This method MUST be called at the start of the application before other input methods are called. | |
| static bool | LoadKeyData (const char *fileName, PlayerIndexs playerToApplySetting=PlayerOne) |
| Loads new setting for key mapping and deletes the current settings. This methods gets called during Initialize() method so only call this method when you want to reload new file and settings. | |
| static void | Update (void) |
| Updates the input system, call this once per frame. | |
| static void | Shutdown (void) |
| Call this method at the end of application to shutdown the input system. This method MUST be called to close down ish safly and to avoid chance of memory leaks. | |
| static float | GetInputValue (const char *name, PlayerIndexs playerIndex=PlayerOne) |
| Check for input (and value) in given key map setting. | |
| static std::string | SetInput (const char *fileName, const char *name, InputOption option, PlayerIndexs index, bool isPositive, SaveOption saveOption) |
| Sets an input option, suggested to use for run-time configuration / key mapping. |
The main class to use features in ish. The user will interact through this class.
| float ISH::GetInputValue | ( | const char * | name, |
| PlayerIndexs | playerIndex = PlayerOne |
||
| ) | [static] |
Check for input (and value) in given key map setting.
-------------------------------------------------------------------------------
| name | name of the key map/group setting to get e.g. "Fire" |
| playerIndex | player and xbox controller to check input for |
-------------------------------------------------------------------------------
| bool ISH::Initialize | ( | const char * | fileName = "keyConfig.ini" , |
| PlayerIndexs | numberOfPlayers = PlayerMax |
||
| ) | [static] |
Initialization of the system. This method MUST be called at the start of the application before other input methods are called.
-------------------------------------------------------------------------------
| fileName | The full path to the key config (.ini) file you want to load. it searches in current directory by default if no parameter is given |
| numberOfPlayers | Number of Players (controllers) to be used in the application |
-------------------------------------------------------------------------------
| bool ISH::LoadKeyData | ( | const char * | fileName, |
| PlayerIndexs | playerToApplySetting = PlayerOne |
||
| ) | [static] |
Loads new setting for key mapping and deletes the current settings. This methods gets called during Initialize() method so only call this method when you want to reload new file and settings.
-------------------------------------------------------------------------------
| fileName | The full path to the key config (.ini) file you want to load. it searches in current directory by default if no parameter is given |
| playerToApplySetting | player (and controller) to load and apply new setting to |
-------------------------------------------------------------------------------
| std::string ISH::SetInput | ( | const char * | fileName, |
| const char * | name, | ||
| InputOption | option, | ||
| PlayerIndexs | index, | ||
| bool | isPositive, | ||
| SaveOption | saveOption | ||
| ) | [static] |
Sets an input option, suggested to use for run-time configuration / key mapping.
-------------------------------------------------------------------------------
| fileName | full path to the file you want to save to or create |
| name | name of the input group (or key) to be used in GetInputValue() function |
| option | option to choose how you want it to take input e.g. check when its pressed |
| index | index of the player you want to apply new setting to |
| isPositive | true if you want new setting to return positive value, otherwise false |
| saveOption | set how you want to save new setting. Refere to enum.h for options |
-------------------------------------------------------------------------------
| void ISH::Shutdown | ( | void | ) | [static] |
Call this method at the end of application to shutdown the input system. This method MUST be called to close down ish safly and to avoid chance of memory leaks.
| void ISH::Update | ( | void | ) | [static] |
Updates the input system, call this once per frame.


Crystal Collector Game
There are four crystals. You will be shown a random number at the start of the game, and when you click on a crystal, it will add a specific amount of points to your total score. You win if your total score matches the random number generated at the beginning of the game. You lose if the score goes above the random number.


This application is an example of an Android library project, a type of project that lets you store and manage shared code and resources in one place, then make them available to your other Android applications.
The TicTacToeLib library project is designed to provide a game-play Activity,
GameActivity
to other applications. Dependent applications simply
launch the Activity using an explicit intent — once launched,
GameActivity
assumes control of the application lifecycle and
handles all events and UI interactions.
GameActivity
.If you want to build the TicTacToeLib application, you can obtain it by downloading the "Samples for SDK API 8" component (or higher version) into your SDK, using the Android SDK and AVD Manager.
Note that you can not build and run TicTacToeLib independently, since it is a library project and not a true Android application project. To run it, you need to build the application that uses the library project — in this case, the TicTacToeMain application, which is also included in the Samples SDK comnponent.
To build an application that uses a library project, you also need to update to the latest version of the SDK tools (r6 or higher) and Android platforms, as well as the latest version of ADT (0.9.7 or higher), if you are developing in Eclipse.
For information about how to set up Android library projects, refer to Developing in Eclipse with ADT or Developing in Other IDEs, depending on your environment.


Reference
Say
Will say somthing on the top screen.
Add
Will add two numbers together.
Subtract
Will take apart most numbers.
Mult
Will multiply numbers.
Div
Will slice numbers apart.