小编Nip*_*tra的帖子

Python,NumPy和R都使用相同的算法(Mersenne Twister)来生成随机数序列.因此,从理论上讲,设置相同的种子应该在所有3中产生相同的随机数序列.事实并非如此.我认为3个实现使用不同的参数导致这种行为.

R
>set.seed(1)
>runif(5)
[1] 0.2655087 0.3721239 0.5728534 0.9082078 0.2016819

Python
In [3]: random.seed(1)

In [4]: [random.random() for x in range(5)]
Out[4]: 
[0.13436424411240122,
 0.8474337369372327,
 0.763774618976614,
 0.2550690257394217,
 0.49543508709194095]

NumPy
In [23]: import numpy as np

In [24]: np.random.seed(1)
In [25]: np.random.rand(5)
Out[25]: 
array([  4.17022005e-01,   7.20324493e-01,   1.14374817e-04,
         3.02332573e-01,   1.46755891e-01])

有没有办法,NumPy和Python实现可以产生相同的随机数序列？正如一些评论和答案指出的那样,可以使用rpy.我特别想要的是微调Python和NumPy中相应调用中的参数以获得序列.

背景:关注来自使用R的EDX课程.在其中一个论坛中,有人询问是否可以使用Python,并且工作人员回答说某些任务需要设置特定种子并提交答案.

有关:

1. 比较使用随机数生成的Matlab和Numpy代码从这看起来,底层的NumPy和Matlab实现是相似的.
2. python vs octave random generator:这个问题确实非常接近预期的答案.需要在默认状态生成器周围使用某种包装器.

来自Python的列表背景和C++/Java等编程语言的背景,一个用于使用a[i][j]方法提取元素的符号.但是NumPy,人们通常会这样做a[i,j].这两个都会返回相同的结果.

这两者之间的根本区别是什么？应该首选哪些？

我正在尝试创建一个简单的加权损失函数.

比方说,我的输入尺寸为100*5,输出尺寸也为100*5.我也有一个相同尺寸的重量矩阵.

类似于以下内容:

import numpy as np
train_X = np.random.randn(100, 5)
train_Y = np.random.randn(100, 5)*0.01 + train_X

weights = np.random.randn(*train_X.shape)

定义自定义丢失功能

def custom_loss_1(y_true, y_pred):
    return K.mean(K.abs(y_true-y_pred)*weights)

定义模型

from keras.layers import Dense, Input
from keras import Model
import keras.backend as K

input_layer = Input(shape=(5,))
out = Dense(5)(input_layer)
model = Model(input_layer, out)

使用现有指标进行测试工作正常

model.compile('adam','mean_absolute_error')
model.fit(train_X, train_Y, epochs=1)

使用我们的自定义丢失功能进行测试不起作用

model.compile('adam',custom_loss_1)
model.fit(train_X, train_Y, epochs=10)

它给出了以下堆栈跟踪:

InvalidArgumentError (see above for traceback): Incompatible shapes: [32,5] vs. [100,5]
 [[Node: loss_9/dense_8_loss/mul = Mul[T=DT_FLOAT, _device="/job:localhost/replica:0/task:0/device:CPU:0"](loss_9/dense_8_loss/Abs, loss_9/dense_8_loss/mul/y)]]

32号来自哪里？

使用权重测试损失函数作为Keras张量

def …

我有以下代码,适当地转换为cython:

from numpy import *

## returns winning players or [] if undecided. 
def score(board):
    scores = []
    checked = zeros(board.shape)
    for i in xrange(len(board)):
        for j in xrange(len(board)):
            if checked[i,j] == 0 and board[i,j] !=0:
                ... do stuf

我尝试转换为cython:

import numpy as np
cimport numpy as np

@cython.boundscheck(False)
@cython.wraparound(False)
@cython.nonecheck(False)

## returns winning players or [] if undecided. 
def score(np.ndarray[int, ndim=2] board):
    scores = []
    cdef np.ndarray[int, ndim = 2 ] checked
    checked = np.zeros(board.shape)
    for i in xrange(len(board)): …

我的申请涉及处理以下形式的数据(包含在CSV中):

Epoch (number of seconds since Jan 1, 1970), Value
1368431149,20.3
1368431150,21.4
..

目前我使用numpy loadtxt方法读取CSV(可以很容易地使用来自Pandas的read_csv).目前我的系列我正在转换时间戳字段如下:

timestamp_date=[datetime.datetime.fromtimestamp(timestamp_column[i]) for i in range(len(timestamp_column))]

我通过将timestamp_date设置为我的DataFrame的Datetime索引来实现此目的.我尝试在几个地方搜索,看看是否有更快(内置)的方式使用这些Unix纪元时间戳,但找不到任何.许多应用程序都使用这种时间戳术语.

1. 是否有内置方法来处理此类时间戳格式？
2. 如果没有,推荐的处理这些格式的方法是什么？

一些方法可以做到这一点:

1. 阅读整个CSV然后使用 df.tail
2. 以某种方式反转文件(对于大文件最好的方法是什么？)然后使用nrows参数来读取
3. 以某种方式找到CSV中的行数,然后使用skiprows并读取所需的行数.
4. 也许做块读取丢弃初始块(虽然不知道这将如何工作)

可以用更简单的方式完成吗？如果不是,应该优先考虑这三者中的哪一个？为什么？

可能相关:

1. 有效地找到文本文件中的最后一行
2. 使用pandas read_csv和nrows读取~13000行CSV文件的部分内容

没有直接关系:

1. 如何获得最后一行pandas数据帧？

我创建了一个看起来像的情节

我有几个问题:

1. 我怎么能专门展示周末.我想到的一些方法是抓住对应周末的指数,然后在xlims之间绘制透明条.也可以绘制矩形.如果可以在熊猫中明白地完成它将是最好的.
2. 日期格式不是最漂亮的

以下是用于生成此图的代码

ax4=df4.plot(kind='bar',stacked=True,title='Mains 1 Breakdown');
ax4.set_ylabel('Power (W)');
idx_weekend=df4.index[df4.index.dayofweek>=5]
ax.bar(idx_weekend.to_datetime(),[1800 for x in range(10)])

这ax.bar是专门用于突出周末,但它不会产生任何可见的输出.(问题1)对于问题2,我尝试使用Major Formatter和Locators,代码如下:

ax4=df4.plot(kind='bar',stacked=True,title='Mains 1 Breakdown');
ax4.set_ylabel('Power (W)');
formatter=matplotlib.dates.DateFormatter('%d-%b');
locator=matplotlib.dates.DayLocator(interval=1);
ax4.xaxis.set_major_formatter(formatter);
ax4.xaxis.set_major_locator(locator);

产生的产出如下:

了解Dataframe的外观可能会有所帮助

In [122]:df4

Out[122]:
<class 'pandas.core.frame.DataFrame'>
DatetimeIndex: 36 entries, 2011-04-19 00:00:00 to 2011-05-24 00:00:00
Data columns:
(0 to 6 AM) Dawn          19  non-null values
(12 to 6 PM) Dusk         19  non-null values
(6 to 12 Noon) Morning    19  non-null values
(6PM to 12 Noon) Night    20  non-null values
dtypes: float64(4)

我正在尝试在Tensorflow中进行非常简单的优化 - 矩阵分解的问题.给定矩阵V (m X n),将其分解为W (m X r)和H (r X n).我从这里借用基于梯度下降的基于张量流的矩阵分解实现.

关于矩阵的详细信息V.在其原始形式中,条目的直方图如下:

要以[0,1]的比例输入条目,我执行以下预处理.

f(x) = f(x)-min(V)/(max(V)-min(V))

规范化后,数据的直方图如下所示:

我的问题是:

1. 鉴于数据的性质:0和1,大多数条目越接近0比1之间,这将是为最佳的初始化W和H？
2. 如何根据不同的成本函数来定义学习率: |A-WH|_F和|(A-WH)/A|？

最小的工作示例如下:

import tensorflow as tf
import numpy as np
import pandas as pd

V_df = pd.DataFrame([[3, 4, 5, 2],
               [4, 4, 3, 3],
               [5, 5, 4, 4]], dtype=np.float32).T

因此,V_df看起来像:

    0   1   2
0   3.0 4.0 5.0
1   4.0 4.0 5.0
2   5.0 3.0 …

我正在使用Matplotlib绘制时间序列数据,并且序列中缺少一些数据.Matplotlib隐式地将最后一个连续数据点连接到下一个连续数据点.但是如果数据丢失,情节看起来很难看.以下是获得的情节.

可以看出,在4月30日标记附近,数据丢失,Matplotlib加入点.以下图像是数据的散点图.散点图掩盖了此故障,但在这种情况下,连续的数据点将不会联合.此外,考虑到涉及大量数据点,散点图非常慢.

这些问题的推荐解决方案是什么？

为了学习Keras LSTM和RNN,我想创造一个简单的问题:给定一个正弦波,我们能预测它的频率吗？

考虑到时间概念在这里很重要,我不希望简单的神经网络能够预测频率.然而,即使使用LSTM,我也无法了解频率; 我能够学习一个微不足道的零作为估计的频率(即使是火车样本).

这是创建火车组的代码.

import numpy as np
import matplotlib.pyplot as plt

def create_sine(frequency):
    return np.sin(frequency*np.linspace(0, 2*np.pi, 2000))

train_x = np.array([create_sine(x) for x in range(1, 300)])
train_y = list(range(1, 300))

现在,这个例子是一个简单的神经网络.

from keras.models import Model
from keras.layers import Dense, Input, LSTM

input_series = Input(shape=(2000,),name='Input')
dense_1 = Dense(100)(input_series)
pred = Dense(1, activation='relu')(dense_1)
model = Model(input_series, pred)
model.compile('adam','mean_absolute_error')
model.fit(train_x[:100], train_y[:100], epochs=100)

正如所料,这个NN没有学到任何有用的东西.接下来,我尝试了一个简单的LSTM示例.

input_series = Input(shape=(2000,1),name='Input')
lstm = LSTM(100)(input_series)
pred = Dense(1, activation='relu')(lstm)
model = Model(input_series, pred)
model.compile('adam','mean_absolute_error')
model.fit(train_x[:100].reshape(100, 2000, 1), train_y[:100], …