Safe init using failable guarded initializer
The separation into a non-failable and a failable init method is 
fine.

The forced casts with as! are safe in your code, because it is verified before
that the three variables id, displayName, number have the
respective types Number, String and NSNumber.

However: 


The code is error-prone: Changes to the types must be done at two places.
It is not immediately obvious that it works correctly.


Forced casts should (and can!) be avoided in most cases, in the
same way as forced unwrappings. The program would be terminated
immediately if the cast fails. 

In your code that is quite easy,
by replacing the type checks is T by  conditional casts as? T.
The latter return a value of the type T and that makes the forced
cast unnecessary. In addition, it simplifies and shortens the code
of  the failable init method:

init?(dictionary: NSDictionary) {

    guard let id = dictionary["id"] as? NSNumber else {
        return nil
    }
    guard let displayName = dictionary["display_name"] as? String else {
        return nil
    }
    guard let amount = dictionary["amount"] as? NSNumber else {
        return nil
    }
    self.init(id: id, displayName: displayName, amount: amount)
}


As a further simplification, combine the optional bindings into
a single guard statement (attribution goes to @Knight0fDragon who
reminded my in a comment):

init?(dictionary: NSDictionary) {
    guard
        let id = dictionary["id"] as? NSNumber,
        let displayName = dictionary["display_name"] as? String,
        let amount = dictionary["amount"] as? NSNumber else {
            return nil
    }
    self.init(id: id, displayName: displayName, amount: amount)
}


Some other points:


Your spacing is not consistent.
The indenting is totally wrong.
The correct spelling is dictionary.