+# Release 1.5.0
+
+## Breaking Changes
+* Prebuilt binaries are now built against CUDA 9 and cuDNN 7.
+* Our Linux binaries are built using ubuntu 16 containers, potentially
+ introducing glibc incompatibility issues with ubuntu 14.
+* Starting from 1.6 release, our prebuilt binaries will use AVX instructions.
+ This may break TF on older CPUs.
+
+## Major Features And Improvements
+* [Eager execution](https://github.com/tensorflow/tensorflow/tree/r1.5/tensorflow/contrib/eager)
+ preview version is now available.
+* [TensorFlow Lite](https://github.com/tensorflow/tensorflow/tree/r1.5/tensorflow/contrib/lite)
+ dev preview is now available.
+* CUDA 9 and cuDNN 7 support.
+
+## Bug Fixes and Other Changes
+* `auto_correlation` added to `tf.contrib.distributions`.
+* Add `DenseFlipout` probabilistic layer.
+* Restandardize `DenseVariational` as simpler template for other probabilistic layers.
+* Make `tf.contrib.distributions` QuadratureCompound classes support batch.
+* `Stream::BlockHostUntilDone` now returns Status rather than bool.
+* Customize request timeouts for the GCS filesystem.
+
+## Thanks to our Contributors
+
+This release contains contributions from many people at Google, as well as:
+
+4d55397500, Abdullah Alrasheed, abenmao, Adam Salvail, Aditya Dhulipala, Ag Ramesh,
+Akimasa Kimura, Alan Du, Alan Yee, Alexander, Amit Kushwaha, Amy, Andrei Costinescu,
+Andrei Nigmatulin, Andrew Erlichson, Andrew Myers, Andrew Stepanov, Androbin, AngryPowman,
+Anish Shah, Anton Daitche, Artsiom Chapialiou, asdf2014, Aseem Raj Baranwal, Ash Hall,
+Bart Kiers, Batchu Venkat Vishal, ben, Ben Barsdell, Bill Piel, Carl Thomé, Catalin Voss,
+Changming Sun, Chengzhi Chen, Chi Zeng, Chris Antaki, Chris Donahue, Chris Oelmueller,
+Chris Tava, Clayne Robison, Codrut, Courtial Florian, Dalmo Cirne, Dan J, Darren Garvey,
+David Kristoffersson, David Norman, David RöThlisberger, DavidNorman, Dhruv, DimanNe,
+Dorokhov, Duncan Mac-Vicar P, EdwardDixon, EMCP, error.d, FAIJUL, Fan Xia,
+Francois Xavier, Fred Reiss, Freedom" Koan-Sin Tan, Fritz Obermeyer, Gao, Xiang,
+Guenther Schmuelling, Guo Yejun (郭叶军), Hans Gaiser, HectorSVC, Hyungsuk Yoon,
+James Pruegsanusak, Jay Young, Jean Wanka, Jeff Carpenter, Jeremy Rutman, Jeroen BéDorf,
+Jett Jones, Jimmy Jia, jinghuangintel, jinze1994, JKurland, Joel Hestness, joetoth,
+John B Nelson, John Impallomeni, John Lawson, Jonas, Jonathan Dekhtiar, joshkyh, Jun Luan,
+Jun Mei, Kai Sasaki, Karl Lessard, karl@kubx.ca, Kb Sriram, Kenichi Ueno, Kevin Slagle,
+Kongsea, Lakshay Garg, lhlmgr, Lin Min, liu.guangcong, Loki Der Quaeler, Louie Helm,
+lucasmoura, Luke Iwanski, Lyndon White, Mahmoud Abuzaina, Marcel Puyat, Mark Aaron Shirley,
+Michele Colombo, MtDersvan, Namrata-Ibm, Nathan Luehr, Naurril, Nayana Thorat, Nicolas Lopez,
+Niranjan Hasabnis, Nolan Liu, Nouce, Oliver Hennigh, osdamv, Patrik Erdes,
+Patryk Chrabaszcz, Pavel Christof, Penghao Cen, postBG, Qingqing Cao, Qingying Chen, qjivy,
+Raphael, Rasmi, raymondxyang, Renze Yu, resec, Roffel, Ruben Vereecken, Ryohei Kuroki,
+sandipmgiri, Santiago Castro, Scott Kirkland, Sean Vig, Sebastian Raschka, Sebastian Weiss,
+Sergey Kolesnikov, Sergii Khomenko, Shahid, Shivam Kotwalia, Stuart Berg, Sumit Gouthaman,
+superzerg, Sven Mayer, tetris, Ti Zhou, Tiago Freitas Pereira, Tian Jin, Tomoaki Oiki,
+Vaibhav Sood, vfdev, Vivek Rane, Vladimir Moskva, wangqr, Weber Xie, Will Frey,
+Yan Facai (颜发才), yanivbl6, Yaroslav Bulatov, Yixing Lao, Yong Tang, youkaichao,
+Yuan (Terry) Tang, Yue Zhang, Yuxin Wu, Ziming Dong, ZxYuan, 黄璞
+
+We are also grateful to all who filed issues or helped resolve them, asked and
+answered questions, and were part of inspiring discussions.
+
+# Release 1.4.1
+
+## Bug Fixes and Other Changes
+* `LinearClassifier` fix for the Google Cloud Machine Learning Engine.
+
# Release 1.4.0
## Major Features And Improvements
Returns:
boolean value of the variable.
+
+ Raises:
+ UserInputError: if an environment variable is set, but it cannot be
+ interpreted as a boolean indicator, assume that the user has made a
+ scripting error, and will continue to provide invalid input.
+ Raise the error to avoid infinitely looping.
"""
if not question:
question = 'Do you wish to build TensorFlow with %s support?' % query_item
question += ' [y/N]: '
var = environ_cp.get(var_name)
+ if var is not None:
+ var_content = var.strip().lower()
+ true_strings = ('1', 't', 'true', 'y', 'yes')
+ false_strings = ('0', 'f', 'false', 'n', 'no')
+ if var_content in true_strings:
+ var = True
+ elif var_content in false_strings:
+ var = False
+ else:
+ raise UserInputError(
+ 'Environment variable %s must be set as a boolean indicator.\n'
+ 'The following are accepted as TRUE : %s.\n'
+ 'The following are accepted as FALSE: %s.\n'
+ 'Current value is %s.' % (
+ var_name, ', '.join(true_strings), ', '.join(false_strings),
+ var))
+
while var is None:
user_input_origin = get_input(question)
user_input = user_input_origin.strip().lower()
Raises:
UserInputError: if a query has been attempted n_ask_attempts times without
- success, assume that the user has made a scripting error, and will continue
- to provide invalid input. Raise the error to avoid infinitely looping.
+ success, assume that the user has made a scripting error, and will
+ continue to provide invalid input. Raise the error to avoid infinitely
+ looping.
"""
default = environ_cp.get(var_name) or var_default
full_query = '%s [Default is %s]: ' % (
def set_trisycl_include_dir(environ_cp):
"""Set TRISYCL_INCLUDE_DIR."""
+
ask_trisycl_include_dir = ('Please specify the location of the triSYCL '
'include directory. (Use --config=sycl_trisycl '
'when building with Bazel) '
'[Default is %s]: '
) % (_DEFAULT_TRISYCL_INCLUDE_DIR)
+
while True:
trisycl_include_dir = get_from_env_or_user_or_default(
environ_cp, 'TRISYCL_INCLUDE_DIR', ask_trisycl_include_dir,
py_library(
name = "dataset_serialization_test",
- testonly = 1,
srcs = [
"dataset_serialization_test_base.py",
],
For those familiar with TensorFlow graphs, notice the absence of
`tf.Session`. The `forward()` method here immediately executes and
returns output values. The `loss()` method immediately compares the
- output of `forward()` with the target adn returns the MSE loss value.
+ output of `forward()` with the target and returns the MSE loss value.
The `fit()` performs gradient-descent training on the model's weights
and bias.
"""
"""MNIST Network.
Network structure is equivalent to:
- https://github.com/tensorflow/tensorflow/blob/r1.4/tensorflow/examples/tutorials/mnist/mnist_deep.py
+ https://github.com/tensorflow/tensorflow/blob/r1.5/tensorflow/examples/tutorials/mnist/mnist_deep.py
and
https://github.com/tensorflow/models/blob/master/tutorials/image/mnist/convolutional.py
std::vector<T> out_values;
std::vector<std::pair<int64, int64>> out_indices;
for (int i = 0; i < input_flat.size(); ++i) {
- std::vector<string> entries =
- str_util::Split(input_flat(i), " ", str_util::SkipEmpty());
- OP_REQUIRES(ctx, !entries.empty(),
- errors::InvalidArgument("No entries found for input[", i,
+ StringPiece line(input_flat(i));
+ str_util::RemoveWhitespaceContext(&line);
+
+ StringPiece piece;
+ OP_REQUIRES(ctx, str_util::ConsumeNonWhitespace(&line, &piece),
+ errors::InvalidArgument("No label found for input[", i,
"]: \"", input_flat(i), "\""));
+
Tlabel label_value;
- OP_REQUIRES(
- ctx, strings::SafeStringToNumeric<Tlabel>(entries[0], &label_value),
- errors::InvalidArgument("Label format incorrect: ", entries[0]));
+ OP_REQUIRES(ctx,
+ strings::SafeStringToNumeric<Tlabel>(piece, &label_value),
+ errors::InvalidArgument("Label format incorrect: ", piece));
+
label(i) = label_value;
- for (int j = 1; j < entries.size(); j++) {
- std::vector<string> pair = str_util::Split(entries[j], ":");
- OP_REQUIRES(
- ctx, (pair.size() == 2),
- errors::InvalidArgument("Invalid feature \"", entries[j], "\""));
+
+ str_util::RemoveLeadingWhitespace(&line);
+ while (str_util::ConsumeNonWhitespace(&line, &piece)) {
+ size_t p = piece.find(':');
+ OP_REQUIRES(ctx, (p != StringPiece::npos),
+ errors::InvalidArgument("Invalid feature \"", piece, "\""));
+
int64 feature_index;
OP_REQUIRES(
- ctx, strings::safe_strto64(pair[0].c_str(), &feature_index),
- errors::InvalidArgument("Feature format incorrect: ", entries[j]));
+ ctx, strings::safe_strto64(piece.substr(0, p), &feature_index),
+ errors::InvalidArgument("Feature format incorrect: ", piece));
OP_REQUIRES(ctx, (feature_index >= 0),
errors::InvalidArgument(
"Feature index should be >= 0, got ", feature_index));
+
T feature_value;
OP_REQUIRES(
- ctx, strings::SafeStringToNumeric<T>(pair[1], &feature_value),
- errors::InvalidArgument("Feature format incorrect: ", entries[j]));
+
+ ctx,
+ strings::SafeStringToNumeric<T>(piece.substr(p + 1),
+ &feature_value),
+ errors::InvalidArgument("Feature format incorrect: ", piece));
+
out_values.emplace_back(feature_value);
out_indices.emplace_back(std::pair<int64, int64>(i, feature_index));
+
+ str_util::RemoveLeadingWhitespace(&line);
}
}
#### Optimization
+The `build_all_ios.sh` script can take optional command-line arguments to
+selectively register only for the operators used in your graph.
+
+```bash
+tensorflow/contrib/makefile/build_all_ios.sh -a arm64 -g $HOME/graphs/inception/tensorflow_inception_graph.pb
+```
+Please note this is an aggresive optimization of the operators and the resulting library may not work with other graphs but will reduce the size of the final library.
+
The `compile_ios_tensorflow.sh` script can take optional command-line arguments.
The first argument will be passed as a C++ optimization flag and defaults to
debug mode. If you are concerned about performance or are working on a release
usage() {
echo "Usage: $(basename "$0") [-a:T]"
echo "-a [build_arch] build only for specified arch x86_64 [default=all]"
+ echo "-g [graph] optimize and selectively register ops only for this graph"
echo "-T only build tensorflow (dont download other deps etc)"
exit 1
}
-while getopts "a:T" opt_name; do
+DEFAULT_ARCH="i386 x86_64 armv7 armv7s arm64"
+while getopts "a:g:T" opt_name; do
case "$opt_name" in
a) BUILD_ARCH="${OPTARG}";;
+ g) OPTIMIZE_FOR_GRAPH="${OPTARG}";;
T) ONLY_MAKE_TENSORFLOW="true";;
*) usage;;
esac
# Make sure we're in the correct directory, at the root of the source tree.
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-cd ${SCRIPT_DIR}/../../../
+TOP_SRCDIR="${SCRIPT_DIR}/../../../"
+cd ${TOP_SRCDIR}
source "${SCRIPT_DIR}/build_helper.subr"
JOB_COUNT="${JOB_COUNT:-$(get_job_count)}"
export MACOSX_DEPLOYMENT_TARGET=$(sw_vers -productVersion)
fi
+PRNT_SLCTV_BIN="${TOP_SRCDIR}bazel-bin/tensorflow/python/tools/print_selective_registration_header"
+
+if [[ ! -z "${OPTIMIZE_FOR_GRAPH}" ]]; then
+ echo "Request to optimize for graph: ${OPTIMIZE_FOR_GRAPH}"
+ #Request to trim the OPs by selectively registering
+ if [ ! -f ${PRNT_SLCTV_BIN} ]; then
+ #Build bazel build tensorflow/python/tools:print_selective_registration_header
+ echo "${PRNT_SLCTV_BIN} not found. Trying to build it"
+ cd ${TOP_SRCDIR}
+ bazel build --copt="-DUSE_GEMM_FOR_CONV" tensorflow/python/tools:print_selective_registration_header
+ if [ ! -f ${PRNT_SLCTV_BIN} ]; then
+ echo "Building print_selective_registration_header failed"
+ echo "You may want to build TensorFlow with: "
+ echo "./configure"
+ echo "bazel build --copt="-DUSE_GEMM_FOR_CONV" tensorflow/python/tools:print_selective_registration_header"
+ echo "and then run this script again"
+ exit 1
+ fi
+ else
+ echo "${PRNT_SLCTV_BIN} found. Using it"
+ ${PRNT_SLCTV_BIN} --graphs=${OPTIMIZE_FOR_GRAPH} > ${TOP_SRCDIR}/tensorflow/core/framework/ops_to_register.h
+
+ fi
+
+fi
+
if [[ "${ONLY_MAKE_TENSORFLOW}" != "true" ]]; then
# Remove any old files first.
make -f tensorflow/contrib/makefile/Makefile clean
# Pull down the required versions of the frameworks we need.
tensorflow/contrib/makefile/download_dependencies.sh
- # Compile protobuf for the target iOS device architectures.
- tensorflow/contrib/makefile/compile_ios_protobuf.sh
+ if [[ -z "${BUILD_ARCH}" ]]; then
+ # Compile protobuf for the target iOS device architectures.
+ tensorflow/contrib/makefile/compile_ios_protobuf.sh -a ${DEFAULT_ARCH}
+ else
+ # Compile protobuf for the target iOS device architectures.
+ tensorflow/contrib/makefile/compile_ios_protobuf.sh -a ${BUILD_ARCH}
+ fi
fi
# Compile nsync for the target iOS device architectures.
fi
export HOST_NSYNC_LIB TARGET_NSYNC_LIB
-if [[ -z "${BUILD_ARCH}" ]]; then
- # build the ios tensorflow libraries.
- tensorflow/contrib/makefile/compile_ios_tensorflow.sh -f "-O3" -h $HOST_NSYNC_LIB -n $TARGET_NSYNC_LIB
-else
+TF_CC_FLAGS="-O3"
+TF_SCRIPT_FLAGS="-h ${HOST_NSYNC_LIB} -n ${TARGET_NSYNC_LIB}"
+
+if [[ ! -z "${OPTIMIZE_FOR_GRAPH}" ]]; then
+ # arch specified so build just that
+ TF_CC_FLAGS="${TF_CC_FLAGS} -DANDROID_TYPES=__ANDROID_TYPES_FULL__ -DSELECTIVE_REGISTRATION -DSUPPORT_SELECTIVE_REGISTRATION"
+ # The Makefile checks the env var to decide which ANDROID_TYPES to build
+ export ANDROID_TYPES="-D__ANDROID_TYPES_FULL__"
+fi
+
+if [[ ! -z "${BUILD_ARCH}" ]]; then
# arch specified so build just that
- tensorflow/contrib/makefile/compile_ios_tensorflow.sh -f "-O3" -a "${BUILD_ARCH}" -h $HOST_NSYNC_LIB -n $TARGET_NSYNC_LIB
+ TF_SCRIPT_FLAGS="${TF_SCRIPT_FLAGS} -a ${BUILD_ARCH}"
fi
+# build the ios tensorflow libraries.
+echo "Building TensorFlow with flags: ${TF_SCRIPT_FLAGS} -f ${TF_CC_FLAGS}"
+tensorflow/contrib/makefile/compile_ios_tensorflow.sh ${TF_SCRIPT_FLAGS} -f "${TF_CC_FLAGS}"
+
# Creates a static universal library in
# tensorflow/contrib/makefile/gen/lib/libtensorflow-core.a
indices.shape[:-1] + params.shape[indices.shape[-1]:]
+Note that on CPU, if an out of bound index is found, an error is returned.
+On GPU, if an out of bound index is found, a 0 is stored in the
+corresponding output value.
+
Some examples below.
Simple indexing into a matrix:
<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
<img style="width:100%" src="https://www.tensorflow.org/images/Gather.png" alt>
</div>
+
+Note that on CPU, if an out of bound index is found, an error is returned.
+On GPU, if an out of bound index is found, a 0 is stored in the
+corresponding output value.
END
}
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]],
[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]]
+
+Note that on CPU, if an out of bound index is found, an error is returned.
+On GPU, if an out of bound index is found, the index is ignored.
END
}
#include "third_party/eigen3/unsupported/Eigen/CXX11/FixedPoint"
// clang-format on
-#include "tensorflow/core/platform/cpu_info.h"
#include "tensorflow/core/platform/types.h"
namespace tensorflow {
rinfo_.push_back({csinfo_.max_pool_grad,
mkl_op_registry::GetMklOpName(csinfo_.max_pool_grad),
CopyAttrsPooling, AlwaysRewrite});
+ /*
rinfo_.push_back({csinfo_.maximum,
mkl_op_registry::GetMklOpName(csinfo_.maximum),
CopyAttrsDataType, AlwaysRewrite});
rinfo_.push_back({csinfo_.mul,
mkl_op_registry::GetMklOpName(csinfo_.mul),
CopyAttrsDataType, AlwaysRewrite});
+ */
rinfo_.push_back({csinfo_.relu,
mkl_op_registry::GetMklOpName(csinfo_.relu),
CopyAttrsDataType, AlwaysRewrite});
rinfo_.push_back({csinfo_.relu_grad,
mkl_op_registry::GetMklOpName(csinfo_.relu_grad),
CopyAttrsDataType, AlwaysRewrite});
+ /*
rinfo_.push_back({csinfo_.tanh,
mkl_op_registry::GetMklOpName(csinfo_.tanh),
CopyAttrsDataType, AlwaysRewrite});
rinfo_.push_back({csinfo_.tanh_grad,
mkl_op_registry::GetMklOpName(csinfo_.tanh_grad),
CopyAttrsDataType, AlwaysRewrite});
+ */
rinfo_.push_back({csinfo_.reshape,
mkl_op_registry::GetMklOpName(csinfo_.reshape),
CopyAttrsReshape, AlwaysRewrite});
rinfo_.push_back({csinfo_.softmax,
mkl_op_registry::GetMklOpName(csinfo_.softmax),
CopyAttrsDataType, AlwaysRewrite});
+ /*
rinfo_.push_back({csinfo_.squared_difference,
mkl_op_registry::GetMklOpName(csinfo_.squared_difference),
CopyAttrsDataType, AlwaysRewrite});
rinfo_.push_back({csinfo_.sub,
mkl_op_registry::GetMklOpName(csinfo_.sub),
CopyAttrsDataType, AlwaysRewrite});
+ */
// Add info about which ops to add workspace edge to and the slots.
wsinfo_.push_back({csinfo_.lrn, csinfo_.lrn_grad, 0, 2, 1, 3});
int TileShortSide,
int size_of_t, Op op) {
// clang-format off
+
return (size_of_t == 16 && ((TileLongSide == 32 && op(TileShortSide, 4)) ||
(TileLongSide == 64 && op(TileShortSide, 4)) ||
(TileLongSide == 128 && op(TileShortSide, 4)) ||
(TileLongSide == 256 && op(TileShortSide, 8)) ||
(TileLongSide == 512 && op(TileShortSide, 4)) ||
(TileLongSide == 1024 && op(TileShortSide, 2))));
+
// clang-format on
}
// format and avoid calling eigen version.
if (!are_all_tf_inputs && !are_all_mkl_inputs) invoke_eigen = true;
- // Temporary fallback to Eigen until MKLDNN Concat performance
- // is improved. To be removed.
- invoke_eigen = true;
-
// Call Eigen library
if (invoke_eigen) {
TensorShapeList tf_input_shapes;
// It does not matter what data format we use here (NHWC or NCHW).
// We just need to ensure that output of Concat uses same data format
// as input.
- memory::desc(src_dims, MklDnnType<T>(), memory::format::nhwc);
+ memory::desc(src_dims, MklDnnType<T>(), memory::format::nchw);
srcs[k].SetUsrMem(src_md, &input_tensors[k]);
auto src_mpd = srcs[k].GetUsrMemPrimDesc();
} else {
// Again, format does not matter here. We just need to make it same as
// input format.
- dst_md = memory::desc(dst_dims, MklDnnType<T>(), memory::format::nhwc);
+ dst_md = memory::desc(dst_dims, MklDnnType<T>(), memory::format::nchw);
}
std::vector<primitive::at> inputs;
GETATTR(int64, batch_size);
GETATTR(string, compression_type);
#undef GETATTR
+
OP_REQUIRES_OK(ctx, ctx->GetAttr("compression_type", &compression_type));
RecordYielder::Options yopts;
pxd_srcs.append(src)
# Invoke cython to produce the shared object libraries.
- cpp_outs = [src.split(".")[0] + ".cpp" for src in pyx_srcs]
- native.genrule(
- name = name + "_cython_translation",
- srcs = pyx_srcs,
- outs = cpp_outs,
- cmd = ("PYTHONHASHSEED=0 $(location @cython//:cython_binary) --cplus $(SRCS)"
- # Rename outputs to expected location.
- + """ && python -c 'import shutil, sys; n = len(sys.argv); [shutil.copyfile(src.split(".")[0] + ".cpp", dst) for src, dst in zip(sys.argv[1:], sys.argv[1+n//2:])]' $(SRCS) $(OUTS)"""),
- tools = ["@cython//:cython_binary"] + pxd_srcs,
- )
+ for filename in pyx_srcs:
+ native.genrule(
+ name = filename + "_cython_translation",
+ srcs = [filename],
+ outs = [filename.split(".")[0] + ".cpp"],
+ cmd = "PYTHONHASHSEED=0 $(location @cython//:cython_binary) --cplus $(SRCS) --output-file $(OUTS)",
+ tools = ["@cython//:cython_binary"] + pxd_srcs,
+ )
shared_objects = []
for src in pyx_srcs:
ss << "*** End stack trace ***" << std::endl;
return ss.str();
+#else
+ return std::string();
#endif // defined(TF_GENERATE_BACKTRACE)
}
## Auto Detect and Advise
-tfprof analyzes profiles and generates advises for common issues.
+tfprof analyzes profiles and generates advice for common issues.
### Run Advise.
// TensorFlow uses semantic versioning, see http://semver.org/.
#define TF_MAJOR_VERSION 1
-#define TF_MINOR_VERSION 4
+#define TF_MINOR_VERSION 5
#define TF_PATCH_VERSION 0
// TF_VERSION_SUFFIX is non-empty for pre-releases (e.g. "-alpha", "-alpha.1",
// "-beta", "-rc", "-rc.1")
-#define TF_VERSION_SUFFIX ""
+#define TF_VERSION_SUFFIX "-rc0"
#define TF_STR_HELPER(x) #x
#define TF_STR(x) TF_STR_HELPER(x)
# C++ API
-Note: By default [tensorflow.org](http://tensorflow.org) shows docs for the
+Note: By default [tensorflow.org](https://www.tensorflow.org) shows docs for the
most recent stable version. The instructions in this doc require building from
source. You will probably want to build from the `master` version of tensorflow.
You should, as a result, be sure you are following the
# Adding a New Op
-Note: By default [tensorflow.org](http://tensorflow.org) shows docs for the
+Note: By default [www.tensorflow.org](https://www.tensorflow.org) shows docs for the
most recent stable version. The instructions in this doc require building from
source. You will probably want to build from the `master` version of tensorflow.
You should, as a result, be sure you are following the
operating systems:
* MacOS X 10.11 (El Capitan) or later.
- * Ubuntu 14.04 or later
+ * Ubuntu 16.04 or later
* Windows 7 or later.
Although you might be able to install TensorFlow on other laptop or desktop
OS="linux" # Change to "darwin" for macOS
TARGET_DIRECTORY="/usr/local"
curl -L \
- "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-${TF_TYPE}-${OS}-x86_64-1.4.0.tar.gz" |
+ "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-${TF_TYPE}-${OS}-x86_64-1.5.0-rc0.tar.gz" |
sudo tar -C $TARGET_DIRECTORY -xz
The `tar` command extracts the TensorFlow C library into the `lib`
TF_TYPE="cpu" # Change to "gpu" for GPU support
TARGET_DIRECTORY='/usr/local'
curl -L \
- "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-${TF_TYPE}-$(go env GOOS)-x86_64-1.4.0.tar.gz" |
+ "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-${TF_TYPE}-$(go env GOOS)-x86_64-1.5.0-rc0.tar.gz" |
sudo tar -C $TARGET_DIRECTORY -xz
The `tar` command extracts the TensorFlow C library into the `lib`
(and we only support) these instructions on machines meeting the
following requirements:
- * Ubuntu 14.04 or higher; 64-bit, x86
+ * Ubuntu 16.04 or higher; 64-bit, x86
* macOS X 10.11 (El Capitan) or higher
* Windows 7 or higher; 64-bit, x86
<dependency>
<groupId>org.tensorflow</groupId>
<artifactId>tensorflow</artifactId>
- <version>1.4.0</version>
+ <version>1.5.0-rc0</version>
</dependency>
```
<dependency>
<groupId>org.tensorflow</groupId>
<artifactId>tensorflow</artifactId>
- <version>1.4.0</version>
+ <version>1.5.0-rc0</version>
</dependency>
</dependencies>
</project>
Take the following steps to install TensorFlow for Java on Linux or macOS:
1. Download
- [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.4.0.jar),
+ [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.5.0-rc0.jar),
which is the TensorFlow Java Archive (JAR).
2. Decide whether you will run TensorFlow for Java on CPU(s) only or with
OS=$(uname -s | tr '[:upper:]' '[:lower:]')
mkdir -p ./jni
curl -L \
- "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-${TF_TYPE}-${OS}-x86_64-1.4.0.tar.gz" |
+ "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-${TF_TYPE}-${OS}-x86_64-1.5.0-rc0.tar.gz" |
tar -xz -C ./jni
### Install on Windows
Take the following steps to install TensorFlow for Java on Windows:
1. Download
- [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.4.0.jar),
+ [libtensorflow.jar](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-1.5.0-rc0.jar),
which is the TensorFlow Java Archive (JAR).
2. Download the following Java Native Interface (JNI) file appropriate for
- [TensorFlow for Java on Windows](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-cpu-windows-x86_64-1.4.0.zip).
+ [TensorFlow for Java on Windows](https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow_jni-cpu-windows-x86_64-1.5.0-rc0.zip).
3. Extract this .zip file.
downloaded `.jar` in your `classpath` by using the `-cp` compilation flag
as follows:
-<pre><b>javac -cp libtensorflow-1.4.0.jar HelloTF.java</b></pre>
+<pre><b>javac -cp libtensorflow-1.5.0-rc0.jar HelloTF.java</b></pre>
### Running
For example, the following command line executes the `HelloTF` program on Linux
and macOS X:
-<pre><b>java -cp libtensorflow-1.4.0.jar:. -Djava.library.path=./jni HelloTF</b></pre>
+<pre><b>java -cp libtensorflow-1.5.0-rc0.jar:. -Djava.library.path=./jni HelloTF</b></pre>
And the following command line executes the `HelloTF` program on Windows:
-<pre><b>java -cp libtensorflow-1.4.0.jar;. -Djava.library.path=jni HelloTF</b></pre>
+<pre><b>java -cp libtensorflow-1.5.0-rc0.jar;. -Djava.library.path=jni HelloTF</b></pre>
If the program prints <tt>Hello from <i>version</i></tt>, you've successfully
installed TensorFlow for Java and are ready to use the API. If the program
following requirements:
* 64-bit desktops or laptops
- * Ubuntu 14.04 or higher
+ * Ubuntu 16.04 or higher
## Determine which TensorFlow to install
Virtualenv environment:
<pre>(tensorflow)$ <b>pip3 install --upgrade \
- https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.4.0-cp34-cp34m-linux_x86_64.whl</b></pre>
+ https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.5.0rc0-cp34-cp34m-linux_x86_64.whl</b></pre>
If you encounter installation problems, see
[Common Installation Problems](#common_installation_problems).
<pre>
$ <b>sudo pip3 install --upgrade \
- https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.4.0-cp34-cp34m-linux_x86_64.whl</b>
+ https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.5.0rc0-cp34-cp34m-linux_x86_64.whl</b>
</pre>
If this step fails, see
<pre>
(tensorflow)$ <b>pip install --ignore-installed --upgrade \
- https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.4.0-cp34-cp34m-linux_x86_64.whl</b></pre>
+ https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.5.0rc0-cp34-cp34m-linux_x86_64.whl</b></pre>
<a name="ValidateYourInstallation"></a>
CPU only:
<pre>
-https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.4.0-cp27-none-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.5.0rc0-cp27-none-linux_x86_64.whl
</pre>
GPU support:
<pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.4.0-cp27-none-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.5.0rc0-cp27-none-linux_x86_64.whl
</pre>
Note that GPU support requires the NVIDIA hardware and software described in
CPU only:
<pre>
-https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.4.0-cp34-cp34m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.5.0rc0-cp34-cp34m-linux_x86_64.whl
</pre>
GPU support:
<pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.4.0-cp34-cp34m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.5.0rc0-cp34-cp34m-linux_x86_64.whl
</pre>
Note that GPU support requires the NVIDIA hardware and software described in
CPU only:
<pre>
-https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.4.0-cp35-cp35m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.5.0rc0-cp35-cp35m-linux_x86_64.whl
</pre>
GPU support:
<pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.4.0-cp35-cp35m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.5.0rc0-cp35-cp35m-linux_x86_64.whl
</pre>
CPU only:
<pre>
-https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.4.0-cp36-cp36m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.5.0rc0-cp36-cp36m-linux_x86_64.whl
</pre>
GPU support:
<pre>
-https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.4.0-cp36-cp36m-linux_x86_64.whl
+https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.5.0rc0-cp36-cp36m-linux_x86_64.whl
</pre>
TensorFlow in the active Virtualenv is as follows:
<pre> $ <b>pip3 install --upgrade \
- https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.4.0-py2-none-any.whl</b></pre>
+ https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.5.0rc0-py2-none-any.whl</b></pre>
If you encounter installation problems, see
[Common Installation Problems](#common-installation-problems).
issue the following command:
<pre> $ <b>sudo pip3 install --upgrade \
- https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.4.0-py2-none-any.whl</b> </pre>
+ https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.5.0rc0-py2-none-any.whl</b> </pre>
If the preceding command fails, see
[installation problems](#common-installation-problems).
TensorFlow for Python 2.7:
<pre> (<i>targetDirectory</i>)$ <b>pip install --ignore-installed --upgrade \
- https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.4.0-py2-none-any.whl</b></pre>
+ https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.5.0rc0-py2-none-any.whl</b></pre>
<a name="ValidateYourInstallation"></a>
<pre>
-https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.4.0-py2-none-any.whl
+https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.5.0rc0-py2-none-any.whl
</pre>
<pre>
-https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.4.0-py3-none-any.whl
+https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.5.0rc0-py3-none-any.whl
</pre>
following:
* [Bazel on Windows](https://bazel.build/versions/master/docs/windows.html)
-* [TensorFlow CMake build](https://github.com/tensorflow/tensorflow/tree/r0.12/tensorflow/contrib/cmake)
+* [TensorFlow CMake build](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/cmake)
+Note: Starting from 1.6 release, our prebuilt binaries will use AVX
+instructions. Older CPUs may not be able to execute these binaries.
## Determine which TensorFlow to install
The filename of the `.whl` file depends on your platform.
For example, the following command will install the pip package
-for TensorFlow 1.4.0 on Linux:
+for TensorFlow 1.5.0rc0 on Linux:
<pre>
-$ <b>sudo pip install /tmp/tensorflow_pkg/tensorflow-1.4.0-py2-none-any.whl</b>
+$ <b>sudo pip install /tmp/tensorflow_pkg/tensorflow-1.5.0rc0-py2-none-any.whl</b>
</pre>
## Validate your installation
python tensorflow/examples/label_image/label_image.py \
--graph=/tmp/output_graph.pb --labels=/tmp/output_labels.txt \
--input_layer=input \
---output_layer=final_result:0 \
+--output_layer=final_result \
--input_height=224 --input_width=224 \
--input_mean=128 --input_std=128 \
--image=$HOME/flower_photos/daisy/21652746_cc379e0eea_m.jpg
srcs = ["framework/dtypes_test.py"],
main = "framework/dtypes_test.py",
srcs_version = "PY2AND3",
+ tags = ["no_windows"],
deps = [
":framework_for_generated_wrappers",
":framework_test_lib",
size = "small",
srcs = ["lib/core/bfloat16_test.py"],
srcs_version = "PY2AND3",
+ tags = ["no_windows"],
deps = [
":client_testlib",
":lib",
self, sess, watch_fn=watch_fn, thread_name_filter=thread_name_filter,
pass_through_operrors=pass_through_operrors)
+ session_root = os.path.expanduser(session_root)
if gfile.Exists(session_root):
if not gfile.IsDirectory(session_root):
raise ValueError(
if not dump_root:
self._dump_root = tempfile.mktemp(prefix=_DUMP_ROOT_PREFIX)
else:
+ dump_root = os.path.expanduser(dump_root)
if os.path.isfile(dump_root):
raise ValueError("dump_root path points to a file: %s" % dump_root)
elif os.path.isdir(dump_root) and os.listdir(dump_root):
def val_and_grad_function(f, params=None):
- """Returns a function that computes f and is derivative w.r.t. params.
+ """Returns a function that computes f and its derivative w.r.t. params.
Example:
```python
mock_executor.assert_called_with(estimator=mock_est,
train_spec=mock_train_spec,
eval_spec=mock_eval_spec)
- mock_executor_instance.run.assert_called()
+ self.assertTrue(mock_executor_instance.run.called)
def test_error_out_if_evaluator_task_id_is_non_zero(self):
tf_config = {
tf.shape(tf.concat([t3, t4], 0)) # [4, 3]
tf.shape(tf.concat([t3, t4], 1)) # [2, 6]
```
+ As in Python, the `axis` could also be negative numbers. Negative `axis`
+ are interpreted as counting from the end of the rank, i.e.,
+ `axis + rank(values)`-th dimension.
+
+ For example:
+
+ ```python
+ t1 = [[[1, 2], [2, 3]], [[4, 4], [5, 3]]]
+ t2 = [[[7, 4], [8, 4]], [[2, 10], [15, 11]]]
+ tf.concat([t1, t2], -1)
+ ```
+
+ would produce:
+
+ ```python
+ [[[ 1, 2, 7, 4],
+ [ 2, 3, 8, 4]],
+
+ [[ 4, 4, 2, 10],
+ [ 5, 3, 15, 11]]]
+ ```
Note: If you are concatenating along a new axis consider using stack.
E.g.
Args:
values: A list of `Tensor` objects or a single `Tensor`.
axis: 0-D `int32` `Tensor`. Dimension along which to concatenate. Must be
- in the range `[-rank(values), rank(values))`.
+ in the range `[-rank(values), rank(values))`. As in Python, indexing
+ for axis is 0-based. Positive axis in the rage of
+ `[0, rank(values))` refers to `axis`-th dimension. And negative axis
+ refers to `axis + rank(values)`-th dimension.
name: A name for the operation (optional).
Returns:
def _compute_dx_and_dy(x, y, y_shape):
- """Returns a node to compute gradient of x wrt y."""
+ """Returns a node to compute gradient of y wrt x."""
# We make up a dy so that we can compute the gradients. We don't really use
# the value of dy -- we will always feed it. We need to add an identity node
# so that we can always feed it properly. Otherwise, for the Add operation,
with x.graph.as_default():
dy_orig = constant_op.constant(1.0, shape=y_shape, dtype=y.dtype)
dy = array_ops.identity(dy_orig)
- # We compute the gradients for x wrt. y
+ # We compute the gradients for y wrt. x
grads = gradients.gradients(y, x, dy)
assert len(grads) == 1
return grads[0], dy_orig
Args:
image : A Tensor.
- gamma : A scalar. Non negative real number.
- gain : A scalar. The constant multiplier.
+ gamma : A scalar or tensor. Non negative real number.
+ gain : A scalar or tensor. The constant multiplier.
Returns:
A Tensor. Gamma corrected output image.
"""
with ops.op_scope([image, gamma, gain], None, 'adjust_gamma'):
- # Convert pixel value to DT_FLOAT for computing adjusted image
+ # Convert pixel value to DT_FLOAT for computing adjusted image.
img = ops.convert_to_tensor(image, name='img', dtype=dtypes.float32)
- # Keep image dtype for computing the scale of corresponding dtype
+ # Keep image dtype for computing the scale of corresponding dtype.
image = ops.convert_to_tensor(image, name='image')
- if gamma < 0:
- raise ValueError('Gamma should be a non-negative real number')
- # scale = max(dtype) - min(dtype)
+ assert_op = _assert(gamma >= 0, ValueError,
+ 'Gamma should be a non-negative real number.')
+ if assert_op:
+ gamma = control_flow_ops.with_dependencies(assert_op, gamma)
+
+ # scale = max(dtype) - min(dtype).
scale = constant_op.constant(image.dtype.limits[1] - image.dtype.limits[0],
dtype=dtypes.float32)
- # According to the definition of gamma correction
+ # According to the definition of gamma correction.
adjusted_img = (img / scale) ** gamma * scale * gain
return adjusted_img
self.assertAllClose(y_tf, y_np, 1e-6)
+ def test_adjust_gamma_less_zero(self):
+ """White image should be returned for gamma equal to zero"""
+ with self.test_session():
+ x_data = np.random.uniform(0, 255, (8, 8))
+ x_np = np.array(x_data, dtype=np.float32)
+
+ x = constant_op.constant(x_np, shape=x_np.shape)
+
+ err_msg = 'Gamma should be a non-negative real number.'
+
+ try:
+ image_ops.adjust_gamma(x, gamma=-1)
+ except Exception as e:
+ if err_msg not in str(e):
+ raise
+ else:
+ raise AssertionError("Exception not raised: %s" % err_msg)
+
+ def test_adjust_gamma_less_zero_tensor(self):
+ """White image should be returned for gamma equal to zero"""
+ with self.test_session():
+ x_data = np.random.uniform(0, 255, (8, 8))
+ x_np = np.array(x_data, dtype=np.float32)
+
+ x = constant_op.constant(x_np, shape=x_np.shape)
+ y = constant_op.constant(-1.0, dtype=dtypes.float32)
+
+ image = image_ops.adjust_gamma(x, gamma=y)
+
+ err_msg = 'Gamma should be a non-negative real number.'
+ try:
+ image.eval()
+ except Exception as e:
+ if err_msg not in str(e):
+ raise
+ else:
+ raise AssertionError("Exception not raised: %s" % err_msg)
+
def test_adjust_gamma_zero(self):
"""White image should be returned for gamma equal to zero"""
with self.test_session():
# Build appropriately shaped IndexedSlices
handle = op.inputs[0]
indices = op.inputs[1]
- if context.in_graph_mode():
- # Walk graph back until the original handle is found.
- # TODO(apassos): implement this for EAGER mode.
- while handle.op.type != "VarHandleOp":
- handle = handle.op.inputs[0]
params_shape = gen_resource_variable_ops.variable_shape(handle)
size = array_ops.expand_dims(array_ops.size(indices), 0)
values_shape = array_ops.concat([size, params_shape[1:]], 0)
pip3.5 install scipy==0.18.1
-pip3.5 install scikit-learn==0.18.1
+pip3.5 install scikit-learn==0.19.1
# pandas required by `inflow`
pip3 install pandas==0.19.2
./configure
make altinstall
-pip3.6 -V
-which pip3.6
ln -s /usr/local/bin/pip3.6 /usr/local/bin/pip3
pip3 install --upgrade virtualenv
pip3 install scipy==0.18.1
-pip3 install scikit-learn==0.18.1
+pip3 install scikit-learn==0.19.1
# pandas required by `inflow`
pip3 install pandas==0.19.2
# Download and build TensorFlow.
WORKDIR /tensorflow
-RUN git clone --branch=r1.4 --depth=1 https://github.com/tensorflow/tensorflow.git .
+RUN git clone --branch=r1.5 --depth=1 https://github.com/tensorflow/tensorflow.git .
# TODO(craigcitro): Don't install the pip package, since it makes it
# more difficult to experiment with local changes. Instead, just add
LABEL maintainer="Clayne Robison<clayne.b.robison@intel.com>"
# These arguments are parameterized. Use --build-args to override.
-ARG TF_BRANCH=r1.4
+ARG TF_BRANCH=r1.5
ARG WHL_DIR=/whl
RUN apt-get update && apt-get install -y --no-install-recommends \
RUN LD_LIBRARY_PATH=${LD_LIBRARY_PATH} \
bazel build --config=mkl \
--config="opt" \
- --copt="-march=native" \
+ --copt="-march=broadwell" \
--copt="-O3" \
//tensorflow/tools/pip_package:build_pip_package && \
mkdir ${WHL_DIR} && \
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||\n\
\n "\
> /etc/motd
-
-CMD ["/bin/bash"]
# Download and build TensorFlow.
WORKDIR /tensorflow
-RUN git clone --branch=r1.4 --depth=1 https://github.com/tensorflow/tensorflow.git .
+RUN git clone --branch=r1.5 --depth=1 https://github.com/tensorflow/tensorflow.git .
# Configure the build for our CUDA configuration.
ENV CI_BUILD_PYTHON python
"""Help include git hash in tensorflow bazel build.
This creates symlinks from the internal git repository directory so
-that the build system can see changes in the version state.
+that the build system can see changes in the version state. We also
+remember what branch git was on so when the branch changes we can
+detect that the ref file is no longer correct (so we can suggest users
+run ./configure again).
NOTE: this script is only used in opensource.
if not data["git"]:
git_version = b"unknown"
else:
- old_branch = data["branch"]
+ old_branch = data["branch"]
new_branch = parse_branch_ref(head_symlink)
if new_branch != old_branch:
- print("Warning, run ./configure again, to get __git_version__ to record "
- "correct version")
- git_version = get_git_version(data["path"])+'-inconsistent-git-version'
- else:
- git_version = get_git_version(data["path"])
+ raise RuntimeError(
+ "Run ./configure again, branch was '%s' but is now '%s'" %
+ (old_branch, new_branch))
+ git_version = get_git_version(data["path"])
write_version_info(dest_file, git_version)
"//tensorflow:tensorflow_py",
"//tensorflow/contrib/boosted_trees:boosted_trees_pip",
"//tensorflow/contrib/cluster_resolver:cluster_resolver_pip",
+ "//tensorflow/contrib/data/python/kernel_tests:dataset_serialization_test",
"//tensorflow/contrib/data/python/ops:prefetching_py",
"//tensorflow/contrib/eager/python/examples:examples_pip",
"//tensorflow/contrib/eager/python:checkpointable",
# This version string is semver compatible, but incompatible with pip.
# For pip, we will remove all '-' characters from this string, and use the
# result for pip.
-_VERSION = '1.4.0'
+_VERSION = '1.5.0-rc0'
REQUIRED_PACKAGES = [
'absl-py >= 0.1.6',
tf_http_archive(
name = "eigen_archive",
urls = [
- "https://mirror.bazel.build/bitbucket.org/eigen/eigen/get/c2947c341c68.tar.gz",
- "https://bitbucket.org/eigen/eigen/get/c2947c341c68.tar.gz",
+ "https://mirror.bazel.build/bitbucket.org/eigen/eigen/get/034b6c3e1017.tar.gz",
+ "https://bitbucket.org/eigen/eigen/get/034b6c3e1017.tar.gz",
],
- sha256 = "f21f8ab8a8dbcb91cd0deeade19a043f47708d0da7a4000164cdf203b4a71e34",
- strip_prefix = "eigen-eigen-c2947c341c68",
+ sha256 = "0a8ac1e83ef9c26c0e362bd7968650b710ce54e2d883f0df84e5e45a3abe842a",
+ strip_prefix = "eigen-eigen-034b6c3e1017",
build_file = str(Label("//third_party:eigen.BUILD")),
)
-"""Repository rule for Git autoconfiguration."""
+"""Repository rule for Git autoconfiguration.
+
+`git_configure` depends on the following environment variables:
+
+ * `PYTHON_BIN_PATH`: location of python binary.
+"""
+
+_PYTHON_BIN_PATH = "PYTHON_BIN_PATH"
+
+def _fail(msg):
+ """Output failure message when auto configuration fails."""
+ red = "\033[0;31m"
+ no_color = "\033[0m"
+ fail("%sGit Configuration Error:%s %s\n" % (red, no_color, msg))
+
+def _get_python_bin(repository_ctx):
+ """Gets the python bin path."""
+ python_bin = repository_ctx.os.environ.get(_PYTHON_BIN_PATH)
+ if python_bin != None:
+ return python_bin
+ python_bin_path = repository_ctx.which("python")
+ if python_bin_path != None:
+ return str(python_bin_path)
+ _fail("Cannot find python in PATH, please make sure " +
+ "python is installed and add its directory in PATH, or --define " +
+ "%s='/something/else'.\nPATH=%s" % (
+ _PYTHON_BIN_PATH, repository_ctx.os.environ.get("PATH", "")))
+
def _git_conf_impl(repository_ctx):
repository_ctx.template(
Label("@org_tensorflow//tensorflow/tools/git:gen_git_source.py"))
generated_files_path = repository_ctx.path("gen")
- repository_ctx.execute([
+ result = repository_ctx.execute([
+ _get_python_bin(repository_ctx),
python_script_path, "--configure", tensorflow_root_path,
"--gen_root_path", generated_files_path], quiet=False)
+ if not result.return_code == 0:
+ _fail(result.stderr)
+
+
git_configure = repository_rule(
implementation = _git_conf_impl,
+ environ = [
+ _PYTHON_BIN_PATH,
+ ],
)
def _is_windows(ctx):
return ctx.os.name.lower().find("windows") != -1
+def _wrap_bash_cmd(ctx, cmd):
+ if _is_windows(ctx):
+ bazel_sh = _get_env_var(ctx, "BAZEL_SH")
+ if not bazel_sh:
+ fail("BAZEL_SH environment variable is not set")
+ cmd = [bazel_sh, "-c", " ".join(cmd)]
+ return cmd
+
def _get_env_var(ctx, name):
if name in ctx.os.environ:
return ctx.os.environ[name]
# Don't check patch on Windows, because patch is only available under bash.
if not _is_windows(ctx) and not ctx.which("patch"):
fail("patch command is not found, please install it")
- cmd = ["patch", "-p1", "-d", ctx.path("."), "-i", ctx.path(patch_file)]
- if _is_windows(ctx):
- bazel_sh = _get_env_var(ctx, "BAZEL_SH")
- if not bazel_sh:
- fail("BAZEL_SH environment variable is not set")
- cmd = [bazel_sh, "-c", " ".join(cmd)]
+ cmd = _wrap_bash_cmd(
+ ctx, ["patch", "-p1", "-d", ctx.path("."), "-i", ctx.path(patch_file)])
_execute_and_check_ret_code(ctx, cmd)
def _apply_delete(ctx, paths):
fail("refusing to rm -rf path starting with '/': " + path)
if ".." in path:
fail("refusing to rm -rf path containing '..': " + path)
- _execute_and_check_ret_code(
- ctx, ["rm", "-rf"] + [ctx.path(path) for path in paths])
+ cmd = _wrap_bash_cmd(ctx, ["rm", "-rf"] + [ctx.path(path) for path in paths])
+ _execute_and_check_ret_code(ctx, cmd)
def _tf_http_archive(ctx):
if ("mirror.bazel.build" not in ctx.attr.urls[0] or
projects / platform / upstream / tensorflow.git / commitdiff