{% extends 'bom/bom-base.html' %} {% load staticfiles %} {% block head-title %}Help{% endblock %} {% block main %} {% endblock %} {% block bom-menu %} {% endblock %} {% block content %}
There are many more things you can do with BOM, but these three steps will get you started.
BOM may be used to create a catalog of parts and to organize parts into assemblies. The parts that comprise a particular assembly is referred to as a Bill of Materials, or BOM. BOMs and parts may be entered directly into BOM or they may be uploaded as comma-separated (CSV) files. Information about an individual part, a collection of parts, or a BOM may be downloaded as CSV files.
Parts are grouped by class. A part class represents a category of parts and is used to classify parts, such as resistors, capacitors, or printed circuit board assemblies.
All of the information about parts, part classes, and BOMs is maintained by BOM in an underlying relational database.
The general use model for BOM is to define part classes, then define parts, then define BOMs for the parts that are assemblies of other parts, and then use this information as the authoritative source of parts and assemblies for your projects or products. For example, you might provide a downloaded BOM to a contract manufacturer so that they are able to procure parts and assemble your product.
Over time, new part classes and parts may be added and new assembly BOMs may be defined. Similarly, the definitions for existing part classes, parts, and assemblies may be revised or even deleted altogether.
BOM is capable of representing many of the key relationships that are required to represent parts and assemblies. Below are some of the key relationships. Note that in the narrative below, a subpart refers to a part that is used to construct another part. A subpart is not a real-world part but rather it represents a relationship between a real-world part and another part that incorporates it (i.e., an assembly). The word assembly is used to indicate a part that contains other parts. Any part can be an assembly. Which ones actually are assemblies are up to you:
For each part ….
a list of properties and free-form text that specify the part in detail
a history of revisions that you have made to the part’s specification
For each part revision ...
a list of manufacturers who are approved as sources for the part along with each manufacturer’s assigned part number, costing information, and other manufacturer-related parameters
the list of subparts that are required to assemble the particular part
For each subpart ….
the part that is represented by the subpart
the list of parts (i.e., assemblies) that use the subpart
the quantity of the subpart that is needed for a particular assembly
an optional assembly-specific reference designator (e.g., R1 for a resistor, C1 for a capacitor, and so on)
an assembly-specific indicator as whether or not the subpart should be loaded into the assembly (referred to as “Do No Load”)
BOM may also be downloaded and installed on your own server. In either case, you define the organization on whose behalf BOM maintains a database of parts and BOMs. You also define the valid users and their roles. A user may only access the parts and BOMs for their organization and may only perform the BOM operations that are allowed by their role.
An BOM user may be affiliated with only one BOM organization at a time. A user can only view and revise information that is associated with their organization.
Within the scope of an organization, a BOM user may have either the role of “Viewer” or of “Admin”. A viewer can search for and view data about part classes, parts and BOMs. An admin can additionally add, revise, and delete part class, part and BOM data.
The user who initially sets-up BOM for an organization is referred to as the “organization’s owner”. This person may add or remove users to their organization, and they may transfer organizational ownership to another user in the organization. An organization can have only one owner.
Part classes are not built into BOM. Instead, one of the first things you need to do when you set-up your BOM environment is to define part classes. A part class is represented by a unique number and a unique name. It may also optionally include a comment or description.
You can define part classes by uploading a CSV file in which one column contains a name for the part class, and another column contains the three-digit code that you have assigned. Alternatively, you manually may define a part class using a form.
You may also use the sample CSV file that is available on the BOM web site.
Over time you may add additional part classes, and you can edit or delete existing part classes.
One of the core decisions made when BOM was conceived is to use a predominantly agnostic part numbering scheme. This as opposed to so-called “smart part numbers”. This means that an BOM part number does not convey much information about a part. Instead, part numbers are designed to be simple to assign and simple to subsequently write, type, or speak. This approach makes it a lot easier to maintain part numbers over time while minimizing the possibility of communication or transcription mistakes.
If detailed information about a part is needed then BOM may be easily used to look up or search for the part.
An BOM part number is comprised of three components:
The overall part number looks like:
CCC-NNNNNN-VV
where the quantity of number item digits N depends on your organization’s configuration (six in this example).
BOM ensures that every part number is unique relative to an organization’s catalog of parts. In other words, the tuple {CCC, NNNNNN, VV} is defined as unique in BOM’s underlying database.
The actual assignment of part numbers may be done explicitly or automatically. When you create a part, or when you uploaded a list of parts, you may specify the part numbers that you would like BOM to use. As long as a part number you specify is unique then it will be accepted by BOM.
Alternatively, you can just specify a part’s part class and leave it to BOM to assign an item number. The item number created by BOM will be one greater-than the largest item number that has ever been assigned to the new part’s part class. The variation will be set to “00”.
No matter how a part number was created, you can of course subsequently change a part’s part class or variation to whatever you would like.
BOM is designed to handle a wide-range of parts. To enable you to adequately specify your parts, you may use a mix of pre-defined part properties in conjunction with free-form text to fully specify a part. A part property may be just a value, or it may be a value and an associated unit of measure.
The list of available properties is comprehensive but not exhaustive. The free-form text provides a means for conveying information not covered by the properties.
When information about a part is displayed a synopsis is often generated and displayed. A part’s synopsis is a synthesis of the property values and associated units of measure, along with free-form text, that were used to specify the part.
The synopsis also plays a role when you search for parts. Anything contained in a part’s synopsis may be subsequently searched for.
As you edit, update or otherwise revise a part’s specification, you can use BOM to keep track of your specification revisions. Independent of how you choose to use the part number part variation field, a revision is a snapshot of your part in terms of the specification information captured and stored in BOM.
A newly created part is assigned a revision of 1. You may edit a part without changing its revision, or you may create a new revision with is initialized with data from the latest revision. Note that you cannot explicitly set the revision number. Instead, BOM manages the assignment of revision numbers, for example, it will increment a part’s current revision number when you instruct BOM to create a new revision.
In addition, at various times BOM will automatically manage part revisions for you. For example, if you change a part’s part class and the part number item and number variation would conflict with a part that already exists in the target class, then BOM will create a new revision of the part. The revision number will be set to one greater than the largest revision for the otherwise conflicting part.
BOM enables you to control whether or not a part’s specification is still a work-in-progress, or whether it has been released for use by your team. A part is tagged in BOM as “Working” if it is a work-in-progress, in which case you may continue to edit the part’s specification or create new revisions. When you are ready, you can change a part’s status so that it is tagged as “Released”. You will not be able to edit the specification or create new revisions of the specification for a “Released” part. However, you can revert a “Released” part back to “Working”, edit the specification or create additional revisions, and then re-tag the part as “Released”.
Throughout the BOM application you will need to enter names for part classes, organizations, and manufacturers. These names you enter are stored in with case preserved, but for comparison purposes the names are treated as case insensitive. In fact, for comparison purposes, any text that you enter is treated as case insensitive.
For example, the part class names “capacitor” and “Capacitor” are treated by BOM as the same thing when it comes to validating part class names. You can edit the part class “Capacitor” so that its new name is “capacitor”, but if you try to create another part class so that its name is also “capacitor”, or “Capacitor”, or “CaPaCiTor”, or any other combination of upper and lower case, as long as it spells “capacitor” then the new part class name will be flagged as an error and rejected.
The Settings page contains three tabs: User, BOM, Organization.
If your role is “Viewer” then you can only access the “User” tab, from which you can edit your BOM username and contact information.
If your role is “Admin” then you can access the “BOM” tab you can revise your organization’s BOM configuration, including:
If your role as “Admin” and you are your organization’s owner, then from the “Organization” tab you can revise your organization’s configuration, including.
Once you have logged into BOM you will be brought to the application’s Home page. From this you may select a part class in order to view all of the parts in the class, or you can search for a part or set of parts using a search term.
The “Upload” menu at the top of the page enables you to upload CSV’s files for parts, BOMs, or part classes. Other buttons at the top of the page enable you to jump to the Settings page or logout.
In addition, pop-up icon buttons at the bottom right of the Home page enable you to explicitly create a part using a form or to upload parts from a CSV file.
Note … you can return to this page from any other BOM page by clicking on the BOM icon that appears on the upper left corner of every page.
The Search Results page is a lot like the Home page except that it lists the part or parts that satisfy your search criteria or part class selection. The information displayed about each part includes the part number, a synopsis, and a drop-drop down menu that gives you various choices about how you can download information about the part to a CSV file.
The synopsis presents information about the part as culled from the property values and free-text information that have been specified.
If you like, you can use the search function on the Search Results page to search for parts within the part class that you previously selected (if, in fact, you had done so). You may also select a different part class to view, obviating the need to return to the Home page.
Additionally, from the Search Results page you can also download to a CSV file the information presented about all of the parts listed in the search results list.
And, from this page, you can select any part for viewing in detail by clicking on its part number.
Finally, if you have the role of Admin, then can show or hide controls that allow you to select one or more parts to delete from BOM. You should do this carefully because the deleting of a part cannot be undone. You will have to re-enter the information about a part you did not really want to delete.
You can use free-form searching to find parts based upon a part’s part number, synopsis, primary manufacturer’s name or primary manufacturer’s part number (MPN). Terms that represents these elements may be mixed and matched in your search expression.
If you enter a part number as a search term then to be recognized as a part number, it must at least include the part class number and the item number. It may optionally include the number item variation.
For example, both 102-00033-04 and 102-000033 are valid part number search terms. This example assumes that your organization uses 5 digits for its item number.
When entering a free-form search expression, the special characters that are used by BOM to display units of measure need to be represented as standard text characters in your search term:
You can narrow your search to a specific class of parts by first selecting a part class. For example, to search for all capacitors whose capacitance is 10μF, you would first select the capacitor part class, then enter 10uF as the search term.
Matches will be made against partial words as well, for example yel will match all parts that contain the word “yellow”or “Yellow” or “yell” and so-on.
If your search expression is composed of multiple terms, then each search term is OR’ed, meaning that the search results will list all of the parts that match at least one of the terms of your search expression.
For example, if your search term is 270Ohms 5% 0805 then your search will list all parts that contain “270Ω” or the “5%” or “0805”.
White space, comprised of any number of spaces or tabs, separates your search terms. If you have a term that is composed of multiple words and you want these words to be treated as a single term then they should be put in quotes, for example “Big Company Inc.” will be treated as single term whereas Big Company Inc. will be treated as three separate terms.
Given how white space is interpreted, you should not have whitespace between a value and the associated units of measure. In other words, want to search for parts that contain “10V”, then your search term should be 10V or “10V” as opposed to 10 V. If you type 10 V then the 10 and the V will be treated as separate search terms and the search will match all parts that contain “10” and “V”, which is probably not what you want!
 This servers as a reminder for what you searched for, and it enables you to easily edit the search expression to make minor adjustments. If you want to start a completely new search then just type over your previous search or push the “Clear” button.
The Part Info Page enables you to view all kinds of information about a part, edit a part, and manage its lifecycle. You can get to the Part Info Page by selecting a part of interest from search results, or after creating a new part.
If you have the role of Admin, then you can also edit the part, add new revisions, and change the part’s status from Working to/from Release.
At the top of the page is a drop down menu from which you can select which revision of the part you want to work with. The default is the most recent version.
Next to this menu is another drop down menu labeled “Manage”. You can use this menu to edit the information about the part (e.g. its various properties). You can also release the part, meaning it is now finalized and available to your organization for general use. And you can create a new revision of the part and you can even delete the part altogether.
The Part Info Page also presents four tabs, each of which enables you to view details about the part and to add more information. The tabs are:
Specifications – this is the default tab, and it enables you to view and edit the part’s class, item number and revision number. You can also set or change the primary manufacturer of the part.
Bill Of Materials – this tab enables you to view and edit the part’s Bill of Materials. See the section Bill Of Materials Page.
Where Used – this tab presents the list of assemblies, if any, that include the part in their own Bill of Materials.
Sourcing – this tab presents the list of manufacturers, if any, for the part, and includes vital information such as pricing and lead time.
If you have the role of Admin, then the Part Creation page enables you to specify a new part. First you need to select a part class, then you may optionally specify the item number and revision, or may allow BOM to specify either or both values of these for you.
The remaining information you may enter describes the part. At a minimum you must specify a value for the part along with the units of measure, or you must provide a free-text description.
The optional properties of a part are organized into the following groups:
Electronics – properties pertinent to electronic parts, such as tolerance, package and pin count.
Ratings – properties representing electrical and temperature limits for a part
Miscellaneous – properties generally useful for describing an electronic part, such as memory capacity
Appearance – properties that describe a part’s color, finish and material
Dimensions – properties that describe the size and weight of a part
Other – free-form text describing properties not included in any of the above
The type of value you can enter for a particular property is generally constrained. In some cases, the value must be a number. In other cases, the value must be selected from a drop down list.
Most properties also have an associated unit of measure. If a property has a value and units of measure, then you must specify both. For each property that has an associated units of measure, a list a relevant built-in units appears in a drop down list.
All property-related drop down lists include the choice “Other”. You can use the free-form text fields to explain how users should interpret “Other”.
Additionally, you can use free-form text fields to provide additional information, such as special storage or handling instructions, or to describe properties not presented in the form.
When you are done, scroll down to the bottom of the page and select “save”.
If you have the role of Admin, then you may upload the specification for one or more parts from a comma-separated-value (CSV) file. A pop-up icon button at the bottom right of the Home page and search results page, as well as several other pages, also enable you to upload a CSV file for parts. Uploading can also be initiated using the “Upload” menu that appears at the top of the Home page and Search Results pages.
When you upload parts from a CSV file you can assign BOM part numbers in the file or you can allow BOM to automatically assign part numbers. If you specify a part number that is already in use then the conflicting part will not be uploaded. Similarly, other errors may prevent a part from being uploaded, for example, an improperly formatted BOM part number or the use of an unknown BOM part class. The uploading will continue with the next valid part in the file.
Any information that you can enter using the Create Part page may also be submitted via the part list upload file. Here is the complete list of items you can upload for each part in the list:
|
Item |
Header Name |
Header Value |
Guidance |
|---|---|---|---|
|
Either: |
|||
|
The part’s part class |
part_class |
3-digit valid BOM part class |
You need to first define the part classes for your organization; If a part_number is also specified then its part_class takes precedence over this part_class should they happen to be different |
|
Or: |
|||
|
A pre-assigned BOM part number |
part_number |
CCC-NNNNNN-VV |
Must not yet exist in BOM; The part class code must be valid; the number of digits in the item number must match your organization’s configuration |
|
And for either of the above: |
|||
|
The part’s revision |
revision |
2-digit revision |
Must not be a negative number. |
|
Either: |
|||
|
A description of the part |
description |
Free form text up to 255 characters |
|
|
And/Or both of: |
|||
|
A value for the part |
value |
Free form text up to 255 characters |
Value should make sense given the units |
|
The part’s value unit of measure |
value_units |
Choose from the “Value Units” list below or free form text up to 5 characters |
Units should make sense given the value |
|
Item |
Header Name |
Header Value |
Guidance |
|---|---|---|---|
|
Manufacturer: |
|||
|
manufacturer |
|||
|
manufacturer_part_number |
|||
|
Electronics: |
|||
|
The part’s tolerance |
tolerance |
A percentage, must be numbers or a decimal point, up to 6 total characters |
|
|
The part’s package |
package |
Choose from the “Package Types” list below or “Other” |
|
|
The part’s pin count |
pin_count |
Must be a number between 1 and 999 |
|
|
The part’s supply voltage |
supply_voltage |
Plus/minus number up to 7 digits including a resolution of up to 3 decimal places |
Value should make sense given the units |
|
The part’s supply voltage units of measure |
supply_voltage_units |
Choose from the “Voltage Units” list below or “Other” |
Units should make sense given the value |
|
Ratings: |
|||
|
The part’s power rating |
power_rating |
Plus/minus number up to 7 digits including a resolution of up to 3 decimal places |
Value should make sense given the units |
|
The part’s power rating units of measure |
power_rating_units |
Choose from the “Power Units” list below or “Other” |
Units should make sense given the value |
|
The part’s voltage rating |
voltage_rating |
Plus/minus number up to 7 digits including a resolution of up to 3 decimal places |
Value should make sense given the units |
|
The part’s voltage rating units of measure |
voltage_rating_units |
Choose from the “Voltage Units” list below or “Other” |
Units should make sense given the value |
|
The part’s current rating |
current_rating |
Plus/minus number up to 7 digits including a resolution of up to 3 decimal places |
Value should make sense given the units |
|
The part’s current rating units of measure |
current_rating_units |
Choose from the “Current Units” list below or “Other” |
Units should make sense given the value |
|
The part’s temperature rating |
temperature_rating |
Plus/minus number up to 7 digits including a resolution of up to 3 decimal places |
Value should make sense given the units |
|
The part’s temperature rating units of measure |
temperature_rating_units |
Choose from the “Temperature Units” list below or “Other” |
Units should make sense given the value |
|
Miscellaneous: |
|||
|
The amount of memory provided by the part |
memory |
Plus/minus number up to 7 digits including a resolution of up to 3 decimal places |
Value should make sense given the units |
|
The part’s memory units of measure |
memory_units |
Choose from the “Memory Units” list below or “Other” |
Units should make sense given the value |
|
The primary communications interface for the part |
interface |
Choose from the “Interface Types” list below or “Other” |
|
|
The part’s operating frequency |
frequency |
Plus/minus number up to 7 digits including a resolution of up to 3 decimal places |
Value should make sense given the units |
|
The part’s frequency units of measure |
frequency_units |
Choose from the “Frequency Units” list below or “Other” |
Units should make sense given the value |
|
The part’s operating wavelength |
wavelength |
Plus/minus number up to 7 digits including a resolution of up to 3 decimal places |
Value should make sense given the units |
|
The part’s wavelength units of measure |
wavelength_units |
Choose from the “Wavelength Units” list below or “Other” |
Units should make sense given the value |
|
Appearance: |
|||
|
The part’s color |
color |
Free form text up to 32 characters |
|
|
The part’s material |
material |
Free form text up to 32 characters |
|
|
The part’s finish |
finish |
Free form text up to 32 characters |
|
|
Dimensions: |
|||
|
The part’s length |
length |
Plus/minus number up to 7 digits including a resolution of up to 3 decimal places |
|
|
The part’s length units of measure |
length_units |
Choose from the “Distance Units” list below or “Other” |
|
|
The part’s width |
width |
Plus/minus number up to 7 digits including a resolution of up to 3 decimal places |
|
|
The part’s width units of measure |
width_units |
Choose from the “Distance Units” list below or “Other” |
|
|
The part’s height |
height |
Plus/minus number up to 7 digits including a resolution of up to 3 decimal places |
|
|
The part’s height units of measure |
height_units |
Choose from the “Distance Units” list below or “Other” |
|
|
The part’s weight |
weight |
Plus/minus number up to 7 digits including a resolution of up to 3 decimal places |
|
|
The part’s weight units of measure |
weight_units |
Choose from the “Weight Units” list below or “Other” |
|
|
Other: |
|||
|
Other part attributes not covered in the above list |
attribute |
Free form text up to 255 characters |
Value Units = Ohms, mOhms, kOhms, F, pF, nF, uF, V, uV, mV, A, uA, mA, C, F, Other
Package Type = 0201 smd, 0402 smd, 0603 smd, 0805 smd, 1206 smd, 1210 smd, 1812 smd,
2010 smd, 2512 smd, 1/8 radial, 1/4 radial, 1/2 radial, Size A, Size B, Size C, Size D, Size E,
SOT-23,
SOT-223, DIL, SOP, SOIC, QFN, QFP, QFT, PLCC, VGA
Power Units = W, uW, mW, kW, MW
Voltage Units = V, uV, mV, kV, MV
Current Units = A, uA, mA, kA, MA
Temperature Units = C, F
Memory Units = KB, MB, GB, TB
Interface Types = I2C, SPI, CAN, One-Wire, RS485, RS232, WiFi, 4G, BT, Z_Wave, Zigbee, LAN, USB, HDMI, Other
Frequency Units = Hz, kHz MHz, GHz
Wavelength Units = km m, cm, um, nm, A (where A means Ångstrom)
Distance Units = mil, in, ft, yd, km, m, cm, um, nm
Weight Units = mg, g, kb, oz, lb
The Bill Of Materials page itemizes all of the parts used in an assembly. An assembly is a part that is comprised of other parts. Assemblies may be nested, meaning that an assembly may include other assemblies.
The Bill Of Materials display orders the listing of parts based upon the optional reference designator assigned to the part. For example, using common electrical engineering conventions, capacitors might have a reference designator that begins with the letter ‘C’ followed by a number, such as C10, C13, C26 and so on. A resistor might have a reference designator that begins with the letter ‘R” followed by a number, such as R1, R13, R15. In the Bill Of Materials listing, these parts would be presented in the order: C10, C13, C26, R1, R13, R15.
A reference designator may be comprised of any printable character. It cannot, however, include any of the delimiters listed below.
If a part does not have a reference then its part number is used to determine its order in the listing.
Whether editing a BOM or uploading a BOM, a warning will be issued when the same reference designator is associated with multiple parts in a Bill of Materials. Sometimes it is desirable to use the same reference designator for multiple parts, which is why this situation is only a warning. The warning is displayed at the top of the page.
Further, when a part is added to a BOM or an existing BOM part is edited, and a reference designator is specified, then the number of designators must match the part quantity specified. Multiple reference designators may be separated by white space, commas, semi-colons, colons, or tabs, such as “R1, R2, R3” or “R1 R2 R3” or “R1; R2, R3”. If the number of reference designators does not match the part quantity then an error is presented and the part is not added to the BOM.
From the Bill Of Materials page it is possible to edit a BOM. The “Manage” menu on the right side of the page includes the choice “Edit BOM”. When selected, a form appears that enables adding a part to the current BOM. The part of interest is identified by its part number. The quantity of parts, one or more reference designators, and the ability to indicate “do not load” are parameters that may be set when adding a part. Only parts that are already in your BOM database may be added to a BOM.
When a BOM is being edited, it is also possible to edit the information about an existing subpart or remove a subpart altogether. At the end of each subpart row is a drop down menu that allows you to edit or delete the subpart. If you chose to edit the subpart you can change which part revision it is tied to, you can change its reference designator(s), you can change the quantity of the subpart, and you can set or unset the subpart’s Do Not Load flag.
If you chose to delete the part then it will be removed from the BOM you are editing. This does not affect any other BOM, and it does not affect the part that the subpart is tied to. In addition, if the subpart appears more than once in the BOM, deleting a subpart row only removes the information contained on that row.
A BOM may be uploaded from a comma-separated file. This can be done from the bottom of the Bill of Materials page when a particular BOM is being edited. It can also be done using the “Upload” menu that appears on the Home page and search results pages.
When you upload BOM subparts from a file, errors may prevent a subpart from being uploaded, for example, an improperly formatted BOM part number a mismatch between the part count and the number of reference designators. The uploading will continue with the next valid subpart in the file.
Any information that you can enter manually about a BOM via the Bill Of Materials page may also be submitted via the BOM upload file. Here is the complete list of items you can upload for a subpart in the list:
|
Item |
Header |
Value |
Guidance |
|---|---|---|---|
|
The subpart’s BOM part number |
part_number |
CCC-NNNNN-VV |
Must be a valid BOM part number; the number of digits in the item number must match your organization’s configuration |
|
Or: |
|||
|
The subpart’s manufacturer’s part number |
manufacturer_part_number |
Per the manufacturer’s convention, up to 128 characters |
Must be a valid manufacturer’s part number previously entered into BOM |
|
For either of the above, must also include: |
|||
|
The quantity of the subpart needed for the BOM |
count |
A positive integer – or - empty |
If empty, the count defaults to 1 |
|
Item |
Header |
Value |
Guidance |
|---|---|---|---|
|
The part’s reference designator |
reference - or - designator |
See the section BOM Reference Designators |
If specified, then the number of reference designators must match the part’s count; A warning will be issued for designators already in use elsewhere in the BOM, however the subpart will still be uploaded |
|
Do not process the part, in other words skip it |
dnp - or - do_not_process |
Y, y, X, x |
|
|
Do not load the part, in other words load it into the BOM but mark as “Do Not Load” into the assembly |
dnl - or - do_not_load |
Y, y, X, x |
A BOM CSV file may be downloaded either from the Search Results page or from the Bill Of Materials page.
On the Search Results page, each part listed presents a menu of download choices. If the part is an assembly, then downloading the part results in its entire BOM being downloaded.
On the Bill of Materials page, the “Manage” menu on the right side of the page presents download choices.
A BOM may be downloaded as a CSV file that is either indented or flat. An indented BOM lists each part exactly as it was added to the BOM, whereas a flat BOM gathers presents only one row for each part number.


Bitcoin Application
Balance
Amount:
0
 ₿
Update
New Address
Address:
Create
Send Bitcoins
Address
Amount
Send
Done!
Unspent Transactions
Update
Include unconfirmed transactions


[gecode-users] Skipping branching alternatives?
Christian Schulte
schulte at imit.kth.se
Tue Jul 11 10:11:03 CEST 2006
I do not know whether BAB will be good enough as I do not know what Martin
exactly needs. However I would also supsect that it will be BAB + X, where X
might be to get more information from search so far.
Christian
--
Christian Schulte, http://www.imit.kth.se/~schulte/
-----Original Message-----
From: Luis Quesada [mailto:luque at info.ucl.ac.be]
Sent: Tuesday, July 11, 2006 10:04 AM
To: schulte at imit.kth.se
Cc: 'Martin Mann'; 'gecode user list'
Subject: Re: [gecode-users] Skipping branching alternatives?
Christian Schulte wrote:
>I just reply to this email, even though I have read the discussion. I
>very much second Guido and Mikael and I have another bit to add as to
>why your idea of tinkering with branchings does not work.
>
>The entire setup of search in Gecode relies on recomputation: here, a
>commit operation using a branching description _must_ always tell the
>very same constraint when invoked with the same parameters. So by
>definition, it is not allowed to use state in the way you state it.
>
>
>
I confess that I still don't see why you need to implement another
search engine for dealing with Martin's problem. It seems to me that BAB
would do the job....Cannot Martin do what he wants to do by using the
constrain method? To me, that's the best place to address his global
property.
Luis
More information about the gecode-users
mailing list


juanpgonzlez:~ webSite$ cd documents/me
juanpgonzlez:me webSite$ cat AboutMe.txt
---------------------------------
My name is Juan Pablo Gonzalez P.
---------------------------------
- Web developer & Designer
I am passionate about sports, technology and being able to work with talented people. I want to work developing software solutions that have an impact on the industry. I love to carry out my own ideas, to be entrepreneur,proactive and have a good team work. In my experience at the university, one of the biggest challenges I have faced is working as a team where people do not want to carry out their tasks, so I have researched to understand how to motivate people to love the things they do, since to work in a team is also to understand each other, to care about each other and to give constructive criticism to improve.
links = ( GitHub, linkedin)
Download my resume here.
Contact me at<EMAIL_ADDRESS>juanpgonzlez:me webSite$


Warning: This is a work in progress.
The LLVM target-independent code generator is a framework that provides a suite of reusable components for translating the LLVM internal representation to the machine code for a specified target -- either in assembly form (suitable for a static compiler) or in binary machine code format (usable for a JIT compiler). The LLVM target-independent code generator consists of five main components:
Depending on which part of the code generator you are interested in working on, different pieces of this will be useful to you. In any case, you should be familiar with the target description and machine code representation classes. If you want to add a backend for a new target, you will need to implement the target description classes for your new target and understand the LLVM code representation. If you are interested in implementing a new code generation algorithm, it should only depend on the target-description and machine code representation classes, ensuring that it is portable.
The two pieces of the LLVM code generator are the high-level interface to the code generator and the set of reusable components that can be used to build target-specific backends. The two most important interfaces (TargetMachine and TargetData classes) are the only ones that are required to be defined for a backend to fit into the LLVM system, but the others must be defined if the reusable code generator components are going to be used.
This design has two important implications. The first is that LLVM can support completely non-traditional code generation targets. For example, the C backend does not require register allocation, instruction selection, or any of the other standard components provided by the system. As such, it only implements these two interfaces, and does its own thing. Another example of a code generator like this is a (purely hypothetical) backend that converts LLVM to the GCC RTL form and uses GCC to emit machine code for a target.
This design also implies that it is possible to design and implement radically different code generators in the LLVM system that do not make use of any of the built-in components. Doing so is not recommended at all, but could be required for radically different targets that do not fit into the LLVM machine description model: programmable FPGAs for example.
Important Note: For historical reasons, the LLVM SparcV9 code generator uses almost entirely different code paths than described in this document. For this reason, there are some deprecated interfaces (such as TargetRegInfo and TargetSchedInfo), which are only used by the V9 backend and should not be used by any other targets. Also, all code in the lib/Target/SparcV9 directory and subdirectories should be considered deprecated, and should not be used as the basis for future code generator work. The SparcV9 backend is slowly being merged into the rest of the target-independent code generators, but this is a low-priority process with no predictable completion date.
The LLVM target-indendent code generator is designed to support efficient and quality code generation for standard register-based microprocessors. Code generation in this model is divided into the following stages:
The code generator is based on the assumption that the instruction selector will use an optimal pattern matching selector to create high-quality sequences of native instructions. Alternative code generator designs based on pattern expansion and aggressive iterative peephole optimization are much slower. This design permits efficient compilation (important for JIT environments) and aggressive optimization (used when generating code offline) by allowing components of varying levels of sophisication to be used for any step of compilation.
In addition to these stages, target implementations can insert arbitrary target-specific passes into the flow. For example, the X86 target uses a special pass to handle the 80x87 floating point stack architecture. Other targets with unusual requirements can be supported with custom passes as needed.
The target description classes require a detailed description of the target architecture. These target descriptions often have a large amount of common information (e.g., an add instruction is almost identical to a sub instruction). In order to allow the maximum amount of commonality to be factored out, the LLVM code generator uses the TableGen tool to describe big chunks of the target machine, which allows the use of domain- and target-specific abstractions to reduce the amount of repetition.
The LLVM target description classes (which are located in the include/llvm/Target directory) provide an abstract description of the target machine, independent of any particular client. These classes are designed to capture the abstract properties of the target (such as what instruction and registers it has), and do not incorporate any particular pieces of code generation algorithms (these interfaces do not take interference graphs as inputs or other algorithm-specific data structures).
All of the target description classes (except the TargetData class) are designed to be subclassed by the concrete target implementation, and have virtual methods implemented. To get to these implementations, the TargetMachine class provides accessors that should be implemented by the target.
The TargetMachine class provides virtual methods that are used to access the target-specific implementations of the various target description classes (with the getInstrInfo, getRegisterInfo, getFrameInfo, ... methods). This class is designed to be specialized by a concrete target implementation (e.g., X86TargetMachine) which implements the various virtual methods. The only required target description class is the TargetData class, but if the code generator components are to be used, the other interfaces should be implemented as well.
The TargetData class is the only required target description class, and it is the only class that is not extensible (it cannot be derived from). It specifies information about how the target lays out memory for structures, the alignment requirements for various data types, the size of pointers in the target, and whether the target is little- or big-endian.
The MRegisterInfo class (which will eventually be renamed to TargetRegisterInfo) is used to describe the register file of the target and any interactions between the registers.
Registers in the code generator are represented in the code generator by unsigned numbers. Physical registers (those that actually exist in the target description) are unique small numbers, and virtual registers are generally large.
Each register in the processor description has an associated MRegisterDesc entry, which provides a textual name for the register (used for assembly output and debugging dumps), a set of aliases (used to indicate that one register overlaps with another), and some flag bits.
In addition to the per-register description, the MRegisterInfo class exposes a set of processor specific register classes (instances of the TargetRegisterClass class). Each register class contains sets of registers that have the same properties (for example, they are all 32-bit integer registers). Each SSA virtual register created by the instruction selector has an associated register class. When the register allocator runs, it replaces virtual registers with a physical register in the set.
The target-specific implementations of these classes is auto-generated from a TableGen description of the register file.
At the high-level, LLVM code is translated to a machine specific representation formed out of MachineFunction, MachineBasicBlock, and MachineInstr instances (defined in include/llvm/CodeGen). This representation is completely target agnostic, representing instructions in their most abstract form: an opcode and a series of operands. This representation is designed to support both SSA representation for machine code, as well as a register allocated, non-SSA form.
Target machine instructions are represented as instances of the MachineInstr class. This class is an extremely abstract way of representing machine instructions. In particular, all it keeps track of is an opcode number and some number of operands.
The opcode number is an simple unsigned number that only has meaning to a specific backend. All of the instructions for a target should be defined in the *InstrInfo.td file for the target, and the opcode enum values are autogenerated from this description. The MachineInstr class does not have any information about how to intepret the instruction (i.e., what the semantics of the instruction are): for that you must refer to the TargetInstrInfo class.
The operands of a machine instruction can be of several different types: they can be a register reference, constant integer, basic block reference, etc. In addition, a machine operand should be marked as a def or a use of the value (though only registers are allowed to be defs).
By convention, the LLVM code generator orders instruction operands so that all register definitions come before the register uses, even on architectures that are normally printed in other orders. For example, the sparc add instruction: "add %i1, %i2, %i3" adds the "%i1", and "%i2" registers and stores the result into the "%i3" register. In the LLVM code generator, the operands should be stored as "%i3, %i1, %i2": with the destination first.
Keeping destination operands at the beginning of the operand list has several advantages. In particular, the debugging printer will print the instruction like this:
%r3 = add %i1, %i2
If the first operand is a def, and it is also easier to create instructions whose only def is the first operand.
Machine instructions are created by using the BuildMI functions, located in the include/llvm/CodeGen/MachineInstrBuilder.h file. The BuildMI functions make it easy to build arbitrary machine instructions. Usage of the BuildMI functions look like this:
// Create a 'DestReg = mov 42' (rendered in X86 assembly as 'mov DestReg, 42') // instruction. The '1' specifies how many operands will be added. MachineInstr *MI = BuildMI(X86::MOV32ri, 1, DestReg).addImm(42); // Create the same instr, but insert it at the end of a basic block. MachineBasicBlock &MBB = ... BuildMI(MBB, X86::MOV32ri, 1, DestReg).addImm(42); // Create the same instr, but insert it before a specified iterator point. MachineBasicBlock::iterator MBBI = ... BuildMI(MBB, MBBI, X86::MOV32ri, 1, DestReg).addImm(42); // Create a 'cmp Reg, 0' instruction, no destination reg. MI = BuildMI(X86::CMP32ri, 2).addReg(Reg).addImm(0); // Create an 'sahf' instruction which takes no operands and stores nothing. MI = BuildMI(X86::SAHF, 0); // Create a self looping branch instruction. BuildMI(MBB, X86::JNE, 1).addMBB(&MBB);
The key thing to remember with the BuildMI functions is that you have to specify the number of operands that the machine instruction will take (allowing efficient memory allocation). Also, if operands default to be uses of values, not definitions. If you need to add a definition operand (other than the optional destination register), you must explicitly mark it as such.
One important issue that the code generator needs to be aware of is the presence of fixed registers. In particular, there are often places in the instruction stream where the register allocator must arrange for a particular value to be in a particular register. This can occur due to limitations in the instruction set (e.g., the X86 can only do a 32-bit divide with the EAX/EDX registers), or external factors like calling conventions. In any case, the instruction selector should emit code that copies a virtual register into or out of a physical register when needed.
For example, consider this simple LLVM example:
int %test(int %X, int %Y) { %Z = div int %X, %Y ret int %Z }
The X86 instruction selector produces this machine code for the div and ret (use "llc X.bc -march=x86 -print-machineinstrs" to get this):
;; Start of div %EAX = mov %reg1024 ;; Copy X (in reg1024) into EAX %reg1027 = sar %reg1024, 31 %EDX = mov %reg1027 ;; Sign extend X into EDX idiv %reg1025 ;; Divide by Y (in reg1025) %reg1026 = mov %EAX ;; Read the result (Z) out of EAX ;; Start of ret %EAX = mov %reg1026 ;; 32-bit return value goes in EAX ret
By the end of code generation, the register allocator has coallesced the registers and deleted the resultant identity moves, producing the following code:
;; X is in EAX, Y is in ECX mov %EAX, %EDX sar %EDX, 31 idiv %ECX ret
This approach is extremely general (if it can handle the X86 architecture, it can handle anything!) and allows all of the target specific knowledge about the instruction stream to be isolated in the instruction selector. Note that physical registers should have a short lifetime for good code generation, and all physical registers are assumed dead on entry and exit of basic blocks (before register allocation). Thus if you need a value to be live across basic block boundaries, it must live in a virtual register.
MachineInstr's are initially instruction selected in SSA-form, and are maintained in SSA-form until register allocation happens. For the most part, this is trivially simple since LLVM is already in SSA form: LLVM PHI nodes become machine code PHI nodes, and virtual registers are only allowed to have a single definition.
After register allocation, machine code is no longer in SSA-form, as there are no virtual registers left in the code.
This section of the document explains any features or design decisions that are specific to the code generator for a particular target.
The X86 code generator lives in the lib/Target/X86 directory. This code generator currently targets a generic P6-like processor. As such, it produces a few P6-and-above instructions (like conditional moves), but it does not make use of newer features like MMX or SSE. In the future, the X86 backend will have subtarget support added for specific processor families and implementations.
The x86 has a very, uhm, flexible, way of accessing memory. It is capable of forming memory addresses of the following expression directly in integer instructions (which use ModR/M addressing):
Base+[1,2,4,8]*IndexReg+Disp32
Wow, that's crazy. In order to represent this, LLVM tracks no less that 4 operands for each memory operand of this form. This means that the "load" form of 'mov' has the following "Operands" in this order:
Index: 0 | 1 2 3 4 Meaning: DestReg, | BaseReg, Scale, IndexReg, Displacement OperandTy: VirtReg, | VirtReg, UnsImm, VirtReg, SignExtImm
Stores and all other instructions treat the four memory operands in the same way, in the same order.
An instruction name consists of the base name, a default operand size followed by a character per operand with an optional special size. For example:
ADD8rr -> add, 8-bit register, 8-bit register
IMUL16rmi -> imul, 16-bit register, 16-bit memory, 16-bit immediate
IMUL16rmi8 -> imul, 16-bit register, 16-bit memory, 8-bit immediate
MOVSX32rm16 -> movsx, 32-bit register, 16-bit memory


Collector Marsha:
Player:
Scissors
Collector Marsha:
Rock
Oh, too bad, you lose! I'll take those orbs now... Hey now, shall we play another round?
Play the game.
Quit


This will be scheduled post-Thanksgiving break.
The front page cards were redone and checked at all screen sizes.
closed
by None at 2021-11-16 14:00:26.labeled
by None at 2021-11-16 14:00:46.Can't replicate now. And all widgets were thoroughly tested during the spotlight 3 upgrade.
closed
by None at 2021-11-16 14:03:29.This is no longer happening.
closed
by None at 2021-11-16 14:04:00.unlabeled
by None at 2021-11-16 14:13:48.labeled
by None at 2021-11-16 14:24:37.labeled
by None at 2021-11-16 14:24:53.labeled
by None at 2021-11-16 14:28:35.labeled
by None at 2021-11-16 14:31:38.labeled
by None at 2021-11-16 14:31:38.There is now only one entry with "lae" -- not sure if the poster collection is still a thing? but regardless there's only one "lae" in https://figgy.princeton.edu/iiif/collections
Checked with stakeholders on this one. The posters are being integrated into LAE and the old DPUL exhibit for them is no longer a thing.
closed
by None at 2021-11-16 14:13:36.renamed
by None at 2021-11-16 14:44:32.@kelea99 is this resolved?
@hackartisan it is not. There is enough to unpack and test with the languages, I did not prioritize it all for the upgrade work cycle. While still important for a future workcycle/to work in when appropriate, I feel that compared to the other tickets (especially if we still have accessibility tickets on the board), this had to take a back seat. But please do let me know if you feel this can and should have been addressed! I am learning too :)
@kelea99 Okay thanks for checking. I don't think there's more we can do now but when we are able to work on it we should look together to get this ticket specified / actionable. For now I was just seeing if there were backlog tickets we could close after the last work cycle. Thank you!
mentioned
by Kim Leaman at 2021-11-16 14:41:46.subscribed
by Kim Leaman at 2021-11-16 14:41:46.labeled
by None at 2021-11-16 14:41:58.mentioned
by None at 2021-11-16 15:21:31.subscribed
by None at 2021-11-16 15:21:31.mentioned
by Kim Leaman at 2021-11-16 16:08:45.subscribed
by Kim Leaman at 2021-11-16 16:08:45.unlabeled
by None at 2021-11-16 16:08:52.closed
by Trey Pendragon at 2021-11-16 17:49:40.deployed
by None at 2021-11-16 13:57:08.ready_for_review
by None at 2021-11-16 14:31:56.referenced
by Trey Pendragon at 2021-11-16 17:49:40.merged
by Trey Pendragon at 2021-11-16 17:49:40.closed
by Trey Pendragon at 2021-11-16 17:49:41.head_ref_deleted
by Trey Pendragon at 2021-11-16 17:49:41.I just emailed lsupport to get added the dpul prod boxes added to the allow list. The setup for allowing email to princeton email addresses is well-defined and we will do that first; it may be all we need.
For sending email to non-princeton email addresses, the process is not well-defined. I could work on clarifying this but we should determine whether we need it, maybe as part of evaluating the success of the work done for princeton email addresses. A couple of considerations: - You can't log into DPUL without a network account - The link to the bookmarks page only shows if you are logged in - Even if we changed this, bookmarks wouldn't persist beyond a session, so there could be some usability work to make sure folks without network accounts understand its impermanence. - If we don't change it, still may be some usability work to do here because a person without a network account can create bookmarks but not view them. - I'm not sure what the implications are for our collaborators with proxy network accounts.
@hackartisan , if the non-princeton.edu accounts for collaborators are university sponsored, does that make any difference to the synopsis above?
Regarding determining whether or not we need support for sending email to non-princeton addresses: Since Fernando is the primary stakeholder to ask about bookmarks, it might be good to start with looking at how the LAE site is configured and then go from there? Is it set up to mail bookmarks to whomever?
assigned
by None at 2021-11-16 16:19:11.mentioned
by None at 2021-11-16 19:49:27.subscribed
by None at 2021-11-16 19:49:27.closed
by Bess Sadler at 2021-11-16 15:07:13.https://github.com/pulibrary/princeton_ansible/pull/2573 ensures that the NGINX Plus configuration sets the proper HTTP headers for WebSockets.
assigned
by Bess Sadler at 2021-11-16 13:23:23.assigned
by James R. Griffin III at 2021-11-16 13:23:32.closed
by Bess Sadler at 2021-11-16 19:33:36.assigned
by Bess Sadler at 2021-11-16 19:33:55.These have been delivered to the stakeholder, closing
closed
by Kate Lynch at 2021-11-16 14:53:06.labeled
by Kate Lynch at 2021-11-16 14:58:07.The XML structure seems to be identical:
<collection>
<item>
<title>Suicide in Seneca: Tragic and Stoic Perspectives</title>
<author>Brill, Rachel</author>
<authorid>961185466</authorid>
<advisor>Graziosi, Barbara</advisor>
<classyear>2019</classyear>
<department>Classics</department>
<url>http://arks.princeton.edu/ark:/88435/dsp016108vf082</url>
</item>
</collection>
<collection>
<item>
<title>The Landscapes of Pithos Production at Hellenistic Morgantina</title>
<author>Thurn, Leina</author>
<authorid/>
<advisor/>
<classyear>2020</classyear>
<department>Classics</department>
<url>http://arks.princeton.edu/ark:/88435/dsp019z9032880</url>
</item>
</collection>
labeled
by James R. Griffin III at 2021-11-16 15:31:26.labeled
by James R. Griffin III at 2021-11-16 15:31:26.labeled
by James R. Griffin III at 2021-11-16 15:31:26.assigned
by James R. Griffin III at 2021-11-16 15:31:26.I have scheduled a meeting to pair with Lynn Durgin on this on Tuesday from a user standpoint. It won't go into production until after the Thanksgiving break. Is there additional action needed on this ticket, or should we close it?
Hannah reported she was able to access, closing this.
closed
by Kate Lynch at 2021-11-16 21:27:04.@jrgriffiniii and I paired on this; I added an "Edit Metadata"/collection approvers group with the affected users and aborted the item's workflow, and James resubmitted the item. Awaiting confirmation from Matt to see if this worked.
mentioned
by James R. Griffin III at 2021-11-16 21:43:04.subscribed
by James R. Griffin III at 2021-11-16 21:43:04.unassigned
by Xander Gardner at 2021-11-16 15:15:21.unlabeled
by Eliot Jordan at 2021-11-16 15:15:36.closed
by Eliot Jordan at 2021-11-16 15:16:27.labeled
by Trey Pendragon at 2021-11-16 17:22:34.labeled
by Trey Pendragon at 2021-11-16 17:22:44.head_ref_force_pushed
by Trey Pendragon at 2021-11-16 17:41:16.referenced
by Trey Pendragon at 2021-11-16 17:40:34.renamed
by None at 2021-11-16 17:40:39.closed
by Trey Pendragon at 2021-11-16 19:07:54.referenced
by Trey Pendragon at 2021-11-16 19:07:54.merged
by Trey Pendragon at 2021-11-16 19:07:54.closed
by Trey Pendragon at 2021-11-16 19:07:54.head_ref_deleted
by Trey Pendragon at 2021-11-16 19:07:55.assigned
by Eliot Jordan at 2021-11-16 20:32:58.closed
by Eliot Jordan at 2021-11-16 20:34:38.referenced
by Eliot Jordan at 2021-11-16 20:34:38.merged
by Eliot Jordan at 2021-11-16 20:34:38.closed
by Eliot Jordan at 2021-11-16 20:34:38.head_ref_deleted
by Eliot Jordan at 2021-11-16 20:34:39.referenced
by Trey Pendragon at 2021-11-16 20:56:07.merged
by Trey Pendragon at 2021-11-16 20:56:07.closed
by Trey Pendragon at 2021-11-16 20:56:08.head_ref_deleted
by Trey Pendragon at 2021-11-16 20:56:08.In the most recent case it looks like someone hit the checkout button twice.
It seems like someone's slamming that button a bunch too and managing to take up all the available item charges for themselves.
referenced
by Trey Pendragon at 2021-11-17 00:06:24.labeled
by Trey Pendragon at 2021-11-17 00:30:10.labeled
by Trey Pendragon at 2021-11-17 00:30:19.See condensed/reordered wireframe:
This is ready for review with stakeholders and DSSG. If tickets come out of this review, they will be created separately. Closing this.
closed
by Kate Lynch at 2021-11-16 15:16:53.Research document - https://docs.google.com/document/d/1bqcgcIlxM1-clijhAIU51LfLzQEdyqyyF9fJkiVNElU/edit#heading=h.bsmas9g4txvg
closed
by Kate Lynch at 2021-11-16 21:22:48.reopened
by Kate Lynch at 2021-11-16 21:22:53.assigned
by Kate Lynch at 2021-11-16 21:43:50.assigned
by Kate Lynch at 2021-11-16 21:45:12.I am merging this even though the drupal9 test is failing, per discussion with @kayiwa
mentioned
by Francis Kayiwa at 2021-11-16 13:21:22.subscribed
by Francis Kayiwa at 2021-11-16 13:21:22.referenced
by Bess Sadler at 2021-11-16 13:21:45.merged
by Bess Sadler at 2021-11-16 13:21:45.closed
by Bess Sadler at 2021-11-16 13:21:45.head_ref_deleted
by Bess Sadler at 2021-11-16 13:21:45.pretty sure this is the same problem here https://github.com/ansible/ansible/issues/73307
referenced
by Bess Sadler at 2021-11-16 19:31:29.merged
by Bess Sadler at 2021-11-16 19:31:29.closed
by Bess Sadler at 2021-11-16 19:31:29.head_ref_deleted
by Bess Sadler at 2021-11-16 19:31:29.There is a new cron that is taking care of this now, created as a resolution to https://github.com/pulibrary/DSS/issues/180. Since that's running perhaps we don't need hard way documentation. I think we should probably close this PR. @kevinreiss what do you think?
mentioned
by Kevin Reiss at 2021-11-16 16:24:17.subscribed
by Kevin Reiss at 2021-11-16 16:24:17.assigned
by None at 2021-11-16 16:26:26.referenced
by None at 2021-11-16 16:29:48.assigned
by None at 2021-11-16 18:51:04.referenced
by None at 2021-11-16 20:48:48.closed
by None at 2021-11-16 21:05:00.referenced
by None at 2021-11-16 21:05:00.merged
by None at 2021-11-16 21:05:00.closed
by None at 2021-11-16 21:05:00.head_ref_deleted
by None at 2021-11-16 21:05:01.labeled
by Trey Pendragon at 2021-11-16 22:14:50.assigned
by Trey Pendragon at 2021-11-16 23:29:18.referenced
by Trey Pendragon at 2021-11-16 23:41:43.referenced
by Trey Pendragon at 2021-11-16 23:42:14.The pick-up locations displayed as the possible destination for these items should be the set of delivery locations that are configured in bibdata/alma.
unlabeled
by Kevin Reiss at 2021-11-16 17:16:42.labeled
by Kevin Reiss at 2021-11-16 17:16:42.


This content is being loaded from account.html but you may have noticed that the URL has not changed.


Account
Current account details
Holder number: 123, Holder name: 123, Account number: 123, Balance: 123 SEK
Deposit
Please enter amount to deposit
Withdraw
Please enter amount to withdraw
Current account details
Holder number: 123, Holder name: 123, Account number: 123, Balance: 123 SEK
Please enter amount to deposit
Please enter amount to withdraw


Nobelium
Element Name:
Nobelium
Latin Name:
Nobelium
Atomic Number:
Nobelium
Atomic Weight:
259.1009 u
Is a:
Actinoid
State of the element:
Solid
About:
Nobelium is a synthetic chemical element with the symbol No and atomic number 102. It is named in honor of Alfred Nobel, the inventor of dynamite and benefactor of science. A radioactive metal, it is the tenth transuranic element and is the penultimate member of the actinide series. Like all elements with atomic number over 100, nobelium can only be produced in particle accelerators by bombarding lighter elements with charged particles. A total of twelve nobelium isotopes are known to exist; the most stable is 259No with a half-life of 58 minutes, but the shorter-lived 255No is most commonly used in chemistry because it can be produced on a larger scale.
Electrons
102
Protons
102
Neutrons
157
Discoverer:
Glenn Theodore Seaborg
Discovered in:
1965


WHAT IS IT
A simple way to multitask on the web
There are several ways to watch your favorite videos while browsing the web: this is called Picture in Picture. Wouldn't it be great if you could do this with any site, not just videos? TabFloater allows you to do exactly that - no more switching tabs back and forth!
Always on top
The floating tab always keeps on top, so you can interact with other websites.
Smart positioning
TabFloater can automatically position the floating tab over empty areas, so all content remains visible.


The ratio Talpha'/T0 is plotted versus the angle of the isogons (Talpha' = length of an isogon, T0 = distance between two layers in
the fold hinge). The curves for an ideal parallel fold (horizontal
line) and for an ideal similar fold (cosine function) are drawn.
colour and line
type can be changed.


Consumer Complaint Database
, 01/01/2015 ... 27/08/2015
Data from
Consumer Complaint Database
, by
Consumer Financial Protection Bureau
.


Toggle navigation
Jeeshop Admin
Settings
Help
Overview
Catalog
Orders
Stats
Users
Emails, Newsletters
Authentication has Failed!
Logged in as {{loginCtrl.credentials.login}}
Logout
Overview
Catalog
Orders
Stats
Users
Emails, Newsletters


CODE.IN
the more you code, the more you code.
From the makers of India's First Coding Bootcamp
From the makers of India's First Coding Bootcamp
Coding Bootcamp, Platform and Program for Kids.
Live Coding Performances.
Powering Coding Bootcamps.
Smile and Compile;
Live Classrooms Powered by Intellect.
Not for the ordinary.
Classrooms for Smart India.
APPLY
Application Management Systems for Coding Bootcamp. Fast. Better.
Bringing great minds together.


Scenario writers may want to express a parameter in a tabular structure. For example:
Given the traders: |name|rank| |Larry|Stooge 3| |Moe|Stooge 1| |Curly|Stooge 2| When a wildcard search ".*y" is executed Then the traders returned are: |name|rank| |Larry|Stooge 3| |Curly|Stooge 2|
Now, JBehave supports multi-line parameters out-of-the-box. Next, we need only combine this feature with the table parsing functionality already seen in the table examples:
@Given("the traders: $tradersTable") public void theTraders(ExamplesTable tradersTable) { // tradersTable is automatically parsed using the multi-line String input // next we need to interpret its content to create a list of traders // then we can use the traders create in subsequent steps this.traders = toTraders(tradersTable); } private List toTraders(ExamplesTable table) { List traders = new ArrayList(); List rows = table.getRows(); for (Map row : rows) { String name = row.get("name"); String rank = row.get("rank"); traders.add(new Trader(name, rank)); } Collections.sort(traders); return traders; }
Note: We are using the same table parsing functionality of the table examples, via the re-use of the ExamplesTable, but there is a fundamental difference between these two use cases: with table examples the scenario is run for each line of the table (using in each execution the parameter values of the given row), while in using table parameters we are simply using the tabular structure as a parameter, and how this structure is interpreted is up to the scenario writer.


-
Avalanche Prediction Model
This is a Python based application that takes in historical weather data from winter 2017/2018 and elevation data taken by NASA’s Shuttle Radar Topgraphy Misson (SRTM) and creates an risk analysis of any region in the greater Salt Lake City area on any date in the winter season. It contains a command line GUI for the user to imput the name of the area along with four latitude and longitude bounds and outputs a interactive 2D and 3D map for the user to see where the safest area is to ski. An example for Park City, Utah for April 1, 2018 in 3D is seen below: …
-
Laplace Equation Solved by Iterations
You’ll find this post in your _posts directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run jekyll serve --watch, which launches a web server and auto-regenerates your site when a file is updated. …
-
Laplace Equation Solved by Iterations
You’ll find this post in your _posts directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run jekyll serve --watch, which launches a web server and auto-regenerates your site when a file is updated. …


Cetus clock
0:00:00
8:88:88
The clock is broken!!
Bounties reset in
2:30:00
Shortcuts
URL:
Name:
Name:
Developed by IronKhagan. Background image by somebody
GitHub
I am not affiliated with Digital Extremes. This website is a personal project.
GitHub
I am not affiliated with Digital Extremes. This website is a personal project.


Payment Gateway
Course-1 $15
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s
Course-2 $5
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s
Course-3 $8
orem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s
Amount$30


PIG LATIN
Let's get TRANSLATING
Please enter a word or phrase that you would like to see in Pig Latin
Translate!


publications
2018
-
Convolutional Neural Network Based Sensors for Mobile Robot Relocalization In 2018 23rd International Conference on Methods & Models in Automation & Robotics (MMAR) 2018
2019
-
Autonomous Detection and Tracking of a High-Speed Ground Vehicle using a Quadrotor UAV In AIAA Scitech 2019 Forum 2019
-
Vision-based autonomous tracking and landing of a fully-actuated rotorcraft Control Engineering Practice 2019


Seating Assignments
Rules: no more than 4 students per table. Must have at least one student of each gender at a full table.
Available Students
Master List
Seat One
Seat Two
Seat Three
Seat Four
Available


Generative Adversarial Networks: The Basics
Posted on mar. 19 décembre 2017 in Generative Adversarial Network by Corey Adams
In particle physics, we think adversarial networks are particularly interesting tools to explore discrepancies between our simulation and real detector data. In principle, the physics tools used for simulation of particle interaction data are quite good, but they are never perfect. Additionally, they are always imperfect in difficult to model ways. Many experiments spend a lot of time studying the differences between the output of their simulation and their real detector data, and a deep network that can learn these differences is really useful for making progress.
In this tutorial, I'll cover some basics of generative adversarial networks with very simple feed-forward neural networks (not even convolutional) as a demonstration of the basic techniques of GANs. You can read the original paper on GANs here: https://arxiv.org/abs/1406.2661. The basic idea is you train two networks to compete with each other. The first (called the discriminator) makes a decision on whether or not the images it's looking at are real or fake. The second (called the generator) tries to generate fake images from random noise to fool the discriminator.
In the years since the original paper came out, GANs have grown increasinly more sophisticated and impressive, especially with the advent of the Deep Convolutional Generative Adversarial Network (DCGAN, original paper: https://arxiv.org/abs/1511.06434). For this tutorial, we're going to eschew all of the recent advances to make a GAN that can generate artificial digits based on the mnist data set. By stripping the networks down to their basics, it's easier to focus on the core aspects of the loss function and outputs, and to avoid the complications of training on GPUs, etc.
MNIST data set¶
The mnist data set is one of the most famous collections of labeled images that exists. You can read all about it at the original website (http://yann.lecun.com/exdb/mnist/), but it has a few nice advantages that make it ideal for learning:
- It's open, and has convient wrappers in many languages (we'll use tensorflows soon)
- It's a large data set (60k training images) but each image is small (28x28)
- The data has been preprocessed to center images of digits and make them easier to use
Basically, you can focus on the fundamentals with this data set, which is why we'll use it here. Some examples of loading it with tensorflow (more here: https://www.tensorflow.org/get_started/mnist/beginners)
%env CUDA_DEVICE_ORDER=PCI_BUS_ID
%env CUDA_VISIBLE_DEVICES=0
import tensorflow as tf
import numpy
from tensorflow.examples.tutorials.mnist import input_data
With tensorflow, you can specify which device to use. The next cell will tell you what's available, and you can select from there. By default, I select "/gpu:0" but you can change this below
from tensorflow.python.client import device_lib
print device_lib.list_local_devices()
default_device = "/gpu:0"
mnist = input_data.read_data_sets("MNIST_data", one_hot=False)
mnist_images, mnist_labels = mnist.train.next_batch(batch_size=5)
Here, we've loaded the mnist data from the tensorflow helper class, and asked for the next batch of images and labels. Let's view those to see what the data looks like before delving into the network:
print "mnist_images.shape: {}".format(mnist_images.shape)
print "mnist_labels.shape: {}".format(mnist_labels.shape)
As expected, variables are arrays with the outermost dimension equal to 5. The images, though, comes unpacked as a 1D array per image instead of a 2D array. We can reshape this to what we're more familar with, since we know mnist images are 28x28:
mnist_images = numpy.reshape(mnist_images, (-1, 28, 28)) # -1 can be used as a placeholder for batch size here
print "mnist_images.shape: {}".format(mnist_images.shape)
Matplotlib gives a good interface for viewing these images in a notebook (or even in general, in python):
from matplotlib import pyplot as plt
%matplotlib inline
index = numpy.random.randint(5)
fig = plt.figure(figsize=(10,10))
plt.imshow(mnist_images[index], cmap="Greys", interpolation="none")
print "This image is labeled as {}".format(mnist_labels[index])
plt.show()
Drawn like this, you can see each individual pixel clearly. It's not a high resolution image, but you can clearly tell what the digit is!
Building a model for a GAN¶
We'll start to put together a network for the GAN, first by defining some useful constants that we'll need to call on multiple times:
BASE_LEARNING_RATE = 0.0002
BATCH_SIZE=50
RANDOM_INPUT_DIMENSIONALITY = 100
MAX_EPOCH=100
INCLUDE_NOISE=True
LOGDIR="./mnist_gan_logs/lr_{}_include_noise_{}_batchsize_{}".format(BASE_LEARNING_RATE, INCLUDE_NOISE, BATCH_SIZE)
RESTORE=False
TRAINING=True
Additionally, let's make sure we have the same graph by defining it:
tf.reset_default_graph()
g = tf.Graph()
Set up the placeholders for the input variables. We'll need to input both real images and random noise, so make a placeholder for both. Additionally, based on this blog post (http://www.inference.vc/instance-noise-a-trick-for-stabilising-gan-training/) I add random gaussian noise to the real and fake images as they are fed to the discriminator to help stabalize training.
with tf.device(default_device):
with g.as_default():
# Input noise to the generator:
noise_tensor = tf.placeholder(tf.float32, [BATCH_SIZE, RANDOM_INPUT_DIMENSIONALITY], name="noise")
# fake_input = tf.reshape(noise_tensor, (tf.shape(noise_tensor)[0], 10,10, 1))
# Placeholder for the discriminator input:
real_flat = tf.placeholder(tf.float32, [BATCH_SIZE, 784], name='x')
# We augment the input to the discriminator with gaussian noise
# This makes it harder for the discriminator to do it's job, preventing
# it from always "winning" the GAN min/max contest
real_noise = tf.placeholder(tf.float32, [BATCH_SIZE, 28*28], name="real_noise")
fake_noise = tf.placeholder(tf.float32, [BATCH_SIZE, 28*28], name="fake_noise")
real_images = real_flat + real_noise
Notice how the input tensors (noise_tensor, real_images) are shaped in the 'flattened' way: (N/2, 100) for noise, (N/2, 784) for real images. This lets me input the mnist images directly to tensorflow, as well as the noise. They are then reshaped to be like tensorflow images (Batch, H, W, Filters).
Image Discriminator:¶
Make a function to build the discriminator, using fully connected networks. Note that a convolutional layer with the stride equal to the image size is a fully connected layer.
def build_discriminator(input_tensor, reuse, is_training, reg=0.2, dropout_rate=0.3):
# Use scoping to keep the variables nicely organized in the graph.
# Scoping is good practice always, but it's *essential* here as we'll see later on
with tf.variable_scope("mnist_discriminator", reuse=reuse):
x = tf.layers.dense(input_tensor, 512, name="fc1")
# Apply a non linearity:
x = tf.maximum(reg*x, x, name="leaky_relu_1")
# Apply a dropout layer:
x = tf.layers.dropout(x,rate=dropout_rate, training=is_training, name="dropout1")
x = tf.layers.dense(x, 256, name="fc2")
# Apply a non linearity:
x = tf.maximum(reg*x, x, name="leaky_relu_2")
# Apply a dropout layer:
x = tf.layers.dropout(x,rate=dropout_rate, training=is_training, name="dropout2")
x = tf.layers.dense(x, 1, name="fc4")
# Since we want to predict "real" or "fake", an output of 0 or 1 is desired. sigmoid is perfect for this:
x = tf.nn.sigmoid(x, name="discriminator_sigmoid")
return x
with tf.device(default_device):
with g.as_default():
real_image_logits = build_discriminator(real_images, reuse=False,is_training=TRAINING, reg=0.2, dropout_rate=0.3)
Now we can define a function to generate random images from noise:
def build_generator(input_tensor, reg=0.2):
# Again, scoping is essential here:
with tf.variable_scope("mnist_generator"):
x = tf.layers.dense(input_tensor, 256, name="fc1")
# Apply a non linearity:
x = tf.maximum(reg*x, x, name="leaky_relu_1")
x = tf.layers.dense(x, 512, name="fc2")
# Apply a non linearity:
x = tf.maximum(reg*x, x, name="leaky_relu_2")
x = tf.layers.dense(x, 1024, name="fc3")
# Apply a non linearity:
x = tf.maximum(reg*x, x, name="leaky_relu_3")
x = tf.layers.dense(x, 28*28, name="fc4")
# Reshape to match mnist images:
# x = tf.reshape(x, (-1, 28, 28, 1))
# The final non linearity applied here is to map the images onto the [-1,1] range.
x = tf.nn.tanh(x, name="generator_tanh")
return x
with tf.device(default_device):
with g.as_default():
fake_images = build_generator(noise_tensor) + fake_noise
We also need to be able to run the discriminator on the fake images, so set that up too. Since it trains on both real and fake images, set reuse=True here:
with tf.device(default_device):
with g.as_default():
fake_image_logits = build_discriminator(fake_images, reuse=True, is_training=TRAINING, dropout_rate=0.3, reg=0.2)
Loss functions¶
We can now define our loss functions. Note that we have to define the loss function for the generator and discriminator seperately:
with tf.device(default_device):
# Build the loss functions:
with g.as_default():
with tf.name_scope("cross_entropy") as scope:
# Be careful with the loss functions. The sigmoid activation is already applied as the
# last step of the discriminator network above. If you want to use something like
# tf.nn.sigmoid_cross_entropy_with_loss, it *will not train* because it applies
# a sigmoid a second time.
d_loss_total = -tf.reduce_mean(tf.log(real_image_logits) + tf.log(1. - fake_image_logits))
# This is the adverserial step: g_loss tries to optimize fake_logits to one,
# While d_loss_fake tries to optimize fake_logits to zero.
g_loss = -tf.reduce_mean(tf.log(fake_image_logits))
# This code is useful if you'll use tensorboard to monitor training:
# d_loss_summary = tf.summary.scalar("Discriminator_Real_Loss", d_loss_real)
# d_loss_summary = tf.summary.scalar("Discriminator_Fake_Loss", d_loss_fake)
d_loss_summary = tf.summary.scalar("Discriminator_Total_Loss", d_loss_total)
d_loss_summary = tf.summary.scalar("Generator_Loss", g_loss)
It's also useful to compute accuracy, just to see how the training is going:
with tf.device(default_device):
with g.as_default():
with tf.name_scope("accuracy") as scope:
# Compute the discriminator accuracy on real data, fake data, and total:
accuracy_real = tf.reduce_mean(tf.cast(tf.equal(tf.round(real_image_logits),
tf.ones_like(real_image_logits)),
tf.float32))
accuracy_fake = tf.reduce_mean(tf.cast(tf.equal(tf.round(fake_image_logits),
tf.zeros_like(fake_image_logits)),
tf.float32))
total_accuracy = 0.5*(accuracy_fake + accuracy_real)
# Again, useful for tensorboard:
acc_real_summary = tf.summary.scalar("Real_Accuracy", accuracy_real)
acc_real_summary = tf.summary.scalar("Fake_Accuracy", accuracy_fake)
acc_real_summary = tf.summary.scalar("Total_Accuracy", total_accuracy)
Independant Optimizers¶
To allow the generator and discriminator to compete and update seperately, we use two distinct optimizers. This step is why it was essential earlier to have the scopes different for the generator and optimizer: we can select all variables in each scope to go to their own optimizer. So, even though the generator loss calculation runs the discriminator, the update step for the generator only affects the variables inside the generator
with tf.device(default_device):
with g.as_default():
with tf.name_scope("training") as scope:
# Global steps are useful for restoring training:
global_step = tf.Variable(0, dtype=tf.int32, trainable=False, name='global_step')
# Make sure the optimizers are only operating on their own variables:
all_variables = tf.trainable_variables()
discriminator_vars = [v for v in all_variables if v.name.startswith('mnist_discriminator/')]
generator_vars = [v for v in all_variables if v.name.startswith('mnist_generator/')]
discriminator_optimizer = tf.train.AdamOptimizer(BASE_LEARNING_RATE, 0.5).minimize(
d_loss_total, global_step=global_step, var_list=discriminator_vars)
generator_optimizer = tf.train.AdamOptimizer(BASE_LEARNING_RATE, 0.5).minimize(
g_loss, global_step=global_step, var_list=generator_vars)
Image snapshots¶
It's useful to snapshot images into tensorboard to see how things are going, as well:
with tf.device(default_device):
with g.as_default():
# Reshape images for snapshotting:
fake_images_reshaped = tf.reshape(fake_images, (-1, 28, 28, 1))
real_images_reshaped = tf.reshape(real_images, (-1, 28, 28, 1))
tf.summary.image('fake_images', fake_images_reshaped, max_outputs=4)
tf.summary.image('real_images', real_images_reshaped, max_outputs=4)
Training the networks¶
There are lots of philosophys on training GANs. Here, we'll do something simple and just alternate updates. To save the network and keep track of training variables, set up a summary writer:
with tf.device(default_device):
with g.as_default():
merged_summary = tf.summary.merge_all()
# Set up a saver:
train_writer = tf.summary.FileWriter(LOGDIR)
Before we start training in earnest, let's make some storage for images as a function of epochs, etc. This network will also store loss and accuracy as a function of epoch so we can make some plots after training is done.
epochs = [] # store the epoch corresponding to the variables below
gen_loss = []
dis_loss = []
images = []
true_acc = []
fake_acc = []
tot_acc = []
Set up a session for training using an interactive session:
with tf.device(default_device):
with g.as_default():
sess = tf.InteractiveSession()
if not RESTORE:
sess.run(tf.global_variables_initializer())
train_writer.add_graph(sess.graph)
saver = tf.train.Saver()
else:
latest_checkpoint = tf.train.latest_checkpoint(LOGDIR+"/checkpoints/")
print "Restoring model from {}".format(latest_checkpoint)
saver = tf.train.Saver()
saver.restore(sess, latest_checkpoint)
print "Begin training ..."
# Run training loop
for i in xrange(50000000):
step = sess.run(global_step)
# Receive data (this will hang if IO thread is still running = this
# will wait for thread to finish & receive data)
epoch = (1.0*i*BATCH_SIZE) / 60000.
if (epoch > MAX_EPOCH):
break
sigma = max(0.75*(10. - epoch) / (10), 0.05)
# Update the generator:
# Prepare the input to the networks:
fake_input = numpy.random.normal(loc=0, scale=1, size=(BATCH_SIZE, RANDOM_INPUT_DIMENSIONALITY))
real_data, label = mnist.train.next_batch(BATCH_SIZE)
real_data = 2*(real_data - 0.5)
if INCLUDE_NOISE:
real_noise_addition = numpy.random.normal(scale=sigma,size=(BATCH_SIZE,28*28))
fake_noise_addition = numpy.random.normal(scale=sigma,size=(BATCH_SIZE,28*28))
else:
real_noise_addition = numpy.zeros((BATCH_SIZE, 28*28))
fake_noise_addition = numpy.zeros((BATCH_SIZE, 28*28))
# Update the discriminator:
[generated_mnist, _] = sess.run([fake_images,
discriminator_optimizer],
feed_dict = {noise_tensor : fake_input,
real_flat : real_data,
real_noise: real_noise_addition,
fake_noise: fake_noise_addition})
# Update the generator:
fake_input = numpy.random.normal(loc=0, scale=1, size=(BATCH_SIZE, RANDOM_INPUT_DIMENSIONALITY))
if INCLUDE_NOISE:
fake_noise_addition = numpy.random.normal(scale=sigma,size=(BATCH_SIZE,28*28))
else:
fake_noise_addition = numpy.zeros((BATCH_SIZE, 28*28))
[ _ ] = sess.run([generator_optimizer],
feed_dict = {noise_tensor: fake_input,
real_flat : real_data,
real_noise: real_noise_addition,
fake_noise: fake_noise_addition})
# Run a summary step:
[summary, g_l, d_l, acc_fake, acc_real, acc] = sess.run(
[merged_summary, g_loss, d_loss_total, accuracy_fake, accuracy_real, total_accuracy],
feed_dict = {noise_tensor : fake_input,
real_flat : real_data,
real_noise: real_noise_addition,
fake_noise: fake_noise_addition})
train_writer.add_summary(summary, step)
if step != 0 and step % 500 == 0:
saver.save(
sess,
LOGDIR+"/checkpoints/save",
global_step=step)
# train_writer.add_summary(summary, i)
# sys.stdout.write('Training in progress @ step %d\n' % (step))
if i != 0 and int(10*epoch) == 10*epoch:
if int(epoch) == epoch:
print 'Training in progress @ epoch %g, g_loss %g, d_loss %g accuracy %g' % (epoch, g_l, d_l, acc)
epochs.append(epoch)
gen_loss.append(g_l)
dis_loss.append(d_l)
images.append(generated_mnist)
true_acc.append(acc_real)
fake_acc.append(acc_fake)
tot_acc.append(acc)
[NOTE: I cleared the output of the training to make the notebook easier to read online. It trained for about 350 epochs, which is quite awhile. It turned in to several hours on a GPU.]
Plotting training variables¶
To confirm the training went well, we can look at the variables we saved:
# Plot the loss values:
fig = plt.figure(figsize=(16,9))
plt.plot(epochs, gen_loss, label="Generator Loss", lw=2)
plt.plot(epochs, dis_loss, label="Discriminator Loss", lw=2)
plt.grid(True)
plt.xlabel("Epoch", fontsize=20)
plt.ylabel("Loss", fontsize=20)
plt.legend(fontsize=20, loc='best')
plt.show()
# Plot the accuracy values:
fig = plt.figure(figsize=(16,9))
plt.plot(epochs, true_acc, label="True Accuracy", lw=1)
plt.plot(epochs, fake_acc, label="Fake Accuracy", lw=1)
plt.plot(epochs, tot_acc, label="Total Accuracy", lw=1)
plt.grid(True)
plt.xlabel("Epoch", fontsize=20)
plt.ylabel("Accuracy", fontsize=20)
plt.legend(fontsize=20, loc='best')
plt.show()
The loss and accuracy graphs indicate the training went pretty well, Over time, the generator got better at tricking the discriminator (you can see the generator loss decreasing and discriminator loss increasing). Additionally, the accuracy trended towards 50% for both real and fake data. In badly trained examples, the average accuracy might be 50% but the individual accuracys (fake or real) are 0 or 100%, indicating the network isn't learning well.
Image Progression¶
We can see the images progress over time. I'll show the progression over the epochs, and we can see a large sample images below that are generated from the network as it's read back at inference time.
indexes = range(len(epochs))[::20]
image_array = numpy.zeros((28*len(indexes), 5*28))
for i, e in enumerate(indexes):
image_set = images[e]
for j in xrange(5):
index = numpy.random.randint(len(image_set))
image_array[i*28:(i+1)*28, j*28:(j+1)*28].shape
image_array[i*28:(i+1)*28, j*28:(j+1)*28] = image_set[index].reshape(28,28)
fig = plt.figure(figsize=(20,20))
plt.imshow(image_array, cmap="Greys", interpolation="none")
plt.show()
In the above, we can see the epochs progressing (downward) and the images improving from noise to recognizable digits.
As a last step, let's load this network back into memory and generate a few fake images for visualization. As you'll see, this network does "OK" but not amazingly well. In the next post, we'll see a deep convolutional network that does better at generating images.
tf.reset_default_graph()
with tf.device(default_device):
g = tf.Graph()
with g.as_default():
sess = tf.InteractiveSession()
latest_checkpoint = tf.train.latest_checkpoint(LOGDIR+"/checkpoints/")
print "Restoring model from {}".format(latest_checkpoint)
noise_tensor = tf.placeholder(tf.float32, [BATCH_SIZE, RANDOM_INPUT_DIMENSIONALITY], name="noise")
fake_noise = tf.placeholder(tf.float32, [BATCH_SIZE, 28*28], name="fake_noise")
fake_images = build_generator(noise_tensor) + fake_noise
saver = tf.train.Saver()
saver.restore(sess, latest_checkpoint)
# We only need to make fake data and run it through the 'fake_images' tensor to see the output:
fake_input = numpy.random.normal(loc=0, scale=1, size=(BATCH_SIZE, RANDOM_INPUT_DIMENSIONALITY))
fake_noise_addition = numpy.zeros((BATCH_SIZE, 28*28))
[generated_images] = sess.run(
[fake_images],
feed_dict = {noise_tensor : fake_input,
fake_noise : fake_noise_addition})
Reshape to make it easier to draw:
generated_images = numpy.reshape(generated_images, (-1, 28, 28))
# Tile together lots of digits to see how the network is doing:
final_image = numpy.zeros((280, 280))
for i in range(10):
for j in range(10):
index = numpy.random.randint(BATCH_SIZE)
final_image[i*28:(i+1)*28, j*28:(j+1)*28] = generated_images[index].reshape(28, 28)
fig = plt.figure(figsize=(10,10))
plt.imshow(final_image, cmap="Greys", interpolation="none")
plt.show()
Well ... It's OK. Some of them look like real digits! Others are less convincing. But, this at least demonstrates the basics of generative adversarial networks.


“WHEN PEOPLE ASK ME IF I WENT TO FILM SCHOOL I TELL THEM, ‘NO, I WENT TO FILMS’.”
- Quentin Tarantino
Explore the movies
Movies
Developers:
Live Melkild Anne Skjærseth Elise Almestad


|
| Local Properties | ||
| Managed Object Types | Data Object Types | All Properties | All Methods |
Properties
| Name | Type | Description |
|---|---|---|
| applicable | xsd:boolean |
Whether or not this update is applicable to this host. An update
may not be applicable to the ESX host for many reasons--for
example, it is obsolete, it conflicts with other installed
patches or libraries, and so on. The reason shows some of the reasons
why the update is not applicable.
An update could be inapplicable with no reason listed. This is
because the prerequisite install state is not correct. For example,
update A is one of the prerequisites of update B. B not only
requires A to be installed, but also requires the host is
rebooted after A is installed. When A is installed and the host
has not been restarted after the installation, B will not be
applicable. In such a case, the scan on both updates A and B
would yield a whole picture of the update applicable status.
|
| id | xsd:string |
Unique identifier for this update.
|
| installed | xsd:boolean |
Whether the update is installed on the server.
|
| installState* | xsd:string[] |
The installation state of the update. Unset if the update is not
installed on the server. See HostPatchManagerInstallState |
| integrity* | xsd:string |
The integrity status of the update's metadata. The value would
be unset if the integrity status is unknown to the server. See HostPatchManagerIntegrityStatus |
| prerequisitePatch* | HostPatchManagerStatusPrerequisitePatch[] |
Prerequisite update.
|
| reason* | xsd:string[] |
Possible reasons why an update is not applicable to the ESX host. See HostPatchManagerReason |
| reconnectRequired | xsd:boolean |
Whether or not this update requires caller to reconnect to the
host. This is usually because the update is on the agent that
running on the host, the agent would thus be restarted when the
update is applied. Caller can reconnect (and possibly relogin) to
the host after the agent has been restarted.
|
| restartRequired | xsd:boolean |
Whether or not this update requires a host restart to take effect.
|
| supersededPatchIds* | xsd:string[] |
Patches that are superseded by this update.
|
| vmOffRequired | xsd:boolean |
Whether or not this update requires the host in maintenance mode.
|
| Properties inherited from DynamicData | ||
| None |
| Top of page | Local Properties | ||
| Managed Object Types | Data Object Types | All Properties | All Methods |


Language Myth 2
“Some languages are just not good enough“
By Ray Harlow
“In the view of some people, some languages are just not good enough.
Not only do they not act as languages of science, of international communication,
of high literature, they are inherently inferior and could not be used in these ways.”
(Page 9)[1]
This myth is about how some minority languages are “just not good enough”.
This would mean a language would not have the potential to talk about newer technical topics,
as it does not have any words that would have the same meaning in any other language.
”This sort of opinion can be seen particularly strikingly in societies where a minority language is spoken
alongside a major language.”(page 10)[1]
The oversight made in this argument is that languages can and very much have already evolved
quite a bit.
English, for example did not have technical terms hundreds of years ago,
the language has evolved to make place for these new additions to the language.
Some words in the English language are even borrowed from other languages,
and this can also be done by minority languages to allow them to constantly evolve.
From digging deeper in this particular myth,
I can also see that when someone says that some languages are not good enough,
it actually just means that they have preferred languages (or just one) because they are easy to learn
or already used/ taught in a lot of countries.
So, that would give us an answer to the question: “
Not good enough for what?”
The main answer would either be: “Not good enough to be easily picked up.”

In my opinion, no language is ever “not good enough”.
All languages have the potential to evolve and to fit whatever situation they may be used in.
I think that If you really want to decide if a language is or isn’t good enough,
then you should at least be fluent in it first.


{% extends "base.html" %}
{% block body_class %}index{% endblock %}
{% block content %}
{{ render_markdown(
"""
# Mailing List
Sign up for our mailing list to get notifications whenever the dataset is
updated. To subscribe, send an email to
[list<EMAIL_ADDRESS>with a blank
message body and the following subject line:
subscribe tomcat-dataset-updates
(replace `` and `` with your own first name and last name).
""")
}}
{% endblock %}


IntersectionExplorer - Exploring IUI 2016 Papers with Intersecting Sets
Sign in
Fill out a questionnaire, please!
How to Use
Select from...
Selected papers


ping6 host- Ping a host only a specific number of times:
ping6 -c count host- Ping a host, specifying the interval in seconds between requests (default is 1 second):
ping6 -i seconds host- Ping a host without trying to lookup symbolic names for addresses:
ping6 -n host- Ping a host and ring the bell when a packet is received (if your terminal supports it):
ping6 -a host


[%EmailHeader%]
[%EmailBody%]
Applicant Name
[%TenantName%]
Applicant Address
[%TenantAddress%]
Property Name
[%PropertyName%]
Unit Name
[%UnitName%]
Deposit
[%Deposit%]
Monthly Rent
[%MonthlyRent%]
[%LeaseDate%]
[%EmailFooter%]


Defines that the output y is the derivative of the input u. Note, that Modelica.Blocks.Continuous.Derivative computes the derivative in an approximate sense, where as this block computes the derivative exactly. This requires that the input u is differentiated by the Modelica translator, if this derivative is not yet present in the model.