charlesreid1

#!/bin/bash
# 
# Download the Large-scale CelebFaces Attributes (CelebA) Dataset
# from their Google Drive link.
# 
# CelebA: http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html
# 
# Google Drive: https://drive.google.com/drive/folders/0B7EVK8r0v71pWEZsZE9oNnFzTm8

python3 get_drive_file.py 0B7EVK8r0v71pZjFTYXZWM3FlRnM celebA.zip

yang-song

import tensorflow as tf


def gradients(f, x, grad_ys=None):
    '''
    An easier way of computing gradients in tensorflow. The difference from tf.gradients is
        * If f is not connected with x in the graph, it will output 0s instead of Nones. This will be more meaningful
            for computing higher-order gradients.

        * The output will have the same shape and type as x. If x is a list, it will be a list. If x is a Tensor, it

t-ae

import torch
import torch.nn as nn
import torch.nn.init as init

class MinibatchDiscrimination(nn.Module):
    def __init__(self, in_features, out_features, kernel_dims, mean=False):
        super().__init__()
        self.in_features = in_features
        self.out_features = out_features
        self.kernel_dims = kernel_dims

brannondorsey

Image-to-Image Translation with Conditional Adversarial Networks

Notes from arXiv:1611.07004v1 [cs.CV] 21 Nov 2016

• Euclidean distance between predicted and ground truth pixels is not a good method of judging similarity because it yields blurry images.
• GANs learn a loss function rather than using an existing one.
• GANs learn a loss that tries to classify if the output image is real or fake, while simultaneously training a generative model to minimize this loss.
• Conditional GANs (cGANs) learn a mapping from observed image x and random noise vector z to y: y = f(x, z)
• The generator G is trained to produce outputs that cannot be distinguished from "real" images by an adversarially trained discrimintor, D which is trained to do as well as possible at detecting the generator's "fakes".
• The discriminator D, learns to classify between real and synthesized pairs. The generator learns to fool the discriminator.
• Unlike an unconditional GAN, both th

sfujiwara

# -*- coding: utf-8 -*-

import numpy as np
from scipy.sparse.linalg import cg
import tensorflow as tf
import time


def conjugate_grad(A, b, x=None):
    """

neosatrapahereje

from collections import OrderedDict
import numpy as np
import theano
import theano.tensor as T
from theano.ifelse import ifelse


def cg(loss, params, x0=None, max_iters=100, precondition=None, tol=1e-3,
       conv_crit='cg'):
    """(Preconditioned) Conjugate Gradient (CG) updates

Vestride

Encoding Video

Installing

Install FFmpeg with homebrew. You'll need to install it with a couple flags for webm and the AAC audio codec.

brew install ffmpeg --with-libvpx --with-libvorbis --with-fdk-aac --with-opus

karpathy

"""
This is a batched LSTM forward and backward pass
"""
import numpy as np
import code

class LSTM:
  
  @staticmethod
  def init(input_size, hidden_size, fancy_forget_bias_init = 3):

paulirish

/* bling.js */

window.$ = document.querySelectorAll.bind(document);

Node.prototype.on = window.on = function (name, fn) {
  this.addEventListener(name, fn);
}

NodeList.prototype.__proto__ = Array.prototype;

GaelVaroquaux

'''
Non-parametric computation of entropy and mutual-information

Adapted by G Varoquaux for code created by R Brette, itself
from several papers (see in the code).

This code is maintained at https://github.com/mutualinfo/mutual_info 
Please download the latest code there, to have improvements and 
bug fixes.