Super Simple Keras Sentiment Analysis

by | Jul 15, 2017 | Uncategorized

from __future__ import print_function

from keras.preprocessing import sequence
from keras.models import Sequential
from keras.layers import Dense, Embedding
from keras.layers import LSTM
from keras.datasets import imdb

batch_size = 32
max_features = 20000
maxlen = 80  # cut texts after this number of words (among top max_features most common words)

(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=max_features)


X_train = sequence.pad_sequences(X_train, maxlen=maxlen)
X_test = sequence.pad_sequences(X_test, maxlen=maxlen)

model = Sequential()
model.add(Embedding(max_features, 128))
model.add(LSTM(128, dropout=0.2, recurrent_dropout=0.2))
model.add(Dense(1, activation='sigmoid'))

model.compile(loss='binary_crossentropy',optimizer='adam',metrics='accuracy')

model.fit(X_train, y_train, batch_size=batch_size, epochs=15, validation_data=(X_test, y_test))

score, acc = model.evaluate(X_test, y_test,batch_size=batch_size)

print('Test score:', score)
print('Test accuracy:', acc)

Super Simple Keras Regression problem

by | Jul 15, 2017 | Uncategorized


from keras.models import Sequential
from keras.layers.core import Dense, Activation
from keras.datasets import boston_housing

(X_train, y_train), (X_test, y_test) = boston_housing.load_data()

model = Sequential()
model.add(Dense(10, input_shape=(X_train.shape[1],)))
model.add(Dense(1))
model.compile(loss='mean_absolute_error', optimizer='rmsprop')

model.fit(X_train, y_train, epoch=20, batch_size=1, validation_data=(X_test, y_test))

score, acc = model.evaluate(X_test, y_test, batch_size=1)

print('Test score:', score)
print('Test accuracy:', acc)

for i in range(-1, -10, -1):
    print("Predicted price = {}, Actual price = {}".format(model.predict(X_test[i].reshape(1, 13))[0][0], y_test[i]))

Super Simple Keras LSTM time series predictions

by | Jul 15, 2017 | Uncategorized


# LSTM for international airline passengers problem with regression framing
import numpy
import matplotlib.pyplot as plt
from pandas import read_csv
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from sklearn.preprocessing import MinMaxScaler

numpy.random.seed(7)

# Configuarble time window, looks back 3 days to predict the next day
LOOK_BACK = 3


def load_dataset():
    df = read_csv(
        'https://raw.githubusercontent.com/lazyprogrammer/machine_learning_examples/master/airline/international-airline-passengers.csv',
        usecols=[1], engine='python', skipfooter=3)

    dataset = df.values
    dataset = dataset.astype('float32')
    # normalize the dataset
    scaler = MinMaxScaler(feature_range=(0, 1))
    dataset = scaler.fit_transform(dataset)
    return dataset, scaler


def create_timeseries(dataset, look_back=1):
    dataX, dataY = [], []
    for i in range(len(dataset) - look_back - 1):
        a = dataset[i:(i + look_back), 0]
        dataX.append(a)
        dataY.append(dataset[i + look_back, 0])
    return numpy.array(dataX), numpy.array(dataY)


def create_test_train(dataset):
    train_size = int(len(dataset) * 0.67)
    test_size = len(dataset) - train_size
    train, test = dataset[0:train_size, :], dataset[train_size:len(dataset), :]
    # reshape into X=t and Y=t+1

    trainX, trainY = create_timeseries(train, LOOK_BACK)
    testX, testY = create_timeseries(test, LOOK_BACK)
    # reshape input to be [samples, time steps, features]
    trainX = numpy.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
    testX = numpy.reshape(testX, (testX.shape[0], 1, testX.shape[1]))
    return trainX, testX, trainY, testY


def plot_predictions(dataset, trainPredict, trainY, testPredict, testY):
    trainPredictPlot = numpy.empty_like(dataset)
    trainPredictPlot[:, :] = numpy.nan
    trainPredictPlot[LOOK_BACK:len(trainPredict) + LOOK_BACK, :] = trainPredict
    # shift test predictions for plotting
    testPredictPlot = numpy.empty_like(dataset)
    testPredictPlot[:, :] = numpy.nan
    testPredictPlot[len(trainPredict) + (LOOK_BACK * 2) + 1:len(dataset) - 1, :] = testPredict
    # plot baseline and predictions
    plt.plot(scaler.inverse_transform(dataset))
    plt.plot(trainPredictPlot)
    plt.plot(testPredictPlot)
    plt.show()


dataset, scaler = load_dataset()
trainX, testX, trainY, testY = create_test_train(dataset)

# create and fit the LSTM network
model = Sequential()
model.add(LSTM(4, input_shape=(1, LOOK_BACK)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX, trainY, epochs=25, batch_size=1, verbose=2)

trainPredict = model.predict(trainX)
testPredict = model.predict(testX)

# undo the normalization we did earlier
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY])
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform([testY])

plot_predictions(dataset, trainPredict, trainY, testPredict, testY)