rollingstone

from keras.models import Sequential
from keras.layers.core import Permute
from keras.layers.convolutional import Convolution2D
from keras.layers.core import Activation
import theano
import theano.tensor as T
import datetime
import numpy as np

now = datetime.datetime.now

rollingstone

#Forward-backward algorithm implementation in Theano, 
#with example taken from Wikipedia: 
#http://en.wikipedia.org/wiki/Forward%E2%80%93backward_algorithm

import theano
import theano.tensor as T
import numpy as np

#Set up vectors, etc to represent 
#observations, indexes into the observation

rollingstone

import numpy as np
from scipy import linalg
from sklearn.utils import array2d, as_float_array
from sklearn.base import TransformerMixin, BaseEstimator


class ZCA(BaseEstimator, TransformerMixin):

    def __init__(self, regularization=10**-5, copy=False):
        self.regularization = regularization

rollingstone

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns # improves plot aesthetics

def _invert(x, limits):
    """inverts a value x on a scale from
    limits[0] to limits[1]"""
    return limits[1] - (x - limits[0])

def _scale_data(data, ranges):

rollingstone

from __future__ import print_function

import json
import os
import numpy as np

from gensim.models import Word2Vec
from gensim.utils import simple_preprocess
from keras.engine import Input
from keras.layers import Embedding, merge

rollingstone

"""
From: https://github.com/darius/sketchbook/blob/master/regex/integrated1.py

Integrate the right-to-left top-down operator-precedence parser with
the simplest terminating NFA code.
"""

def match(re, s): return run(prepare(re), s)

def run(states, s):

rollingstone

# -*- coding: utf-8 -*-
#
# Used like this:
#
# from repermute import ipermute
#
# for s in ipermute('[A-Z]\d'):
#    print s
#
# Almost all regular expression constructs are supported except for '*'

rollingstone

import json
import random
import string
from functools import partial

from sanic import Sanic

import aioredis
import asyncio
import websockets

rollingstone

// Computes the SHA-256 digest of a string with Web Crypto
// Source: https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest

function sha256(str) {
  // Get the string as arraybuffer.
  var buffer = new TextEncoder("utf-8").encode(str)
  return crypto.subtle.digest("SHA-256", buffer).then(function(hash) {
    return hex(hash)
  })
}

rollingstone

import argparse
import av
import logging
import time


def parse_options(preset, tune, crf, x264_params, x265_params):
    opts = {}
    if preset:
        opts['preset'] = preset